Не получается разобраться с кодом инстанцирования кортежа

#include <iostream>
 
 
template <class T, class U>
struct Typelist
{
    typedef T head; 
    typedef U Tail;
};
class NullType 
{ };
 
template < 
    typename T1 = NullType, typename T2 = NullType, typename T3 = NullType,
    typename T4 = NullType, typename T5 = NullType
>
class MakeList
{
    typedef typename MakeList< T2, T3, T4, T5 >::Result Tail;
 
public:
    typedef Typelist<T1, Tail> Result;
};
 
template <>
class MakeList<>
{
public:
    typedef NullType Result;
};
 
template <class TList> struct Length;
template <> 
struct Length< NullType >
{
    enum { value = 0 };
};
template <class T, class U>
struct Length< Typelist<T, U> >
{
    enum { value = 1 + Length<U>::value };
};
 
template <class TList, unsigned int Index> struct TypeAt;
 
template <class Head, class Tail>
struct TypeAt<Typelist<Head, Tail>, 0>
{
    typedef Head Result;
};
 
template <class Head, class Tail, unsigned int Index>
struct TypeAt<Typelist<Head, Tail>, Index>
{
    typedef typename TypeAt<Tail, Index - 1>::Result Result;
};
 
//============ Примитивная реализация Tuple с использованием списка типов ==================
 
template <typename T, unsigned int I>
class TupleElement
{
public:
    T & get() 
    {
        return m_value;
    }
private:
    T m_value;
};
 
template <typename List, unsigned int I = 0>
class TupleImpl;
    
template <typename T, typename U, unsigned int I>
class TupleImpl<Typelist<T, U>, I>
    : public TupleElement<T, I>
    , public TupleImpl<U, I + 1>
{ };
template <unsigned int I>
class TupleImpl<NullType, I>
{ };
 
template <
    typename T1 = NullType, typename T2 = NullType, typename T3 = NullType,
    typename T4 = NullType, typename T5 = NullType    
>
class Tuple : public TupleImpl<typename MakeList<T1, T2, T3, T4, T5>::Result>
{
    typedef typename MakeList<T1, T2, T3, T4, T5>::Result ElementsList;
        
public:
    template <unsigned int Index>
    typename TypeAt<ElementsList, Index>::Result & get() 
    {
        TupleElement<typename TypeAt<ElementsList, Index>::Result, Index> & el = *this;
        return el.get();
    }
    enum 
    {
        Size = Length<ElementsList>::value
    };
    
};
 
//======================== Эмуляция перебора в цикле ====================================
template <typename Tuple, unsigned int I = Tuple::Size>
struct TupleForEach_ 
{
    template <typename F>
    static void run(Tuple & tpl, F f) 
    {
        TupleForEach_<Tuple, (I - 1)>::run(tpl, f);
        f(tpl.template get<(I - 1)>());
    }
};
 
template <typename Tuple>
struct TupleForEach_<Tuple, 0> 
{
    template <typename F>
    static void run(Tuple & tpl, F f) { }
};
 
template <typename Tuple, typename F>
void TupleForEeach(Tuple & x, F f) 
{
    TupleForEach_<Tuple>::run(x, f);
}
//=======================================================================
 
struct CoutPrinter {
    template <typename T>
    void operator()(T const & v) const 
    {
        std::cout << v << ' '; 
    }
};
 
int main()
{
    Tuple<int, char, double> tpl;
    
    tpl.get<0>() = 1;
    tpl.get<1>() = 'a';
    tpl.get<2>() = 3.14;
    
    TupleForEeach(tpl, CoutPrinter());
}

class MakeList
{
    typedef typename MakeList< T2, T3, T4, T5 >::Result Tail;
 
public:
    typedef Typelist<T1, Tail> Result;
};

template <typename F>
    static void run(Tuple & tpl, F f) 
    {
        TupleForEach_<Tuple, (I - 1)>::run(tpl, f);
        f(tpl.template get<(I - 1)>());
    }

template<typename Tuple, unsigned int I = Tuple::Size>
struct TupleFor__
{
    template<typename F>
    static void run(Tuple& tpl, F f, unsigned int i)
    {
        if 
            (i == I - 1) f(tpl.template get<(I - 1)>());
        else
            TupleFor__<Tuple, (I - 1)>::run(tpl, f, i);
    }
};
 
template <typename Tuple>
struct TupleFor__<Tuple, 0> 
{
    template <typename F>
    static void run(Tuple& tpl, F f, unsigned int i) { }
};
 
template <typename Tuple, typename F>
void TupleFor_(Tuple& t, F f, unsigned int i) 
{
    TupleFor__<Tuple>::run(t, f, i);
}
 
template<typename Tuple, typename F>
void TupleFor(unsigned int first, unsigned int last, Tuple t, F f)
{
    for (unsigned int i = first; i <= last; ++i)
        TupleFor_(t, f, i);
}

int main()
{
    Tuple<int, char, double, unsigned int> tpl;
    
    tpl.get<0>() = -12;
    tpl.get<1>() = 'a';
    tpl.get<2>() = 3.14;
    tpl.get<3>() = 50;
    
    unsigned int a = 0;
    unsigned int b = 0;
 
    std::cin >> a;
    std::cin >> b;
    
    TupleFor(a, b, tpl, CoutPrinter());
}

TupleFor(b, b, tpl, CoutPrinter());

typedef Typelist<T1, Tail> Result;

    for (unsigned int i = first; i <= last; ++i)
        TupleFor_(t, f, i);

        if 
            (i == I - 1) f(tpl.template get<(I - 1)>());
        else
            TupleFor__<Tuple, (I - 1)>::run(tpl, f, i);

#include <iostream>
#include <tuple> 
 
// http://www.vishalchovatiya.com/variadic-template-cpp-implementing-unsophisticated-tuple/
 
using namespace std;
 
template <typename... Args>
void print(const std::tuple<Args...> &t) {
    std::apply([](const auto &... args) {
        ((cout << args << endl), ...);
    }, t);
}
 
template <class... Ts>
struct overloaded : Ts... {
    using Ts::operator()...;
};
 
template <class... Ts>
overloaded(Ts...) -> overloaded<Ts...>;  
 
auto f = overloaded {
    [](const int &a)        { cout << "From int: " << a << endl; },
    [](const char &b)       { cout << "From char: " << b << endl; },
    [](const string &c)     { cout << "From string: " << c << endl; },
};
 
 
int main(int argc, const char *argv[])
{
    tuple<int, char, string, string>    t(1, 'A', "ABC", "done");
    std::apply([&](const auto &... e) { (f(e), ...); }, t);
    return 0;
}