Why can't you template a template?

Question

In C++ there are 2 template types (to my knowledge): template classes and template functions. Why is it not possible to have a template of template? (be it class, or function, or other template). Has it ever been considered in standards? Does it break C++ syntax/spirit in a way? I know it may sound crazy, and it's easy to get around.

What is possible with C++:

template<bool b>
class TemplateDependingOnBool
{
public:
  template<typename T>
  class TheTemplateWeWant{};
}

What would be great:

template<bool b>
template<typename T>
class TheTemplateWeWant{};

and call it in a policy-based style (that's where it's really interesting):

template<typename T, template<typename> class ThePolicy = TheTemplateWeWant<true> >
class Foo {};

The way it's possible to do now is to use:

template<typename T,
  template<typename> class ThePolicy = TemplateDependingOnBool<true>::TheTemplateWeWant >
class Foo{};

which is not very elegant.

EDIT:
I know I can template on 2 parameters. The goal is to use the underlying template class (the templated template) as something by itself, be it in a template alias or a template template parameter (as shown in my example). Policy-based design is a reference to Andrei Alexandrescu's Modern C++ Design, which is the main reason why the feature I'm asking might be useful (because templates are used as template parameters).

Answer 1

With C++11, you're wrong in assuming only two types of templates. There are also type aliases which allow

template <bool b, typename T>
class TheTemplateWeWant { ... };

template<typename T>
using ThePolicy = TheTemplateWeWant<true, T>

Answer 2

If I'm understanding what you're asking correctly (and I'm not entirely clear on your question), then you could write your template taking two parameters:

template <bool b, typename T>
class TheTemplateWeWant { ... };

add a metafunction to partially apply the bool:

template <bool b>
struct PartiallyWant {
    template <typename T>
    using type = TheTemplateWeWant<b, T>;
};

and then pass that as your policy:

template<typename T,
         template<typename> class ThePolicy = PartiallyWant<true>::type >
class Foo { ... };

Foo<char, PartiallyWant<false>::type> foo;

---

So why not just layer the templates like you propose? The simple answer is that there's no reason to. If TheTemplateWeWant has two template parameters (bool b and typename T, regardless of whether it's an "inner" class or not), then we should express it as such. And if we want to only apply one type or the other, that's something that has fewer use-cases than a general template while also being solvable with just a few lines of boilerplate. Additionally, what if we had such a feature, and now I want to partially apply the T instead of the b? With a few lines of boilerplate I can again accomplish the same thing, but with the layering this would be impossible.