Template template parameter with mixed type and non-type variadic parameters

Question

I am having trouble declaring the following:

// c++17
template<typename T, typename ...Before, T v, typename ...After, template<typename ..., T, typename ...> U>
auto enum_to_type() {
    // do things with
    // U<Before..., v, After...> obj;
    // as an example:
    return U<Before..., v + 1, After...>{};
}

// demonstrate of usage

template<int v>
struct A {};

template<typename T, int v>
struct B {};

/// call enum_to_type to get next type
/// note: the following does not compile
using next_A = decltype(enum_to_type<int, 0, A>()); 
// == A<1>
template<typename T>
using next_B = decltype(enum_to_type<int, T, 0, B>()); 
// == B<1>

The purpose of this function is to write generic code that could make use of non-type template parameter v to construct template class from class template U without the knowledge of how the template parameters are declared in U . Otherwise, one has to write this function for different signatures eg, U<T v> , U<typename, T v> , U<T v, typename> , and so on.

Edit: I guess what I want is likely not possible.

Answer 1

It is possible with some modifications:

//type container template
template<typename...>
struct types{};
//declaration
template<typename ,auto V, typename, template<typename ,decltype(V), typename...>class>
class enum_to_type;
//generic definition
template<typename First, typename ... Befors, First V, typename ... Afters, template<typename ,First, typename...>class U>
class enum_to_type<types<First, Befors...>, V, types<Afters...>, U>{
public:
    static auto go(){
        return U<types<Befors...>, V + 1, Afters...>{};
    }
};
//specialization
template<auto V, typename ... Afters, template<typename ,decltype(V), typename...>class U>
class enum_to_type<types<>, V,types<Afters...>, U>{
public:
    static auto go(){
        return U<types<>, V + 1, Afters...>{};
        //or
        //return U<types<>, V, Afters...>{};
    }
};
//Declarations and specializations for the target class templates
template<typename, int>
struct A{};

template<typename, int, typename>
struct B;
template<typename T, int V>
struct B<types<>, V, T > {};

using next_A = decltype(enum_to_type<types<int>,  0, types<>, A>::go());

template<typename T>
using next_B = decltype(enum_to_type<types<int>, 0, types<T>, B>());

template<typename, auto, typename...>
struct general_case;
template<typename ... befors, int V, typename ... afters>
struct general_case<types<befors...>, V, afters ...> {};

Usage:

decltype(enum_to_type<types<>,  0, types<>, A>::go()) object_A;
decltype(enum_to_type<types<>, 0, types<int>, B>::go()) object_B;
decltype(enum_to_type<types<int, float>, 3, types<int>, general_case>::go()) object_general;

It is just that compiler does not have a way to find out how many types are in before and after. That is why in general it can take only one arguments pack in template declaration. But it can handle multiple arguments packs in specialization!

Good luck!