TupleList example

#include <type_traits>


template <typename...>
struct Tuple;

// base case specialization
template<>
struct Tuple<>{
        static void loop(Tuple<>& tuple, auto&& func, size_t idx){}
        static size_t hash(Tuple<>& tuple){ return 0;}
};

// recursive case specialization
template <typename T, typename... Rem>
struct Tuple<T, Rem...>: Tuple<Rem...>{
        T val;
        // copy constructor
        Tuple(const Tuple&) = default;
        Tuple<T, Rem...>(T head, Tuple<Rem...> tail): Tuple<Rem...>(tail), val(head){}
        Tuple<T, Rem...>(T head, Rem... tail): Tuple<Rem...>(tail...), val(head){}
        static void loop(Tuple<T, Rem...>& tuple, auto&& func, size_t idx){
                func(idx, tuple.val);
                Tuple<Rem...>::loop(tuple, func, idx+1);
        }
        static size_t hash(Tuple<T, Rem...>& tuple){
                size_t hash = std::hash<T>()(tuple.val);
                return hash ^ Tuple<Rem...>::hash(tuple);
        }
};

template <size_t idx, typename TupleType>
struct TupleElem;

template <typename T, typename... Rem>
struct TupleElem<0, Tuple<T, Rem...>>{
        using type = T;
        static T& get(Tuple<T, Rem...>& tuple){
                return tuple.val;
        }
};

template <size_t idx, typename T, typename... Rem>
struct TupleElem<idx, Tuple<T, Rem...>>{
        using type = typename TupleElem<idx-1, Tuple<Rem...>>::type;
        static type& get(Tuple<T, Rem...>& tuple){
                return TupleElem<idx-1, Tuple<Rem...>>::get(tuple);
        }
};

template<size_t idx, typename T, typename... Rem>
typename TupleElem<idx, Tuple<T, Rem...>>::type get(Tuple<T, Rem...>& tuple){
        return TupleElem<idx, Tuple<T, Rem...>>::get(tuple);
}

template<typename T, typename... Rem>
static void loop(Tuple<T, Rem...>& tuple, auto&& func){
        size_t idx = 0;
        func(idx, tuple.val);
        return Tuple<Rem...>::loop(tuple, func, idx+1);
}

template<typename T, typename... Rem>
static size_t hash(Tuple<T, Rem...>& tuple){
        size_t hash = std::hash<T>()(tuple.val);
        return hash ^ Tuple<Rem...>::hash(tuple);
}