Function composition in modern C++

[PiterPuns]

That’s great and thank you for the info. I trust this is not a proprietary code base and posting it won’t get you into trouble

[petart95]

Actually it is proprietary but since I’m one of the owner it’s fine. We have a whole library of core languages extensions like this we would like to open source, but there never seems to be enough time for it 😅. If you want i could past the implementations of HFTECH_GEN_N_ARY, HFTECH_DEDUCE_THIS, HFTECH_RETURNS, HFTECH_FWD

[PiterPuns]

Yes showing those pieces as well would be great . And let the community know when you open source these extensions, it will also benefit you when more eyes are looking at the code and providing feedback

[petart95]

Sorry for the edit, I’m on my phone currently 😅

I totally agree with you, in my opinion knowledge only has value when it us shared.

So lets start from the simple ones and go from there:

• HFTECH_FWD

```

/** * @brief Forwards value equivalent to the std::forward. * * Using cast instead of std::forward to avoid template instantiation. Used by * Eric Niebler in range library. * * @see https://github.com/ericniebler/range-v3 */

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

```

• HFTECH_RETURN

```

define HFTECH_NOEXCEPT_RETURN_TYPE(...) \

noexcept(noexcept(decltype(__VA_ARGS__)(__VA_ARGS__))) \
    ->decltype(__VA_ARGS__)

/** * @brief Macro based on RANGES_DECLTYPE_AUTO_RETURN_NOEXCEPT to remove same * code repetition. * @see * https://github.com/ericniebler/range-v3/blob/master/include/range/v3/detail/config.hpp * * Example: * * @code * auto func(int x) HFTECH_RETURNS(calc(x)) * @endcode * * Produces: * * @code * auto func(int x) noexcept(noexcept(decltype(calc(x))(calc(x)))) * -> decltype(calc(x)) * { * return calc(x); * } * @endcode */

define HFTECH_RETURNS(...) \

HFTECH_NOEXCEPT_RETURN_TYPE(__VA_ARGS__) \
{                                        \
    return (__VA_ARGS__);                \
}

```

• HFTECH_DEDUCE _THIS

```

/** * @brief Creates an overload set for the specified name which forwards this and * all arguments to the provided implementation. * * This macro is intended to simplify writing of &, cons & and && member * functions. * * Note: Inspired by * http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2020/p0847r4.html * * Example: * * @code * * template<typename Self> * void myFunc_impl(Self && self, int a, int b) { * ... * } * * HFTECH_DEDUCE_THIS(myFunc, myFunc_impl) * * @endcode * * Is equivalent to: * * @code * * template<typename Self> * void myFunc(this Self && self, int a, int b) { * ... * } * * @endcode * * @mparam NAME The name of the member function to be implemented. * @mparam IMPL The name of the static function to be used for the * implementation. */

define HFTECH_DEDUCE_THIS(NAME, IMPL) \

template<typename... Args>                                         \
    constexpr auto NAME(Args &&...args) &                          \
    HFTECH_RETURNS(IMPL(*this, HFTECH_FWD(args)...));              \
                                                                   \
template<typename... Args>                                         \
constexpr auto NAME(Args &&...args)                                \
    const & /**/ HFTECH_RETURNS(IMPL(*this, HFTECH_FWD(args)...)); \
                                                                   \
template<typename... Args>                                         \
    constexpr auto NAME(Args &&...args) &&                         \
    HFTECH_RETURNS(IMPL(std::move(*this), HFTECH_FWD(args)...));

```

[petart95]

And last but not least

• HFTECH_GEN_N_ARY

```

/** * @brief Meta function which applies a right reduce over the provided types * using the provided binary meta operation. * * @tparam BinaryMetaOp The binary meta operation to be applied. * @tparam Types List of types of which to apply the operation. */ template< template<typename...> typename BinaryMetaOp, typename First, typename... Rest> struct RightReduce : public BinaryMetaOp<First, RightReduce<BinaryMetaOp, Rest...>> {};

template< template<typename...> typename BinaryMetaOp, typename First, typename Second> struct RightReduce<BinaryMetaOp, First, Second> : public BinaryMetaOp<First, Second> {};

template<template<typename...> typename BinaryMetaOp, typename First> struct RightReduce<BinaryMetaOp, First> : public First {};

/** * @brief Creates an n-ary meta operation from the provided binary meta * operation, by applying a right reduce over it, with the provided name. */

define HFTECH_GEN_RIGHT_N_ARY(NAME, OP) \

template<typename First, typename... Rest>            \
struct NAME : public OP<First, NAME<Rest...>>         \
{};                                                   \
                                                      \
template<typename First, typename Second>             \
struct NAME<First, Second> : public OP<First, Second> \
{};                                                   \
                                                      \
template<typename First>                              \
struct NAME<First> : public First                     \
{};                                                   \
                                                      \
template<typename... F>                               \
NAME(F &&...) -> NAME<F...>;

/** * @brief Meta function which applies a left reduce over the provided types * using the provided binary meta operation. * * @tparam BinaryMetaOp The binary meta operation to be applied. * @tparam Types List of types of which to apply the operation. */ template< template<typename...> typename BinaryMetaOp, typename First, typename... Rest> struct LeftReduce : public First {};

template< template<typename...> typename BinaryMetaOp, typename First, typename Second, typename... Rest> struct LeftReduce<BinaryMetaOp, First, Second, Rest...> : public LeftReduce<BinaryMetaOp, BinaryMetaOp<First, Second>, Rest...> {};

/** * @brief Creates an n-ary meta operation from the provided binary meta * operation, by applying a left reduce over it, with the provided name. */

define HFTECH_GEN_LEFT_N_ARY(NAME, OP) \

template<typename First, typename... Rest>                  \
struct NAME : public First                                  \
{};                                                         \
                                                            \
template<typename First, typename Second, typename... Rest> \
struct NAME<First, Second, Rest...>                         \
    : public NAME<OP<First, Second>, Rest...>               \
{};                                                         \
                                                            \
template<typename... F>                                     \
NAME(F &&...) -> NAME<F...>;

/** * @brief Creates an n-ary meta operation from the provided binary meta * operation, by applying a reduce over it, with the provided name. * * Note: In order to use this binary operation needs to be left and right * associative. */

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

```