折疊嵌套std :: future

Question

我想折疊一個嵌套的std::future ，例如

void foo(std::future<int>)
{
}

foo(fold(std::declval<std::future<std::future<std::shared_future<int>>>>());

到目前為止，這是我未曾嘗試過的。 它似乎在std::future<void>變體方面特別存在問題。

有什么建議么？

#include <future>
#include <type_traits>
#include <string>

namespace detail {

template <typename T>
auto get(T&& f)
{
    return f;
}

auto get(std::future<void>&& f)
{
    return f.wait();
}

auto get(std::shared_future<void> f)
{
    return f.wait();
}

template <typename T>
auto get(std::future<T>&& f)
{
    return detail::get(f.get());
}

template <typename T>
auto get(std::shared_future<T> f)
{
    return detail::get(f.get());
}

}

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

Answer 1

以下對我有用：

template <typename T>
auto fold(T&& x)
{
    return x;
}

template <typename T>
auto fold(std::future<T>&& f)
{
    return fold(f.get());
}

template <>
auto fold(std::future<void>&& f)
{
    return f.get();
}

測試用例：

auto r0 = fold(std::future<std::future<std::future<int>>>{
    std::async(std::launch::async, [] {
        return std::async(std::launch::async, [] {
            return std::async(std::launch::async, [] { return 0; });
        });
    })});
fold(std::future<std::future<std::future<void>>>{
    std::async(std::launch::async, [] {
        return std::async(std::launch::async, [] {
            return std::async(std::launch::async, [] { return; });
        });
    })});

wandbox.org上的實時示例