C++20 函数式函数调用

Question

我最近一直在努力实现以函数式（管道）样式调用函数的方法，例如给定函数 foo(int, float) 可以以这种方式调用 10 | foo(10.f) 。

（这里假设管道算子，其实可以是随机的）

这是我所知道的

string _add(int&& a1, int&& a2)
{
    return "ADD i:" + to_string(a1) + " i:" + to_string(a2);
}

string _add(float&& a1, int&& a2)
{
    return "ADD f:" + to_string(a1) + " i:" + to_string(a2);
}

string _add(int&& a1, float&& a2)
{
    return "ADD i:" + to_string(a1) + " f:" + to_string(a2);
}

struct add_name;
template <typename SUBJ, typename A1>
auto operator|(SUBJ subj, args<add_name, A1, monostate> args)
{
    return _add(move(subj), move(args.a1));
}
template <typename A1> using add = args<add_name, A1, monostate>;

其中args 是一个保存参数的模板结构。 这允许我调用这样的函数

string s1 = 10.f | add(15);
string s2 = 10 | add(15);
string s3 = 10 | add(10.f);

最终有一个宏可以为每个函数名称生成模板，我能够非常成功地使用它。 此外，这对于重载和函数模板非常有效。

然而，这有一个巨大的缺点，即所有的函数特化都需要在定义操作符模板之前知道。

随着代码库的增长，它的使用变得越来越具有挑战性。

我一直在反复思考不同的想法，但存在 C++ 限制，无法以更有用的方式实现它，包括

1. 无法将函数名沿模板特化链传递
2. C++ 抱怨（重新）定义完全相同的模板

有没有办法实现如上所述的函数流水线？

Answer 1

只需将operator| 设为通用：

template<typename LeftT, typename RightT>
auto operator|(LeftT&& left, RightT&& right)
-> decltype(std::forward<RightT>(right)(std::forward<LeftT>(left)))
{return std::forward<RightT>(right)(std::forward<LeftT>(left));}

现在这允许您value | single_arg_method 为整个代码库中的任何值和一元函数。 （虽然这会使你的编译器错误变得复杂，只要你在一个无辜的| 附近有错字）

那么唯一的技巧就是让add(15) 生成所需的一元函数。如果没有宏，我无法想出一种方法来为这个函数赋予与其调用的方法相同的名称。

#define define_bifunction_to_monofunction(name) \
template<class ArgT> \
auto name(ArgT&& right) { \
    return [&right](auto&& left){ \
        return _ ## name(std::forward<decltype(left)>(left), std::forward<ArgT>(right)); \
    }; \
}

（比我更了解宏的人现在可能如何使用## 让它调用_add 而不是add）

现在用法很简单：

string _add(int&& a1, float&& a2)
{
    return "ADD i:" + to_string(a1) + " f:" + to_string(a2);
}
define_bifunction_to_monofunction(add)

int main() {
    string s1 = 10.f | add(15);
    string s2 = 10 | add(15);
    string s3 = 10 | add(10.f);
}

http://coliru.stacked-crooked.com/a/30697aebc0d594ac

但是，这确实使operator| 过于激进，这可能会导致奇怪的编译器错误，因此通常建议制作某种类型标志，这会使实现稍微复杂化：

template<typename FunctionT>
struct enabled_pipe_chaining : std::false_type {};

template<typename LeftT, typename RightT, typename enabled=std::enable_if_t<enabled_pipe_chaining<RightT>::value,void> >
auto operator|(LeftT&& left, RightT&& right)
{return std::forward<RightT>(right)(std::forward<LeftT>(left));}

#define enable_mono_pipe_chain(name) \
template<> struct enabled_pipe_chaining<decltype(name)> : std::true_type {};

#define define_bifunction_pipe_chain(name) \
template<typename RightT> \
struct name ## _pipe_chainable { \
    RightT&& right; \
    template<typename LeftT> \
    auto operator()(LeftT&& left) { \
        return _ ## name(std::forward<decltype(left)>(left), std::forward<RightT>(right)); \
    } \
}; \
template<typename RightT> struct enabled_pipe_chaining<name ## _pipe_chainable<RightT>> : std::true_type {}; \
template<typename RightT> \
name ## _pipe_chainable<RightT> name(RightT&& right) { return {std::forward<RightT>(right)};}

http://coliru.stacked-crooked.com/a/41ce66c1a1444495

但是operator| 将仅可用于 pipe_chainable 方法，而不是代码中的任何 operator|。

Answer 2

Clang 会告诉你在模板之后声明重载有什么问题：

error: call to function '_add' that is neither visible in the template definition nor found by argument-dependent lookup
    return _add(move(subj), move(args.a1));
           ^

最简单的解决方案是通过传递标记类型来启用依赖于参数的查找：

struct adl_tag {};
template <typename SUBJ, typename A1>
auto operator|(SUBJ subj, args<add_name, A1, monostate> args)
{
    return _add(adl_tag{}, move(subj), move(args.a1));
}
string _add(adl_tag, int&& a1, int&& a2)
// etc.

Example.

Answer 3

所有函数特化都需要在定义运算符模板之前知道。

对于内置和非依赖类型，是的。 对于依赖类型，ADL 可能会有所帮助。

无法将函数名沿模板特化链传递

传递重载集不能通过名称传递，但可以通过 lambda。

C++ 抱怨（重新）定义完全相同的模板

你有标签，允许你不同的重载，所以应该没有问题。

但是，如果您提供 Functor 作为模板参数，您可能只写一个 operator|，类似于：

template <auto, typename T>
struct Args
{
    Args(T data) : data(std::move(data)) {}
    
    T data;  
};

template <typename LHS, auto F, typename T>
auto operator|(LHS&& lhs, Args<F, T> rhs)
{
    return F(std::forward<LHS>(lhs), std::move(rhs.data));
}

然后

// Your overloads
std::string _add(int&& a1, int&& a2)
{
    return "ADD i:" + std::to_string(a1) + " i:" + std::to_string(a2);
}

std::string _add(float&& a1, int&& a2)
{
    return "ADD f:" + std::to_string(a1) + " i:" + std::to_string(a2);
}

std::string _add(int&& a1, float&& a2)
{
    return "ADD i:" + std::to_string(a1) + " f:" + std::to_string(a2);
}

// The alias
template <typename T>
using add = Args<[](auto&& lhs, auto&& rhs){ return _add((decltype(lhs))lhs, (decltype(rhs))rhs); }, T>;

Demo.