Allows a functional style syntax for composing functions

compose.cpp

#include <functional>

template<class T>
struct wrap_impl
{
    wrap_impl(T&& x) : data(std::forward<T>(x)) { }
    
    T   get() const & { return data; }
    T&& get()      && { return std::move(data); }
private:
    T data;
};

template<class R, class... Args>
struct wrap_impl<R (&)(Args...)> : wrap_impl<std::function<R (Args...)>>
{
    using wrap_impl<std::function<R (Args...)>>::wrap_impl;
    using wrap_impl<std::function<R (Args...)>>::get;
};

template<class T>
wrap_impl<T> wrap(T&& x)
{
    return wrap_impl<T>(std::forward<T>(x));
}

template<typename T, typename U>
auto operator|(wrap_impl<std::function<T>>&& lhs,
               wrap_impl<std::function<U>>&& rhs)
{
    return [lhs = std::move(lhs),
            rhs = std::move(rhs)] (auto&&... x) { return lhs.get()(rhs.get()(std::forward<decltype(x)>(x)...)); };
}

int main()
{
    auto f = [] (int x) { return x*10; };
    auto g = [] (int y) { return y*10; };
    (wrap(f) | wrap(g))(5); // f(g(5))
}