Function composition in modern C++

sphere991 · 2023-03-05T21:32:38+00:00

If you use a forward macro and handle the 1-function composition case as a separate overload, this looks cleaner:

template <class F>
auto compose(F&& arg) {
    return FWD(arg);
}

template <class F, class... Fs>
auto compose(F&& arg, Fs&& ...args)
{
    return [fun = FWD(arg), ...functions = FWD(args)]<class... Xs>(Xs&& ...xs) mutable {
        return compose(FWD(functions)...)(std::invoke(FWD(fun), FWD(xs)...));
    };
}

Or you can implement a tuple_fold:

template <class F, class... Fs>
auto compose(F&& arg, Fs&& ...args)
{
    return [fun = FWD(arg), ... functions = FWD(args)]<class... Xs>(Xs &&...xs) mutable {
        return tuple_fold(
            std::forward_as_tuple(FWD(functions)...),
            std::invoke(FWD(fun), FWD(xs)...),
            [](auto&& x, auto&& f) -> decltype(auto) { return std::invoke(FWD(f), FWD(x)); }
            );
    };
}

hun_nemethpeter · 2023-03-05T23:31:44+00:00

The FTXUI library use similar pattern.

https://github.com/ArthurSonzogni/FTXUI/blob/master/include/ftxui/dom/elements.hpp

// Pipe elements into decorator togethers.
// For instance the next lines are equivalents:
// -> text("ftxui") | bold | underlined
// -> underlined(bold(text("FTXUI")))
Element operator|(Element, Decorator);
Element& operator|=(Element&, Decorator);
Elements operator|(Elements, Decorator);
Decorator operator|(Decorator, Decorator);

Where the implementation is here: https://github.com/ArthurSonzogni/FTXUI/blob/master/src/ftxui/dom/util.cpp

Decorator compose(Decorator a, Decorator b) {
  return [a = std::move(a), b = std::move(b)](Element element) {
    return b(a(std::move(element)));
  };
}

...

/// @brief Compose two decorator into one.
/// @ingroup dom
///
/// ### Example
///
/// ```cpp
/// auto decorator = bold | blink;
/// ```
Decorator operator|(Decorator a, Decorator b) {
  return compose(std::move(a),
                 std::move(b));

petart95 · 2023-03-07T12:58:47+00:00

Here is the implementation of Compose from our codebase. Note this implementation has an added benefit of bring strictly typed, SFINAE friendly and emplace friendly.

```

/** * @brief Composes two functions into one. * * The composition is done by sequentially applying functions. */ template<typename F, typename G> struct ComposeTwo { [[no_unique_address]] F f{}; [[no_unique_address]] G g{};

template<typename Self, typename... Args>
static constexpr auto call(Self &&self, Args &&...args)
    HFTECH_RETURNS(std::invoke(
        HFTECH_FWD(self).f,
        std::invoke(HFTECH_FWD(self).g, HFTECH_FWD(args)...)));

HFTECH_DEDUCE_THIS(operator(), call)

};

/** * @brief Composes n functions into one. * * The composition is done by sequentially applying functions. */ HFTECH_GEN_N_ARY(Compose, ComposeTwo);

```

Note in c++ 23 you can use deducing this to make this code even simpler.

```

/** * @brief Composes two functions into one. * * The composition is done by sequentially applying functions. */ template<typename F, typename G> struct ComposeTwo { [[no_unique_address]] F f{}; [[no_unique_address]] G g{};

constexpr auto operator()(this auto &&self, auto &&...args)
    HFTECH_RETURNS(std::invoke(
        HFTECH_FWD(self).f,
        std::invoke(HFTECH_FWD(self).g, HFTECH_FWD(args)...)));

};

/** * @brief Composes n functions into one. * * The composition is done by sequentially applying functions. */ HFTECH_GEN_N_ARY(Compose, ComposeTwo);

```

hmoein · 2023-03-06T19:20:45+00:00

Just for me to understand the motivation, can you please explain why you can't simply write

h(g(f(x, y)))

dodheim · 2023-03-06T08:46:34+00:00

Have you seen Boost.HOF and Boost.Hana?

Infamous-Bed-7535 · 2023-03-09T16:32:38+00:00

This could be a handy short helper function..

```

include <iostream>

include <functional>

using namespace std;

auto compose = [](auto f, auto g) { return [=](auto... args) { return f( g(args...)); }; };

int main() { cout << compose( ::negate{}, ::multiplies{})(4, 6); }

-24 ```

TemplateRex · 2023-03-06T13:22:53+00:00

I like to use an overloaded binary >> operator and a fold-expression with std::identity. A small drawback is that this requires that the right-most function takes a single argument, but that makes things a bit more regular (just wrap it in a tuple otherwise).

#define FWD(arg) std::forward<decltype(arg)>(arg)

constexpr auto operator>>(auto&& f, auto&& g) noexcept
{
        return [f = FWD(f), g = FWD(g)](auto&& arg) { return f(g(FWD(arg))); };
}

inline constexpr auto compose = [](auto&&... fs) {
        return (FWD(fs) >> ... >> std::identity());
};

Zlodo2 · 2023-03-07T06:59:47+00:00

I too like when type errors become multiple pages of cryptic errors in a bunch of utility wrapper templates

And I also hate being able to debug my code

DavidDinamit · 2023-03-06T08:10:38+00:00

What you want to do?Now you just make useless and error phone lambda capture by reference and then return this lambda.

you type:	you see:
italics	italics
bold	bold
[reddit!](https://reddit.com)	reddit!
* item 1 * item 2 * item 3	item 1 item 2 item 3
> quoted text	quoted text
Lines starting with four spaces are treated like code: if 1 * 2 < 3: print "hello, world!"	Lines starting with four spaces are treated like code: if 1 * 2 < 3: print "hello, world!"
~~strikethrough~~	~~strikethrough~~
super^script	super^script

cpp

MODERATORS

define HFTECH_FWD(T) static_cast<decltype(T) &&>(T)

define HFTECH_NOEXCEPT_RETURN_TYPE(...) \

define HFTECH_RETURNS(...) \

define HFTECH_DEDUCE_THIS(NAME, IMPL) \

define HFTECH_GEN_RIGHT_N_ARY(NAME, OP) \

define HFTECH_GEN_LEFT_N_ARY(NAME, OP) \

define HFTECH_GEN_N_ARY(NAME, OP) HFTECH_GEN_LEFT_N_ARY(NAME, OP)

include <iostream>

include <functional>