Small variadic template challenge: function composition

[Rui Maciel]

Does anyone know if it's possible to use (or abuse) variadic templates to
implement a way to concisely pull off function composition?

The following example can better describe what I mean:

<pseudo-code>
B AtoB(A)
{
//... do something
return B(something);
}

C BtoC(B)
{
//... do something
return C(something);
}

D CtoD(C)
{
//... do something
return D(something);
}


int main(void)
{
A a;

D d = composition<AtoB, BtoC, CtoD>(a); // magic happens

return 0;
}
</pseudo-code>



Thanks in advance,
Rui Maciel

 

[Gert-Jan de Vos]

Does anyone know if it's possible to use (or abuse) variadic templates to

implement a way to concisely pull off function composition?



The following example can better describe what I mean:



<pseudo-code>

B AtoB(A)

{

//... do something

return B(something);

}



C BtoC(B)

{

//... do something

return C(something);

}



D CtoD(C)

{

//... do something

return D(something);

}





int main(void)

{

A a;



D d = composition<AtoB, BtoC, CtoD>(a); // magic happens



return 0;

}

</pseudo-code>


Thanks in advance,

Rui Maciel

How about this:

struct A {};
struct B {};
struct C {};
struct D {};

struct AtoB
{
typedef A argument_type;
typedef B result_type;

B operator()(A a) const
{
return B();
}
};

struct BtoC
{
typedef B argument_type;
typedef C result_type;

C operator()(B b) const
{
return C();
}
};

struct CtoD
{
typedef C argument_type;
typedef D result_type;

D operator()(C C) const
{
return D();
}
};

template <typename Fn1, typename ... Fns>
struct composition
{
typedef typename Fn1::argument_type argument_type;
typedef composition<Fns ...> Tail;
typedef typename Tail::result_type result_type;

result_type operator()(argument_type a) const
{
Fn1 fn1;
Tail tail;
return tail(fn1(a));
}
};

template <typename Fn>
struct composition<Fn>
{
typedef typename Fn::argument_type argument_type;
typedef typename Fn::result_type result_type;

result_type operator()(argument_type a) const
{
Fn fn;
return fn(a);
}
};

template <typename... Fns>
typename composition<Fns ...>::result_type
compose(typename composition<Fns ...>::argument_type a)
{
composition<Fns ...> fn;
return fn(a);
}

int main()
{
A a;
D d = compose<AtoB, BtoC, CtoD>(a);
}

Regards,

Gert-Jan