Clever! I like that variadic compose function you have there.

I did a bit of poking around, dealing with primitives with cps and crazy lambdas in general tends to give you the exact same code as if you just wrote something like std::cout << whateverl since lambdas inline quite well. STL functions are a special objects so they take a fair bit more overhead in general.

I'm trying to learn assembly just so I can better comment on performance stuff, but I'm far from expert at it.

I work in gcc 4.9 your mileage may vary.

Thanks for reading!

#include

using namespace std;

// ———————————————————
// ———————————————————
template
class Composite;

// ———————————————————
// ———————————————————
template
Composite compose2 (F1 f, F2 g) {
return Composite {f,g};
}

// ———————————————————
// ———————————————————
template
auto compose (F1 f, F2 g) -> decltype(compose2 (f, g))
{
return compose2 (f, g);
}

template
decltype(auto) compose (F1 f, Fs … args)
{
return compose2 (f, compose(args…));
}

// ———————————————————
// ———————————————————
template
class Composite{
private:
F1 f1;
F2 f2;

public:
Composite(F1 f1, F2 f2) : f1(f1), f2(f2) { }

template
auto operator() (IN i) -> decltype(f2(f1(i)))
{
return f2 ( f1(i) );
}
};

// ———————————————————
// ———————————————————
int f(int a) { return 2*a; }

double g(int a) { return a+2.5; }

double h(double a) { return 2.5*a; }

double i(double a) { return 2.5-a; }

class Functor {
double x;

public:

Functor (double x_) : x(x_) { }

double operator() (double a) { return a*x; }
};

// ———————————————————
// ———————————————————
int main () {

auto l1 = [] (double a) { return a/3; };
auto l2 = [] (double a) { return 3.5+a; };

Functor fu {4.5};

auto compos1 = compose (f, g, l1, g, h, h, l1, l2);

auto compos2 = compose (compos1, l1, l2, fu);

auto x = compos2 (3);

cout << x << endl;
cout << compos2(3) << endl;

cout << fu(l2(l1(l2(l1(h(h(g(l1(g(f(3))))))))))) << endl;

} // ()

Additionally that would work for any container type that has insert, not just vector.

Nice and clear article, thank you. (really makes me think of the waterfall Js)
Also I wondered if in you next articles you could mention about the possible performance overhead.

From what I’ve done with lambdas and std::function, I would say: low overhead with Lambdas, and heavy with std::functions on MSVC, quite heavy for both on CLang (3.1 if i remember well). Which was a bit sad.
Maybe this will change as compilers are evolving quite fast and probably just starting on these. Although I can imagine it to be easier to optimize for a compiler when simply written with ad hoc code.

Best