Проблемы с синтаксисом шаблонов-шаблоны-шаблоны

Question

Я пишу метафункцию MultipartitionWithUnaryPredicates, используемую в виде

MultipartitionWithUnaryPredicates<Pack<Args...>, UnaryPredicates...>::type 

так что шаблон пакет типов будет multipartitioned стаей UnaryPredicates... одинарных предикаты , с разбиениями в порядке перечисления унарных предикатов. Если вы не уверены, что я имею в виду, просто проверить основной() в коде ниже (который работает правильно):

#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 
} 

Проблема пытается уточнить код выше.

PartitionWithUnaryPredicate<Pack, First> 

в настоящее время вычисляется дважды, я пытаюсь определить JoinSpecial, который будет использовать его только один раз. Но я не могу правильно получить синтаксис.

template <template <typename, template <typename> class> class Pack, typename... Ts> 
struct JoinSpecial : Join<typename Pack::head, typename MultipartitionWithUnaryPredicates<typename Pack::tail, Ts...>::type> {}; 

не компилируется. Тип шаблона PartitionWithUnaryPredicate имеет тип template <typename, template <typename> class> class не так ли?

Update: Благодаря кончике Angew, я получил синтаксис правильный прямо сейчас:

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...> {}; 

Теперь все работает правильно - мой первый раз с помощью шаблонов-шаблонов-шаблонов, которые я должен сказать, выглядит довольно некрасиво.

Answer 1

В вашем определении JoinSpecial, Pack - шаблон класса. Затем, задав аргументы шаблона Join, у вас есть typename Pack::head и typename Pack::tail. Но Pack - это шаблон, а не класс —, вам нужно указать аргументы шаблона для Pack.