How to overload an operator for composition of functionals in C++0x?

Question

Is there a way to overload, say the >> operator for function composition? The operator should work seamlessly on lambdas as well as std::function?

Requirements:

• The solution should not include nested bind calls,
• the left operand can be of a functional type with an arbitrary number of parameters, and
• no more than one function object instance should be created.

Here is a quick and dirty example that illustrates the desired behaviour:

#include <iostream>
#include <functional>

using namespace std;

// An example of a quick and dirty function composition.
// Note that instead of 'std::function' this operator should accept
// any functional/callable type (just like 'bind').
template<typename R1, typename R2, typename... ArgTypes1>
function<R2(ArgTypes1...)> operator >> (
                const function<R1(ArgTypes1...)>& f1,
                const function<R2(R1)>& f2) {
    return [=](ArgTypes1... args){ return f2(f1(args...)); };
}

int main(int argc, char **args) {
    auto l1 = [](int i, int j) {return i + j;};
    auto l2 = [](int i) {return i * i;};

    function<int(int, int)> f1 = l1;
    function<int(int)> f2 = l2;

    cout << "Function composition: " << (f1 >> f2)(3, 5) << endl;

    // The following is desired, but it doesn't compile as it is:
    cout << "Function composition: " << (l1 >> l2)(3, 5) << endl;

    return 0;
}

Answer 1

(l1 >> l2) can never work.

They are function objects made by the compiler and don't include that operator, so unless you plan on modifying the compiler to be non-conforming that's how it's always going to be. :)

You can, however, introduce a "keyword" (utility class) which is arguably a good thing, but it's hefty:

// https://ideone.com/MS2E3

#include <iostream>
#include <functional>

namespace detail
{
    template <typename R, typename... Args>
    class composed_function;

    // utility stuff
    template <typename... Args>
    struct variadic_typedef;

    template <typename Func>
    struct callable_type_info :
        callable_type_info<decltype(&Func::operator())>
    {};

    template <typename Func>
    struct callable_type_info<Func*> :
        callable_type_info<Func>
    {};

    template <typename DeducedR, typename... DeducedArgs>
    struct callable_type_info<DeducedR(DeducedArgs...)>
    {
        typedef DeducedR return_type;
        typedef variadic_typedef<DeducedArgs...> args_type;
    };

    template <typename O, typename DeducedR, typename... DeducedArgs>
    struct callable_type_info<DeducedR (O::*)(DeducedArgs...) const>
    {
        typedef DeducedR return_type;
        typedef variadic_typedef<DeducedArgs...> args_type;
    };

    template <typename DeducedR, typename... DeducedArgs>
    struct callable_type_info<std::function<DeducedR(DeducedArgs...)>>
    {
        typedef DeducedR return_type;
        typedef variadic_typedef<DeducedArgs...> args_type;
    };

    template <typename Func>
    struct return_type
    {
        typedef typename callable_type_info<Func>::return_type type;
    };

    template <typename Func>
    struct args_type
    {
        typedef typename callable_type_info<Func>::args_type type;
    };

    template <typename FuncR, typename... FuncArgs>
    struct composed_function_type
    {
        typedef composed_function<FuncR, FuncArgs...> type;
    };

    template <typename FuncR, typename... FuncArgs>
    struct composed_function_type<FuncR, variadic_typedef<FuncArgs...>> :
        composed_function_type<FuncR, FuncArgs...>
    {};

    template <typename R, typename... Args>
    class composed_function
    {
    public:
        composed_function(std::function<R(Args...)> func) :
        mFunction(std::move(func))
        {}

        template <typename... CallArgs>
        R operator()(CallArgs&&... args)
        {
            return mFunction(std::forward<CallArgs>(args)...);
        }

        template <typename Func>
        typename composed_function_type<
                    typename return_type<Func>::type, Args...>::type
             operator>>(Func func) /* && */ // rvalues only (unsupported for now)
        {
            std::function<R(Args...)> thisFunc = std::move(mFunction);

            return typename composed_function_type<
                                typename return_type<Func>::type, Args...>::type(
                                        [=](Args... args)
                                        {
                                            return func(thisFunc(args...));
                                        });
        }

    private:    
        std::function<R(Args...)> mFunction;
    };
}

template <typename Func>
typename detail::composed_function_type<
            typename detail::return_type<Func>::type,
                typename detail::args_type<Func>::type>::type
    compose(Func func)
{
    return typename detail::composed_function_type<
                        typename detail::return_type<Func>::type,
                            typename detail::args_type<Func>::type>::type(func);
}

int main()
{
    using namespace std;

    auto l1 = [](int i, int j) {return i + j;};
    auto l2 = [](int i) {return i * i;};

    std:function<int(int, int)> f1 = l1;
    function<int(int)> f2 = l2;

    cout << "Function composition: " << (compose(f1) >> f2)(3, 5) << endl;
    cout << "Function composition: " << (compose(l1) >> l2)(3, 5) << endl;
    cout << "Function composition: " << (compose(f1) >> l2)(3, 5) << endl;
    cout << "Function composition: " << (compose(l1) >> f2)(3, 5) << endl;

    return 0;

That's a quite a bit of code! Unfortunately I don't see how it can be reduced any.

You can go another route and just make it so to use lambdas in your scheme, you just have to explicitly make them std::function<>s, but it's less uniform. Some of the machinery above could be used to make some sort of to_function() function for making lambda functions into std::function<>s.

Answer 2

This code should do the job. I've simplified it so these only work on functions with one argument, but you should be able to extend it to take functions of more than one argument by some variadic template magic. Also you'd may want to restrict the << operator appropriately.

#include <iostream>

template <class LAMBDA, class ARG>
auto apply(LAMBDA&& l, ARG&& arg) -> decltype(l(arg))
{
  return l(arg);
}

template <class LAMBDA1, class LAMBDA2>
class compose_class
{
public:
  LAMBDA1 l1;
  LAMBDA2 l2;

  template <class ARG>
  auto operator()(ARG&& arg) -> 
    decltype(apply(l2, apply(l1, std::forward<ARG>(arg))))
  { return apply(l2, apply(l1, std::forward<ARG>(arg))); }

  compose_class(LAMBDA1&& l1, LAMBDA2&& l2) 
    : l1(std::forward<LAMBDA1>(l1)), l2(std::forward<LAMBDA2>(l2)) {}
};

template <class LAMBDA1, class LAMBDA2>
auto operator>>(LAMBDA1&& l1, LAMBDA2&& l2) -> compose_class<LAMBDA1, LAMBDA2>
{
  return compose_class<LAMBDA1, LAMBDA2>
    (std::forward<LAMBDA1>(l1), std::forward<LAMBDA2>(l2));
}

int main()
{    
  auto l1 = [](int i) { return i + 2; };
  auto l2 = [](int i) { return i * i; };

  std::cout << (l1 >> l2)(3) << std::endl;
}

(p.s. You probably don't need the indirection of "apply", just had some trouble compiling without it)