返回 std::function 的类 std::bind 函数

Question

我需要一个 bind 函数，它的行为类似于 std::bind，但返回 std::function 的适当特化。

我认为std::function 模板参数可以使用函数参数中的占位符编号提取。不过，这看起来并不那么微不足道。是否有任何可用的实现？

---

为什么我需要这个

我想实现一个语义类似于this JavaScript one的waterfall函数。

这是我想象的 C++ 中的样子：

std::function<void(const std::string &)> f = waterfall(
  []( const std::function<void(int)> &cb, const std::string & ) {
    ...;
    cb( 1 );
  },
  []( const std::function<void(double, double)> &cb, int ) {
    ...;
    cb(0.5, 10);
  },
  []( double, double ) {
  }
);

换句话说，waterfall 将采用一堆函数，每个函数（但最后一个）将一个函数作为第一个参数。 waterfall 会将每个函数绑定到前一个函数（当然是从最后一个函数开始），并返回一个函数。

瀑布基本上应该是这样的：

// recursion termination: `waterfall` called with a single functions
template< typename Arg >
auto waterfall( const Arg& first ) -> decltype( first ) {
  return first;
}
// recursion: `waterfall` called with mulitple functions
template< typename Arg, typename... Args >
... waterfall( const Arg& first, Args... args ) {
  return std::bind( first, waterfall(std::forward<Args>(args)...) );
}

虽然存在三个未解决的问题：

1. 在使用多个参数调用时确定waterfall 的返回类型。它不能是decltype( std::bind(first, waterfall(...)) )（因为 C++ 不允许递归调用模板函数来推断其类型）。如果我知道函数的类型（即Arg），那么如果没有第一个参数，那将是我正在寻找的返回类型。
2. 我想我需要知道first 的参数数量才能正确std::bind。
3. std::bind 的返回类型不符合我的要求：嵌套 std::bind 调用合并所有绑定函数在一起，而不是组合它们。

我能够通过编写一个 std::bind 包装器来绕过第三点，该包装器将绑定函数包装到 T 类型的对象中，这样 std::is_bind_expression<T>::value == false。

对于前两点，我需要找出waterfall 参数的返回类型和参数类型。如果函数是std::functions，这将是微不足道的。如果它们是 lambda、经典函数或具有单个 operator() 的函子，那也很简单：我只需要使用类似 this function_traits 的东西。但是我真的想将使用std::bind 绑定的函数传递给waterfall，而不必手动将它们转换为std::functions，因为这使我的代码方式 更短，方式更清晰，waterfalls 大。

有什么想法、想法或建议吗？

Answer 1

这里的设计是在一个辅助类details::waterfall 中完成大部分工作，2 功能瀑布式组合在waterfall_call 中完成。

#include <iostream>
#include <utility>
#include <functional>
#include <string.h>

namespace details {

如果我在结构定义之外衰减，这会稍微更有效，因为在某些情况下它会减少唯一类型。我不在乎：

  template<class F0, class F1>
  struct waterfall_call {
    typename std::decay<F0>::type f0;
    typename std::decay<F1>::type f1;

调用 f0 并传递 f1 和 args...：

    template<class...Args>
    auto operator()(Args&&... args)const
    -> typename std::result_of<F0 const&(F1 const&,Args...)>::type
    {
      return f0( f1, std::forward<Args>(args)... );
    }
  };

算法的中心：

  struct waterfall {

对于 2 个参数，只需使用 waterfall_call:

    template<class F0, class F1>
    waterfall_call<F0, F1> operator()( F0&& f0, F1&& f1 )const
    {
      return { std::forward<F0>(f0), std::forward<F1>(f1) };
    }

对于 >2 args，递归，然后做一个 2 arg 解决方案：

    template<class F0, class...Fs,
      class I=typename std::result_of<waterfall const&(Fs...)>::type
    >
    auto operator()( F0&& f0, Fs&&... fs )const
    -> typename std::result_of< waterfall( F0, I ) >::type
    {
      auto child = (*this)( std::forward<Fs>(fs)... );
      return (*this)( std::forward<F0>(f0), std::move(child) );
    }

对于 1 个 arg，只需转发到输入 arg 的衰减版本：

    template<class F0>
    auto operator()(F0&&f0)const
    ->typename std::decay<F0>::type
    {
      return std::forward<F0>(f0);
    }
  };
}

而waterfall 本身只是委托给details::waterfall：

template<class...Fs>
auto waterfall(Fs&&... fs )
-> typename std::result_of<details::waterfall(Fs...)>::type{
  return details::waterfall{}( std::forward<Fs>(fs)... );
}

live example

绕过递归模板返回类型推导限制的另一种方法（除了上面的struct 技巧）是从函数的命名空间中按模板类型获取参数，并将其传递给递归调用。这启用了 ADL 查找，即使在推断您自己的返回类型时，它也可以递归地找到您自己的函数。