How to alias a nested template class with variadic parameter packs

Question

Is there any way one can alias a nested template class with a using keyword? Something like this

template <typename... Types>
struct Something {
    template <typename... TypesTwo>
    struct Another {};
};

template <typename... Types>
template <typename... TypesTwo>
using Something_t = typename Something<Types...>::template Another<TypesTwo...>;

int main() {
    Something_t<int><double>{};
    return 0;
}

This answer template template alias to a nested template? shows a way to do that but that will no longer work if both the parameter packs are variadic, as the compiler will not know where to start and where to end the type lists.

Why do you need such specific way? You can change code slightly and use similar code `Something_t::Something2` — Alex Aparin, Mar 15 '17 at 16:11
@LmTinyToon It is possible to do without it but I am just wondering if it is a thing. — Curious, Mar 15 '17 at 16:15
I don't know about an alias, but you might be able to build something similar using an old-school struct-with-typedef by using a delimiter type. — cdhowie, Mar 15 '17 at 16:36
@cdhowie you mean a delimiter in between the type lists to separate them? — Curious, Mar 15 '17 at 16:37
@Curious I got my example working with the same approach as the posted answer, just using a custom `template struct pack;` instead of using `std::tuple`. — cdhowie, Mar 15 '17 at 16:47

score 2 · Answer 1 · answered Mar 15 '17 at 16:42

Not exactly what you asked but... if you can wrap your variadic type lists as arguments of tuples (or similar classes)...

#include <tuple>

template <typename ... Types>
struct Something
 {
   template <typename ... TypesTwo>
   struct Another {};
 };

template <typename, typename>
struct variadicWrapper;

template <typename ... Ts1, typename ... Ts2>
struct variadicWrapper<std::tuple<Ts1...>, std::tuple<Ts2...>>
 { using type = typename Something<Ts1...>::template Another<Ts2...>; };

template <typename T1, typename T2>
using Something_t = typename variadicWrapper<T1, T2>::type;

int main()
 {
   Something_t<std::tuple<int>, std::tuple<double>>{};
 }

score 0 · Answer 2 · answered Mar 15 '17 at 16:55

Not a standalone answer, but an addition to max66's answer:

You could have tried this:

template<typename ... TT, typename ... TTT>
using Alias = typename Something<TT...>::Another<TTT...>;

Looks really nice at first, doesn't it?

Problem then, however will already be with one single template parameter:

Alias<int> a;

Which one is it now? Something<int>::Another<> or Something<>::Another<int>? And if you have more parameters, how to distribute? No chance to get a meaningful solution. So no, you can't do that directly, you have to help yourself with tricks such as max66 proposed...

He tried with bad syntax (two template parameter lists) - sure *that* can't work. Above is now the correct syntax (compare to max66's anwwer), but still can't work due to ambiguites... — Aconcagua, Mar 16 '17 at 12:32

How to alias a nested template class with variadic parameter packs

2 Answers2