title: aliassing a template parameter pack
body: <p>I would like to use a using alias for a parameter pack such that the templates can be used elsewhere in the code base. In the following code I commented the lines where I would use the types:</p>
  
  <pre class="lang-cpp prettyprint-override"><code>template &lt;typename FirstArg, typename ... OtherArgs&gt;
  struct Base {
      using UsableFirstArg = FirstArg;
  // this would be needed later
  //    using UsableOtherArgs... = OtherArgs...;
      virtual OtherClass method(OtherArgs... a) = 0
  };
  
  template &lt;typename DerivedOfBaseInstantiation&gt;
  struct CallerStructure {
  // to be used here
  //    OtherClass unknownCall(typename DerivedOfBaseInstantiation::UsableOtherArgs... args) {
  //        DerivedOfBaseInstantiation instance;
  //        return instance.method(args...);
  //    }
  }
  
  </code></pre>
  
  <p>At code write time of <code>CallerStructure</code>, the arguments of <code>unknownCall</code> are not known and are determined by the instantiation of <code>CallerStructure</code> where <code>DerivedOfBaseInstantiation</code> is a type that's derived of <code>Base</code>. In a more complete example that would look like that:</p>
  
  <pre class="lang-cpp prettyprint-override"><code>class OtherClass {
  };
  
  template &lt;typename FirstArg, typename ... OtherArgs&gt;
  struct Base {
      using UsableFirstArg = FirstArg;
      using UsableOtherArgs... = OtherArgs...;
  
      virtual OtherClass method(OtherArgs... a) = 0;
  
  };
  
  struct Derived_df : Base&lt;int, double, float&gt; {
      OtherClass someMethod(Base::UsableFirstArg);  // int
      OtherClass method(double, float) override ;
  };
  
  
  
  template &lt;typename DerivedOfBaseInstantiation&gt;
  struct CallerStructure {
      OtherClass knownCall(typename DerivedOfBaseInstantiation::UsableFirstArg a) {
          DerivedOfBaseInstantiation instance;
          return instance.someMethod(a);
      }
      OtherClass unknownCall(typename DerivedOfBaseInstantiation::UsableOtherArgs... args) {
          DerivedOfBaseInstantiation instance;
          return instance.method(args...);
      }
  };
  
  
  void instantiations() {
      CallerStructure&lt;Derived_df&gt; c;
      [[maybe_unused]] auto a = c.knownCall(42);
      [[maybe_unused]]  auto b = c.unknownCall(23., 11.f);
  }
  </code></pre>
  
  <p>Any hints of how to access the variadic templates of <code>Base</code> for the method interface in <code>CallerStructure</code>?</p>
  
  <p><a href="https://godbolt.org/z/3clKLw" rel="nofollow noreferrer">mandatory compiler-explorer link</a></p>