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

live example on wandbox.org

折叠嵌套std :: future

1 个答案: