What can you do with templates with zero template parameters?

Question

I learned some time ago that you can create templates with zero parameters. While it is not possible to create them directly, you can use member templates

template<typename ...T> 
struct Maker {
   template<T...>
   struct HasNParams { };
};

Maker<>::HasNParams<> hnp;

I wonder whether this is intended to be well-formed and what you can do with these beasts. Can you pass them as template arguments, and create explicit specializations (I guess the only scenario is for the empty case then)?

Answer 1

At the risk of sounding obvious, ending recursive instantiation.

template<typename Arg, typename ...T> 
struct Maker : public Maker<T...>
{
   template<T...>
   struct HasNmin1Params { };
};

The point here is that the actual argument list to Maker isn't empty, but we only use N-1 arguments in HasNminOneParams.

Answer 2

Consider the following class template:

template <typename... > struct typelist { };

This is the metaprogramming equivalent of a container. And in the same way that it is useful to have an empty vector or map, it is useful to have an empty typelist. That is, something of type typelist<>. Here are two example use-cases for such a construct.

It could be the termination condition for type recursion:

void foo(typelist<> ) { }

template <typename T, typename... Ts>
void foo(typelist<T, Ts...> ) {
    bar<T>();
    foo(typelist<Ts...>{});
}

It could be a "return" value for a metafunction, indicating a failure condition.

template <typename F, typename T>
struct filter_one
: std::conditional_t<F::template apply<T>::value,
                     typelist<T>, 
                     typelist<>>
{ };

Which is a helper we could use to write a typelist filter metafunction:

template <typename F, typename TL>
struct filter;

template <typename F, typename... Ts>
struct filter<F, typelist<Ts...>>
: concat_t<filter_one<F, Ts>...>
{ };

Both of those are very useful features of typelist<>, and that's just the one class template.