c++ - 在知道可调用参数之前如何约束惰性组合？

Question

所以我正在研究 GCC6 及其概念实现，并且我认为 Haskell Prelude 将是一个很好的实验来源。 Haskell 的核心功能之一是函数组合，这是我需要立即解决的问题。

尽我所能模仿 Haskell 语法，我编写了这个函数:

template <typename F, typename G>
auto operator*(F f, G g)
{
  return [f, g](auto... args) {
    return f(g(args...));
  }
}

效果很好，可以让我做类似的事情:

auto add([](int a, int b) { return a + b; }
auto doubled([](int a) { return a * 2; }

auto add_then_double(doubled * add);
assert(add_then_double(2, 3) == 10);

很高兴，我决定回去对我的函数组合应用一些约束，但由于它的惰性，我很快遇到了一个问题。

首先我写了这个概念:

template <typename F, typename Ret, typename... Args>
concept bool Function()
{
  return requires(F f, Args ...args) {
    { f(args...) } -> Ret;
  }
}

我基于在 Andrew Sutton's origin 中找到的概念github项目。

所以我尝试将其应用于我的原始功能。我遇到的问题是，在不知道传递给 G 的参数的情况下，我不知道 G 返回什么，所以我无法约束 G而且我不知道 F 在不知道给定的参数的情况下返回什么，我不知道是因为我不知道 G 返回什么。

我很确定我需要一个新的 Function 概念，它不关心返回类型，因为我的组合函数不关心 F 返回什么，所以只要它是可调用的。而且我想我可以对参数类型的内部 lambda 施加约束，并针对 G 和 F 进行更正，但这意味着我可以编写不可组合的函数，并且在调用站点之前不会出错。这是可以避免的吗？

也许是这样的:

template <typename F, typename G>
auto operator*(F f, G g)
{
  return [f, g](auto... args) 
    // is it even possible to constrain here?
    requires FunctionAnyReturn<G, decltype(args)...>
      && FunctionAnyReturn<F, decltype(G(decltype(args)...))>
  {
    return f(g(args...));
  }
}

这是我能做的最好的事情吗(如果我能做到的话)？

Answer 1

如您所见，将约束放在正确的位置确实很重要。在您的情况下，必须约束结果的 operator()，而不是组合函数本身。你真的不能做得更好，例如考虑许多函数没有单一的返回类型(例如 std::make_tuple)。然而，虽然 Concepts-Lite 确实稍微触及了 lambda 表达式，但它并没有达到允许对它们使用 requires 子句的程度，因此您的尝试不会奏效。

在大多数情况下，我通常的建议是编写 lambda 表达式，以便生成的 operator() 自然受到 SFINAE 的约束。在您的情况下，这意味着避免返回类型推导:

return [f, g](auto... args) -> decltype( f(g(args...)) )
{ return f(g(args...)); }

如果您使用例如铛，everything is peachy .如果使用 GCC，您可能会遇到错误 GCC performs some checking too early .

另一种方法是不遗余力地“展开”lambda 表达式的闭包类型。通过将其设为用户定义类型，您可以使用所有技巧，特别是您可以编写所需的显式约束:

template<typename F, typename G>
struct compose_type {
    F first_composed_function;
    G second_composed_function;

    template<typename... Args>
    constexpr auto operator()(Args... args)
        // substitute in whichever concepts and traits you're actually using
        requires
            Callable<G, Args...>
            && Callable<F, result_of<G, Args...>>
    { return first_composed_function(second_composed_function(args...)); }
};

template<typename F, typename G>
constexpr compose_type<F, G> compose(F f, G g)
{ return { std::move(f), std::move(g) }; }

Live On Coliru