I've implemented a type function `Tuple`

that turn a list of `My_enum`

values into an `std::tuple`

of corresponding types:

```
#include <tuple>
enum My_enum{ t_int, t_double };
// Bind_type is a type function that given a My_enum returns the corresponding type
template<My_enum E> struct Bind_type;
template<> struct Bind_type<t_int>{ using type = int; };
template<> struct Bind_type<t_double>{ using type = double; };
// Tuple is a type function that given a template value parameter pack of My_enums returns a std::tuple of correspondig types
template<My_enum First, My_enum... Others>
struct Tuple {
using type = decltype(std::tuple_cat(
typename Tuple<First>::type{},
typename Tuple<Others...>::type{}
));
};
template<>
struct Tuple<t_int> {
using type = std::tuple<Bind_type<t_int>::type>;
};
template<>
struct Tuple<t_double> {
using type = std::tuple<Bind_type<t_double>::type>;
};
```

I'd like to be able to declare the recursion base case for `Tuple`

in one shot, because I don't want to manually manage `Tuple`

specialization as long as I add or remove values to `My_enum`

, because it is error prone (and boring). I've tried:

```
template<My_enum E>
struct Tuple {
using type = std::tuple<Bind_type<E>::type>;
};
```

but this is not a valid specialization for the variadic version.

My question is: is there a smart way to declare the specialization of `Tuple`

when it has only one template value parameter?