Trouble with syntax for template-template-templates - c++

Question

I'm writing a meta-function MultipartitionWithUnaryPredicates, used in the form
MultipartitionWithUnaryPredicates<Pack<Args...>, UnaryPredicates...>::type
so that a template pack of types will be multipartitioned by a pack UnaryPredicates... of unary predicates, with the partitions in the order of the unary predicates listed. If you're not sure what I mean, just check out main() in the code below (which works correctly):
#include <iostream>
#include <type_traits>
#include <typeInfo>
template <template <typename> class, typename, typename, typename> struct Helper;
template <template <typename> class UnaryPredicate, template <typename...> class P, typename... Types1, typename... Types2>
struct Helper<UnaryPredicate, P<>, P<Types1...>, P<Types2...>> {
using type = P<Types1..., Types2...>;
using head = P<Types1...>;
using tail = P<Types2...>;
};
template <template <typename> class UnaryPredicate, template <typename...> class P, typename First, typename... Rest, typename... Types1, typename... Types2>
struct Helper<UnaryPredicate, P<First, Rest...>, P<Types1...>, P<Types2...>> : std::conditional<UnaryPredicate<First>::value,
Helper<UnaryPredicate, P<Rest...>, P<Types1..., First>, P<Types2...>>,
Helper<UnaryPredicate, P<Rest...>, P<Types1...>, P<Types2..., First>>
>::type {};
template <typename, template <typename> class> struct PartitionWithUnaryPredicate;
template <template <typename> class UnaryPredicate, template <typename...> class P, typename... Ts>
struct PartitionWithUnaryPredicate<P<Ts...>, UnaryPredicate> : Helper<UnaryPredicate, P<Ts...>, P<>, P<>> {};
template <typename, template <typename> class...> struct MultipartitionWithUnaryPredicates;
template <typename Pack, template <typename> class UnaryPredicate>
struct MultipartitionWithUnaryPredicates<Pack, UnaryPredicate> : PartitionWithUnaryPredicate<Pack, UnaryPredicate> {};
template <typename, typename> struct Join;
template <template <typename...> class P, typename... Types1, typename... Types2>
struct Join<P<Types1...>, P<Types2...>> {
using type = P<Types1..., Types2...>;
};
//template <template <typename, template <typename> class> class Pack, typename... Ts>
//struct JoinSpecial : Join<typename Pack::head, typename MultipartitionWithUnaryPredicates<typename Pack::tail, Ts...>::type> {};
template <typename Pack, template <typename> class First, template <typename> class... Rest>
struct MultipartitionWithUnaryPredicates<Pack, First, Rest...> : Join<typename PartitionWithUnaryPredicate<Pack, First>::head, typename MultipartitionWithUnaryPredicates<typename PartitionWithUnaryPredicate<Pack, First>::tail, Rest...>::type> {};
// The above can be improved, since PartitionWithUnaryPredicate<Pack, First> is being computed twice.
// -----------------------------------------------------------------------------------------------------------------------------------------------
// Testing:
template <typename...> struct Pack {};
template <typename Last>
struct Pack<Last> {
static void print() {std::cout << typeid(Last).name() << std::endl;}
};
template <typename First, typename ... Rest>
struct Pack<First, Rest...> {
static void print() {std::cout << typeid(First).name() << ' '; Pack<Rest...>::print();}
};
struct Thing {};
struct Blob { Blob(Blob&&){} }; // Copy constructor deleted.
struct Object {};
enum MyEnum {x, y, z};
enum HerEnum {xx, yy, zz};
int main() {
MultipartitionWithUnaryPredicates<Pack<int, Thing, double, short, Blob, char, MyEnum, long, Object, float, HerEnum>,
std::is_integral>::type b;
b.print(); // int short char long Thing double Blob MyEnum Object float HerEnum
MultipartitionWithUnaryPredicates<Pack<int, Thing, double, short, Blob, char, MyEnum, long, Object, float, HerEnum>,
std::is_integral, std::is_enum>::type c;
c.print(); // int short char long MyEnum HerEnum Thing double Blob Object float
MultipartitionWithUnaryPredicates<Pack<int, Thing, double, short, Blob, char, MyEnum, long, Object, float, HerEnum>,
std::is_integral, std::is_enum, std::is_arithmetic>::type d;
d.print(); // int short char long MyEnum HerEnum double float Thing Blob Object
MultipartitionWithUnaryPredicates<Pack<int, Thing, double, short, Blob, char, MyEnum, long, Object, float, HerEnum>,
std::is_integral, std::is_enum, std::is_arithmetic, std::is_member_pointer, std::is_copy_constructible>::type e;
e.print(); // int short char long MyEnum HerEnum double float Thing Object Blob
}
The problem is trying to refine the above code.
PartitionWithUnaryPredicate<Pack, First>
is being computed twice, I'm trying to define JoinSpecial that will use it just once. But I can't get the syntax correct.
template <template <typename, template <typename> class> class Pack, typename... Ts>
struct JoinSpecial : Join<typename Pack::head, typename MultipartitionWithUnaryPredicates<typename Pack::tail, Ts...>::type> {};
does not compile. The template type PartitionWithUnaryPredicate is of type template <typename, template <typename> class> class is it not?
Update:
Thanks to Angew's tip, I got the syntax correct now:
template <template <typename, template <typename> class> class P, typename Pack, template <typename> class Pred, template <typename> class... Ts>
struct JoinSpecial : Join<typename P<Pack, Pred>::head, typename MultipartitionWithUnaryPredicates<typename P<Pack, Pred>::tail, Ts...>::type> {};
template <typename Pack, template <typename> class First, template <typename> class... Rest>
struct MultipartitionWithUnaryPredicates<Pack, First, Rest...> : JoinSpecial<PartitionWithUnaryPredicate, Pack, First, Rest...> {};
Now everything works correctly--my first time using template-template-templates, which I must say looks quite ugly.

Answer 1

In your definition of JoinSpecial, Pack is a class template. Then, in specifying template arguments to Join, you have typename Pack::head and typename Pack::tail. But Pack is a template, not a class — you need to supply template arguments for Pack.