reverse type in variadic template

reverse.cpp

template<typename ... T_args>
struct pack{};

template<template<typename ...T>class target, typename ... T_args>
struct transfer;

template<template<typename ...T>class target, typename ... T_args>
struct transfer<target, pack<T_args...>>
{
    typedef target<T_args...> type;
};

template<template<typename ... T> class target, typename ... T_args>
struct join;

template<template<typename ... T> class target, typename T, typename ... T_args>
struct join<target, T, target<T_args...>>
{
    typedef target<T, T_args...> type;
};

template<template<typename ... T> class target, typename packed,
         typename ... T_args>
struct reverse_impl;

template<template<typename ... T> class target, typename packed,
         typename T_head, typename ... T_args>
struct reverse_impl<target, packed, T_head, T_args...>
{
    typedef typename reverse_impl<target,
                typename join<pack, T_head, packed>::type,
                T_args...>::type type;
};

template<template<typename ... T> class target, typename packed>
struct reverse_impl<target, packed>
{
    typedef typename transfer<target, packed>::type type;
};

template<template<typename ... T> class target, typename ... T_args>
struct reverse
{
    typedef typename reverse_impl<target, pack<>, T_args...>::type type;
};


#include <type_traits>
#include <tuple>

static_assert(
    std::is_same<typename reverse<std::tuple, char, int, short, double>::type,
                 std::tuple<double, short, int, char>>::value,
    "reverse: 4 argument tuple");

static_assert(
    std::is_same<typename reverse<std::tuple, char, int, double>::type,
                 std::tuple<double, int, char>>::value,
    "reverse: 3 argument tuple");

static_assert(
    std::is_same<typename reverse<std::tuple, char, int>::type,
                 std::tuple<int, char>>::value,
    "reverse: 2 argument tuple");

static_assert(
    std::is_same<typename reverse<std::tuple, char>::type,
                 std::tuple<char>>::value,
    "reverse: 1 argument tuple");

static_assert(
    std::is_same<typename reverse<std::tuple>::type,
                 std::tuple<>>::value,
    "reverse: 0 argument tuple");

#include <iostream>
int main()
{
    typename reverse<std::tuple, char, int, double>::type t;
    std::get<0>(t) = 3.14;
    std::get<1>(t) = 42;
    std::get<2>(t) = 'a';

    std::cout << "std::get<0>(t) = " << std::get<0>(t) << std::endl;
    std::cout << "std::get<1>(t) = " << std::get<1>(t) << std::endl;
    std::cout << "std::get<2>(t) = " << std::get<2>(t) << std::endl;
    return 0;
}