#include <type_traits>

struct identity {};

template< typename... Ts > struct type_list;

template< int N, typename C >
struct dispatch;

template<>
struct dispatch< 1, identity >
{
    template< typename T >
    using f = T;
};

template< template< typename... > class F, typename C = identity >
struct promote {};

template< int N, template< typename... > class F, typename C >
struct dispatch< N, promote< F, C > >
{
    template< typename... Ts >
    using f = typename dispatch< 1, C >::template f< F< Ts... > >;
};

using listify = promote< type_list >;

template< bool C >
struct cond
{
    template< typename T, typename F >
    using value_type = T;
};

template<>
struct cond< false >
{
    template< typename T, typename F >
    using value_type = F;
};

template< typename F, typename... Ts >
using call_f = typename dispatch< sizeof...( Ts ), F >::template f< Ts... >;

template< typename T >
void test();

template< typename T >
using is_int = std::is_same< T, int >;

template< typename T, typename C = listify >
struct append
{
};

template< typename T, typename C = listify >
struct nop
{
};

template< int N, typename T, typename C >
struct dispatch< N, nop< T, C > >
{
    template< typename... Ts >
    using f = typename dispatch< sizeof...( Ts ), C >::template f< Ts... >;
};

template< int N, typename T, typename C >
struct dispatch< N, append< T, C > >
{
    template< typename... Ts >
    using f = typename dispatch< sizeof...( Ts ) + 1, C >::template f< Ts..., T >;
};

template< template< typename > class F, typename C = listify > struct find_if
{
};

template< typename C, typename... Ts2 >
struct callify {};

template< int N, typename C, typename... Ts2 >
struct dispatch< N, callify< C, Ts2... > >
{
    template< typename... Ts >
    using f = typename dispatch< sizeof...( Ts ), C >::template f< typename dispatch< 1, Ts >::template f< Ts2 >... >;
};

template< template< typename > class F, typename C >
struct dispatch< 2, find_if< F, C > >
{
    template< typename T0, typename T1 >
    using f = typename dispatch< 2, callify< C, T0, T1 > >::template f<
        typename cond< F< T0 >::value >::template value_type< promote< append, identity >, promote< nop, identity > >,
        typename cond< F< T1 >::value >::template value_type< promote< append, identity >, promote< nop, identity > >
    >;
};

// < append< H, < find_if<  > >

int main()
{
    using t = call_f< find_if< is_int >, int, char >;
    test< t >();
}