template <typename... _Types>
	struct typelist {};

Wenn ich zwei Listen verketten möchte, ist das alles kein Problem.

template <typename _Typelist1, typename _Typelist2>
	struct typelist_cat;

	template <template <typename...> typename _Typelist1, template <typename...> typename _Typelist2, typename... _Types1, typename... _Types2>
	struct typelist_cat<_Typelist1<_Types1...>, _Typelist2<_Types2...>>
	{
		using type = typelist<_Types1..., _Types2...>;
	};

Gibt es irgendeine Möglichkeit das ganze jetzt mit einer variablen Argumentliste zu implementieren ?

template <typename... _Typelists>
	struct typelist_cat;

template <typename... T>
    struct typelist_cat;

    template <>
    struct typelist_cat<>
    {
        using type = typelist<>;
    };

    template <typename... T>
    struct typelist_cat<typelist<T...>>
    {
        using type = typelist<T...>;
    };

    template <typename... T, typename... U, typename... V>
    struct typelist_cat<typelist<T...>, typelist2<U...>, V...> : tuplecat<typelist<T..., U...>, V...>
    {};

template <typename... lists> struct concat : typelist<> {};
template <typename l> struct concat<l> : l {};
template <typename... k, typename... l, typename... lists>
struct concat<typelist<k...>, typelist<l...>, lists...> : concat<typelist<k..., l...>, lists...> {};

(ungetestet). Ist funktionale Programmierung nicht klasse?

Edit: Ein wenig spät.