    The emi(unpack operator) is used to obtain template arguments in many
situations. No mechanism other than recursion (as shown in section
ref(DEFVARTEMP)) is available to obtain the individual types and values of a
variadic template.

    The unpack operator can also be used to define template classes that are
derived from any number of base classes.
  hi(perfect forwarding: inheritance) Here is how it's done:
        verb(    template <typename ...BaseClasses>
    class Combi: public BaseClasses...          // derive from base classes
    {
        public:
                                                // specify base class objects
                                                // to its constructor using
                                                // perfect forwarding
            Combi(BaseClasses &&...baseClasses)
            :
                BaseClasses(baseClasses)...     // use base class initializers
            {}                                  // for each of the base
    };                                          // classes)

This allows us to define classes that combine the features of any number
of other classes. If the class tt(Combi) is derived of classes tt(A, B,) and
tt(C) then tt(Combi) is-an tt(A, B,) and tt(C). It should of course be given a
virtual destructor. A tt(Combi) object can be passed to functions expecting
pointers or references to any of its base class type objects. Here is an
example defining tt(Combi) as a class derived from a vector of complex
numbers, a string and a pair of ints and doubles (using uniform intializers in
a sequence matching the sequence of the types specified for the used tt(Combi)
type):
        verb(    using MultiTypes = Combi<
        vector<complex<double>>, string, pair<int, double> >;

    MultiTypes mt = { {3.5, 4}, "mt", {1950, 1.72} };)

The same construction can also be used to define template data members
supporting variadic type lists such as tt(tuples) (cf. section
ref(TUPLES)). Such a class could be designed along these lines:
        verb(    template <typename ...Types>
    struct Multi
    {
        std::tuple<Types...> d_tup;        // define tuple for Types types

        Multi(Types ...types)
        :                                   // initialize d_tup from Multi's
            d_tup(std::forward<Types>(types)...)   //             arguments
        {}
    };)

The ellipses that are used when forwarding parameter packs are
essential. The compiler considers their omission an error. In the following
tt(struct) definition it was the intent of the programmer to pass a parameter
pack on to a nested object construction but ellipses were omitted while
specifying the template parameters, resulting in a
    hi(parameter pack: not expanded)
 em(parameter packs not expanded with `...') error message:
        verb(    template <int size, typename ...List>
    struct Call
    {
        Call(List &&...list)
        {
            Call<size - 1, List &&> call(std::forward<List>(list)...);
        }
    };)

Instead of the above definition of the tt(call) object the programmer
should have used:
        verb(    Call<size - 1, List &&...> call(std::forward<List>(list)...);)

