title: Type function that returns a tuple of chosen types
body: <p>I've implemented a type function <code>Tuple</code> that turn a list of <code>My_enum</code> values into an <code>std::tuple</code> of corresponding types:</p>
  
  <pre><code>#include &lt;tuple&gt;
  
  enum My_enum{ t_int, t_double };
  
  // Bind_type is a type function that given a My_enum returns the corresponding type
  template&lt;My_enum E&gt; struct Bind_type;
  template&lt;&gt; struct Bind_type&lt;t_int&gt;{ using type = int; };
  template&lt;&gt; struct Bind_type&lt;t_double&gt;{ 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&lt;My_enum First, My_enum... Others&gt;
  struct Tuple {
      using type = decltype(std::tuple_cat(
                  typename Tuple&lt;First&gt;::type{},
                  typename Tuple&lt;Others...&gt;::type{}
              ));
  };
  
  template&lt;&gt;
  struct Tuple&lt;t_int&gt; {
      using type = std::tuple&lt;Bind_type&lt;t_int&gt;::type&gt;;
  };
  template&lt;&gt;
  struct Tuple&lt;t_double&gt; {
      using type = std::tuple&lt;Bind_type&lt;t_double&gt;::type&gt;;
  };
  </code></pre>
  
  <p>I'd like to be able to declare the recursion base case for <code>Tuple</code> in one shot, because I don't want to manually manage <code>Tuple</code> specialization as long as I add or remove values to <code>My_enum</code>, because it is error prone (and boring). I've tried:</p>
  
  <pre><code>template&lt;My_enum E&gt;
  struct Tuple {
      using type = std::tuple&lt;Bind_type&lt;E&gt;::type&gt;;
  };
  </code></pre>
  
  <p>but this is not a valid specialization for the variadic version.</p>
  
  <p>My question is: is there a smart way to declare the specialization of <code>Tuple</code> when it has only one template value parameter?</p>