「拼合」嵌套期貨

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)...)); 
}