代码之家 › 专栏 › 技术社区 › Ali

可能会失败的多重未来——成功与失败并存?

scala-cats scalaz parallel-processing concurrency scala

Ali · 技术社区 · 6 年前

我有一个需要并行运行一系列操作的情况。

Seq[String] ).

有些操作可能会失败,而有些操作则会成功返回结果。

在我编写自己的类之前,是否有一种内置的方法,或者通过任何库(cats/scalaz)的简单方法来实现这一点?

我在考虑在每个操作各自的未来进行,然后检查每个未来,并返回一个元组 Seq[String] -> Seq[Throwable] 其中left值是成功的结果(展平/合并),right是发生的任何异常的列表。

4 回复 | 直到 6 年前

jwvh 6 年前

打电话 value Future 返回一个 Option[Try[T]] 未来 尚未完成则 Option None . 如果它已经完成,那么它很容易展开和处理。

if (myFutr.isCompleted)
  myFutr.value.map(_.fold( err: Throwable  => //log the error
                         , ss: Seq[String] => //process results
                         ))
else
 // do something else, come back later

Alexey Romanov 6 年前

使用 Await.ready 你在评论中提到的,使用期货通常会失去大部分好处。相反,你可以用普通的 Future 组合器。让我们做一个更通用的版本,它适用于任何返回类型;压平 Seq[String] 可以很容易地添加。

def successesAndFailures[T](futures: Seq[Future[T]]): Future[(Seq[T], Seq[Throwable])] = {
  // first, promote all futures to Either without failures
  val eitherFutures: Seq[Future[Either[Throwable, T]]] = 
    futures.map(_.transform(x => Success(x.toEither)))
  // then sequence to flip Future and Seq
  val futureEithers: Future[Seq[Either[Throwable, T]]] = 
    Future.sequence(eitherFutures)
  // finally, Seq of Eithers can be separated into Seqs of Lefts and Rights
  futureEithers.map { seqOfEithers =>
    val (lefts, rights) = seqOfEithers.partition(_.isLeft)
    val failures = lefts.map(_.left.get)
    val successes = rights.map(_.right.get)
    (successes, failures)
  }
}

Scalaz and Cats have separate to simplify the last step.

Dici gla3dr 6 年前

听起来像是一个很好的用例 Try 习语(基本上和 Either 单子)。

使用示例来自 doc :

import scala.util.{Success, Failure}

val f: Future[List[String]] = Future {
  session.getRecentPosts
}

f onComplete {
  case Success(posts) => for (post <- posts) println(post)
  case Failure(t) => println("An error has occurred: " + t.getMessage)
}

Mikhail Golubtsov 6 年前

import scala.concurrent.{Future, ExecutionContext}
import scala.util.Success

def eitherify[A](f: Future[A])(implicit ec: ExecutionContext): Future[Either[Throwable, A]] = f.transform(tryResult => Success(tryResult.toEither))

def eitherifyF[A, B](f: A => Future[B])(implicit ec: ExecutionContext): A => Future[Either[Throwable, B]] = { a => eitherify(f(a)) }

// here we need some "cats" magic for `traverse` and `separate`
// instead of `traverse` you can use standard `Future.sequence`
// there is no analogue for `separate` in the standard library

import cats.implicits._

def myProgram[A, B](values: List[A], asyncF: A => Future[B])(implicit ec: ExecutionContext): Future[(List[Throwable], List[B])] = {
  val appliedTransformations: Future[List[Either[Throwable, B]]] = values.traverse(eitherifyF(asyncF))
  appliedTransformations.map(_.separate)
}