“拼合”嵌套期货

Question

我有我使用一个辅助功能“扁平化”嵌套期货成一个单一的未来：

编辑：改名为“折”到“扁平化”的建议。

我使用的是期货从Boost库：

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(); 

的问题是，这只是作品，如果我转换“嵌套”的未来变成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所有实例std::future的代码已经测试和工程在我结束）

的问题是， lambda表达式或者通过值来捕获（这实际上意味着通过拷贝捕获）或者通过引用（这里不适用，因为我们希望将未来的生命周期与我们的关闭联系起来），而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<std::future<...std::future<T>...>>>转换为std::future<T>，那么也许我会打电话给flatten_future。或者也许只是flatten，因为毕竟它首先只接受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)...)); 
}