scala.concurrent.Future的替代实现？

给定两个未来[选项[Int]：

scala> val x: Future[Option[Int]] = Future.successful { None }
x: scala.concurrent.Future[Option[Int]] = scala.concurrent.impl.Promise$KeptPromise@39dcf4b0

scala> val y: Future[Option[Int]] = Future.successful { Some(55) }
y: scala.concurrent.Future[Option[Int]] = scala.concurrent.impl.Promise$KeptPromise@7ef2d7a6

有没有更干净的方法来做以下事情

scala> def f[A](x: Future[Option[A]], 
                y: Future[Option[A]]): Future[Option[A]] = x.flatMap( _ match {
     |   case None => y
     |   case Some(_) => x
     | })
f: [A](x: scala.concurrent.Future[Option[A]], y: scala.concurrent.Future[Option[A]])scala.concurrent.Future[Option[A]]

我曾想过使用另一种方法，但我不确定是否有这样一种scala.concurrent.Future的实现：

>import Control.Applicative
> Nothing <|> Just 55
Just 55

>导入控制。应用程序
>没什么只是55
只有55岁

您可以使用以下机制：

import scala.concurrent.{Await, duration, ExecutionContext, Future}
import duration.Duration
import ExecutionContext.Implicits.global

val f = Future.reduce(Seq(x, y))(_ orElse _)
Await.result(f, Duration.Inf) // Some(55)

---

或者，如果选项的数量不清楚，请使用

Future.fold

将

选项归零。清空[Int]

您可以使用以下机制：

import scala.concurrent.{Await, duration, ExecutionContext, Future}
import duration.Duration
import ExecutionContext.Implicits.global

val f = Future.reduce(Seq(x, y))(_ orElse _)
Await.result(f, Duration.Inf) // Some(55)

---

或者，如果选项的数量不清楚，请使用

Future.fold

将

选项归零。清空[Int]

您可以使用以下机制：

import scala.concurrent.{Await, duration, ExecutionContext, Future}
import duration.Duration
import ExecutionContext.Implicits.global

val f = Future.reduce(Seq(x, y))(_ orElse _)
Await.result(f, Duration.Inf) // Some(55)

---

或者，如果选项的数量不清楚，请使用

Future.fold

将

选项归零。清空[Int]

您可以使用以下机制：

import scala.concurrent.{Await, duration, ExecutionContext, Future}
import duration.Duration
import ExecutionContext.Implicits.global

val f = Future.reduce(Seq(x, y))(_ orElse _)
Await.result(f, Duration.Inf) // Some(55)

---

或者如果选项的数量不清楚，请使用

Future.fold

和零的

Option.empty[Int]

如果您使用的是scalaz，您可以使用monad transformer，即使对于这样一个简单的示例来说有点过头

import scala.concurrent.Future
import scala.concurrent.ExecutionContext.Implicits.global
import scalaz.OptionT
import scalaz.std.scalaFuture.futureInstance

def f[A](x: Future[Option[A]],
         y: Future[Option[A]]): Future[Option[A]] = 
  OptionT(x).orElse(OptionT(y)).run

---

另外，函数的

\uumatch

部分是不必要的。

如果您使用的是scalaz，那么您可以使用monad transformer，即使对于这样一个简单的示例来说有点过头

import scala.concurrent.Future
import scala.concurrent.ExecutionContext.Implicits.global
import scalaz.OptionT
import scalaz.std.scalaFuture.futureInstance

def f[A](x: Future[Option[A]],
         y: Future[Option[A]]): Future[Option[A]] = 
  OptionT(x).orElse(OptionT(y)).run

---

另外，函数的

\uumatch

部分是不必要的。

如果您使用的是scalaz，那么您可以使用monad transformer，即使对于这样一个简单的示例来说有点过头

import scala.concurrent.Future
import scala.concurrent.ExecutionContext.Implicits.global
import scalaz.OptionT
import scalaz.std.scalaFuture.futureInstance

def f[A](x: Future[Option[A]],
         y: Future[Option[A]]): Future[Option[A]] = 
  OptionT(x).orElse(OptionT(y)).run

---

另外，函数的

\uumatch

部分是不必要的。

如果您使用的是scalaz，那么您可以使用monad transformer，即使对于这样一个简单的示例来说有点过头

import scala.concurrent.Future
import scala.concurrent.ExecutionContext.Implicits.global
import scalaz.OptionT
import scalaz.std.scalaFuture.futureInstance

def f[A](x: Future[Option[A]],
         y: Future[Option[A]]): Future[Option[A]] = 
  OptionT(x).orElse(OptionT(y)).run

此外，函数的

匹配部分也不是必需的