Variadic template в классическом C++

#include <cstddef>
 
// TypeList implementation begins...
struct NullList;
 
template <typename Head, typename Tail = NullList>
struct TypeList;
 
// Эти повторения могут быть сгенерированы через макро
template <
    typename Arg0 = NullList, typename Arg1 = NullList
  , typename Arg2 = NullList, typename Arg3 = NullList
  , typename Arg4 = NullList, typename Arg5 = NullList
  , typename Arg6 = NullList, typename Arg7 = NullList
  , typename Arg8 = NullList, typename Arg9 = NullList // Etc... 
>
struct MakeList
{
private:
    typedef typename MakeList<
        Arg1, Arg2, Arg3
      , Arg4, Arg5, Arg6
      , Arg7, Arg8, Arg9
    >::Result TailType;
 
public:
    typedef TypeList<Arg0, TailType> Result;
};
template <>
struct MakeList<>
{
    typedef NullList Result;
};
 
template <typename List, size_t I> 
struct TypeAt;
 
template <typename Head, typename Tail>
struct TypeAt<TypeList<Head, Tail>, 0>
{
    typedef Head Result;
};
 
template <typename Head, typename Tail, size_t I>
struct TypeAt<TypeList<Head, Tail>, I>
{
    typedef typename TypeAt<Tail, I - 1>::Result Result;
};
// TypeList implementation ends...
 
 
// Tuple implementation begins...
template <typename T, size_t I>
class TupleElement
{
public:
    T& get() 
    {
        return m_value;
    }
    T const& get() const
    {
        return m_value;
    }
private:
    T m_value;
};
 
template <typename List, size_t I = 0>
class TupleImpl;
 
template <typename Head, typename Tail, size_t I>
class TupleImpl<TypeList<Head, Tail>, I> 
    : public TupleImpl<Tail, I + 1>
    , public TupleElement<Head, I>
{ };
template <size_t I>
class TupleImpl<NullList, I>
{
public:
    enum { Size = I };
};
 
template <typename List>
class Tuple : TupleImpl<List>
{
    template <size_t I, typename X>
    static 
    typename TypeAt<List, I>::Result& xget(TupleElement<X, I>& el)
    {
        return el.get();
    }
    template <size_t I, typename X>
    static
    typename TypeAt<List, I>::Result const& xget(TupleElement<X, I> const& el)
    {
        return el.get();
    }
public:
    template <size_t I>
    typename TypeAt<List, I>::Result& get() 
    {
        return xget<I>(*this);
    }
    template <size_t I>
    typename TypeAt<List, I>::Result const& get() const
    {
        return xget<I>(*this);
    }
};
// Tuple implementation ends...
 
// User code
#include <string>
#include <iostream>
 
int main() 
{
    typedef MakeList<int, double, std::string>::Result List;
 
    Tuple<List> tpl;
    tpl.get<0>() = 1;
    tpl.get<1>() = 3.14;
    tpl.get<2>() = "hello";
    
    std::cout << tpl.get<2>() << '\n';
    std::cout << tpl.get<1>() << '\n';
    std::cout << tpl.get<0>() << '\n';
}