Transform tuple to "triangular" tuple - c++

Question

How do I transform this type:
std::tuple<T0, T1, ..., TN1, TN>
into this:
std::tuple<
std::function<T0()>,
std::function<T1(T0)>,
std::function<T2(T0, T1)>,
...
std::function<TN(T0, ..., TN1 )>
>

Answer 1

Right ... isn't suffice, but you could always use pattern matching (i.e. partial specialization) with recursion:
#include <tuple>
#include <functional>
#include <cstdlib>
// A type to store list of integers
template <size_t... ns>
struct integers
{
template <size_t n>
using push_back = integers<ns..., n>;
};
// This generates 'integers<0, 1, 2, ..., n-1>'
template <size_t n>
struct iota
{
typedef typename iota<n-1>::type::template push_back<n-1> type;
};
template <>
struct iota<0>
{
typedef integers<> type;
};
// Put a type to the front of the argument list
template <typename T, typename U>
struct push_front;
template <typename T, typename R, typename... A>
struct push_front<R(A...), T>
{
typedef R type(T, A...);
};
// This converts 'std::tuple<T0, T1, ..., TN>' to the function type
// 'TK(T0, T1, ..., TK-1)' where K is the first parameter
template <size_t, typename...>
struct slice;
template <size_t end, typename First, typename... Rest>
struct slice<end, First, Rest...>
{
typedef typename push_front<typename slice<end-1, Rest...>::type, First>::type type;
};
template <typename First, typename... Rest>
struct slice<0, First, Rest...>
{
typedef First type();
};
// This calls 'slice' on T... for all integers in the list.
template <typename T, typename U>
struct triangularize_impl;
template <typename... T, size_t... n>
struct triangularize_impl<std::tuple<T...>, integers<n...>>
{
typedef std::tuple<std::function<typename slice<n, T...>::type>...> type;
};
// This is a wrapper of 'triangularize_impl'.
template <typename T>
struct triangularize;
template <typename... T>
struct triangularize<std::tuple<T...>>
{
typedef typename triangularize_impl<std::tuple<T...>, typename iota<sizeof...(T)>::type>::type type;
};
As a demo, in g++ 4.7 when we write
triangularize<std::tuple<int, float, double, char>>::type d = 0;
the error message shows
error: conversion from ‘int’ to non-scalar type
‘triangularize<std::tuple<int, float, double, char> >::type {aka
std::tuple<std::function<int()>,
std::function<float(int)>,
std::function<double(int, float)>,
std::function<char(int, float, double)> >}’
requested
Showing the code is correct.