C++ 组合返回期货的函数

假设我有两个返回未来的函数：

std::future<T> foo(int);

std::future<U> bar(T const &);

此函数将一直阻止，直到

foo

返回的future完成，对吗？这显然不是我想要的

std::future<U> foobar2(int x)
{
  return std::async([=]()
  {
    auto foo_x = foo(x);
    return bar(foo_x.get()).get();
  });
}

---

在这里，我必须再次调用

bar

返回的future上的

get（）

，否则我将有一个

future

。这是正确的方法吗？

您想要的是单子

std:：future

几乎是一个单子，但不完全是单子，但缺乏通过提升函数来正确组合函数的能力，正如您所注意到的那样。有关这方面的详细讨论，请参阅

总结是，对于C++17，已经为

std:：future

提出了一种附加方法：要么

next

要么

then

，该方法将在未来值可用时采用一个应用于未来值的函数。这大致相当于Haskell中的

bind

（注意：不是

std:：bind

）

让我们看两个函数：

T foo(int);
U bar(T const &);

这里我们有一个映射

int->T->U

，您想要的是将这个映射提升到

int->std:：future->std:：future

。这可能是什么样子的：

int x = 2;
std::async([=](){return foo(x);}).then(bar);

其中，

那么

是一个自动将

T->U

映射到

std:：future->std:：future

的函数

免责声明：我不是Haskell程序员，我意识到我可能把一切都搞混了。我很高兴接受更正

T foo(int);
U bar(T const &);

int x = 2;
std::async([=](){return foo(x);}).then(bar);