在 Boost::range 中组合适配器

Question

我开始使用 Boost::Range 以获得pipeline of lazy transforms in C++。我现在的问题是如何将管道分成更小的部分。假设我有：

int main(){
  auto map = boost::adaptors::transformed; // shorten the name
  auto sink = generate(1) | map([](int x){ return 2*x; })
                          | map([](int x){ return x+1; })
                          | map([](int x){ return 3*x; });
  for(auto i : sink)
    std::cout << i << "\n";
}

我想用magic_transform替换前两张地图，即：

int main(){
  auto map = boost::adaptors::transformed; // shorten the name
  auto sink = generate(1) | magic_transform()
                          | map([](int x){ return 3*x; });
  for(auto i : sink)
    std::cout << i << "\n";
}

如何写magic_transform？我查了Boost::Range's documentation，但我不能很好地掌握它。

附录：我正在寻找这样的类：

class magic_transform {
    ... run_pipeline(... input) {
        return input | map([](int x){ return 2*x; })
                     | map([](int x){ return x+1; });
};

Answer 1

最困难的问题是找出代码中的返回类型。 decltype 和 lambdas 不能很好地混合在一起（see here），所以我们不得不想一个替代方法：

auto map = boost::adaptors::transformed;

namespace magic_transform
{
   std::function<int(int)> f1 = [](int x){ return 2*x; };
   std::function<int(int)> f2 = [](int x){ return x+1; };
   template <typename Range>
   auto run_pipeline(Range input) -> decltype(input | map(f1) | map(f1))
   {
        return input | map(f1) | map(f2);
   }
}

...
auto sink = magic_transform::run_pipeline(generate(1))
                          | map([](int x){ return 3*x; });

简单的解决方案是将 lambdas 粘贴到 std::function 中，这样我们就可以使用 decltype 来推断返回类型。我在示例中使用了命名空间magic_transform，但如果您愿意，也可以将此代码改编成一个类。 Here is a link 使您的代码适应上述内容。

另外，在这里使用std::function 可能有点矫枉过正。相反，您可以只声明两个普通函数 (example)。

我也在试验boost::any_range，似乎与 C+11 lambda 有一些不兼容，等等。我能得到的最接近的是以下 (example)：

auto map = boost::adaptors::transformed;
using range = boost::any_range<
               const int,
               boost::forward_traversal_tag,
               const int&,
               std::ptrdiff_t
               >;

namespace magic_transform
{
    template <typename Range>
    range run_pipeline(Range r)
    {
        return r | map(std::function<int(int)>([](int x){ return 2*x; }))
             | map(std::function<int(int)>([](int x){ return x+1; }));
    }
}

int main(){
  auto sink = magic_transform::run_pipeline(boost::irange(0, 10))
                          | map([](int x){ return 3*x; });
  for(auto i : sink)
    std::cout << i << "\n";
}

Answer 2

我认为可行：

auto magic_transform()->decltype(boost::adaptors::transformed(std::function<int(int)>())
{
    std::function<int(int)> retval = [](int x){ return [](int x){ return x+1; }(2*x);
    return boost::adaptors::transformed(retval);
}

但它可能不是您想要的。 :) （上面代码中的笑话：2*x+1 的链式 lambda，基本上实现上使用 decltype 来查找返回类型），

查看http://www.boost.org/doc/libs/1_46_1/boost/range/adaptor/transformed.hpp的源码，magic_transform要返回的类型是boost::range_detail::transform_holder<T>，其中T是函数的类型。

当您使用 lambda 在堆栈上执行此操作时，T 最终会成为一些非常窄的类型。如果您想在不暴露所有细节的情况下传递抽象转换，使用std::function<outtype(intype)> 可能是合理的（运行时开销会很小）。

希望有效。