“压平”嵌套期货

Question

我有一个辅助函数，用于将嵌套的 future“展平”为单个 future：

编辑：按照建议将“fold”重命名为“展平”。

我正在使用 boost 库中的 futures：

template<typename T>
auto flatten(boost::unique_future<T>&& f) -> boost::unique_future<decltype(f.get().get())>
{
    auto shared_f = boost::shared_future<T>(std::move(f));
    return async(launch_policy::deferred, [=]() mutable
    {
        return shared_f.get().get();
    });
}

它的使用方式如下：

auto nested_future_result = async([]() -> boost::shared_future<int>
{
    auto tmp = async([]
    {
        return 1;
    });
    return boost::shared_future<int>(std::move(tmp));    
});

boost::unique_future<int> future_result = flatten(nested_future_result);
int result = future_result.get();

问题是，只有当我将“嵌套”future 转换为 shared_future 时，这才有效。有什么好的方法可以绕过它吗？我想要的是这样的：

auto future_result = flatten(async([]
{
    return async([]
    {
        return 1;
    }); 
}));

int result = future_result.get();

其次，我有点不确定该方法的名称。有什么意见吗？

Answer 1

（注意：我不明白你如何让 boost::unique_future 与 std::async 配合，所以我替换了 boost::unique_future< 的所有实例/code> 和 std::future 代码已经过测试并且可以在我这边运行。）

问题是 lambda 表达式要么按值捕获（这实际上意味着通过复制捕获），要么按引用捕获（不适用于我们想要的这里将 future 的生命周期与我们的闭包联系起来），而 std::future 是仅移动的。答案通常是 std::bind，尽管在​​本例中 std::async 具有内置的类似 bind 的功能：

template<typename T>
auto fold(std::future<T>&& f)
-> std::future<decltype(f.get().get())>
{
    return std::async(std::launch::deferred, [](std::future<T>&& f)
    {
        return f.get().get();
    }, std::move(f));
}

恐怕我没有好名字可以推荐。如果模板可能递归地转换任何 std::future...>>>到 std::future 那么也许我会调用 if flatten_future。或者也许只是展平，因为毕竟它首先只接受std::future。

---

假设我们已经有一个一元async：

template<typename Functor, typename Arg, typename... Args>
auto async(Functor&& functor, Arg&& arg, Args&&.... args)
-> decltype( async(std::bind(std::forward<Functor>(functor)
    , std::forward<Arg>(arg), std::forward<Args>(args)...)) )
{
    return async(std::bind(std::forward<Functor>(functor)
        , std::forward<Arg>(arg), std::forward<Args>(args)...));
}