Futuresの任意の長さのリストをFuture of Listに変換する方法を探しています。私はPlayframeworkを使用しているので、最終的に、私が本当に欲しいのはFuture[Result]
ですが、物事を簡単にするために、Future[List[Int]]
と言ってみましょう。これを行う通常の方法はFuture.sequence(...)
しかし、ひねりがあります...私が与えられたリストには、通常10-20前後の先物があり、それらの先物の1つが失敗することは珍しくありません(外部のWebサービスリクエストを行っています)。それらのいずれかが失敗した場合にそれらすべてを再試行する代わりに、成功したものを取得してそれらを返せるようにしたいと思います。
たとえば、次の操作は機能しません
import scala.concurrent._
import scala.concurrent.ExecutionContext.Implicits.global
import scala.util.Success
import scala.util.Failure
val listOfFutures = Future.successful(1) :: Future.failed(new Exception("Failure")) ::
Future.successful(3) :: Nil
val futureOfList = Future.sequence(listOfFutures)
futureOfList onComplete {
case Success(x) => println("Success!!! " + x)
case Failure(ex) => println("Failed !!! " + ex)
}
scala> Failed !!! Java.lang.Exception: Failure
唯一の例外を取得する代わりに、1と3をそこから引き出したいと思います。 Future.fold
を使用してみましたが、明らかに舞台裏でFuture.sequence
を呼び出しているようです。
助けてくれてありがとう!
秘Theは、先物が失敗していないことを最初に確認することです。 .recover
はここであなたの友達です。map
と組み合わせて、すべてのFuture[T]
結果をFuture[Try[T]]]
インスタンスに変換できます。
注:ここでもOption
またはEither
を使用できますが、例外をトラップする場合はTry
が最もクリーンな方法です
def futureToFutureTry[T](f: Future[T]): Future[Try[T]] =
f.map(Success(_)).recover(x => Failure(x))
val listOfFutures = ...
val listOfFutureTrys = listOfFutures.map(futureToFutureTry(_))
次に、以前と同様にFuture.sequence
を使用して、Future[List[Try[T]]]
を提供します
val futureListOfTrys = Future.sequence(listOfFutureTrys)
次に、フィルタリングします。
val futureListOfSuccesses = futureListOfTrys.map(_.filter(_.isSuccess))
必要に応じて、特定の障害を引き出すこともできます。
val futureListOfFailures = futureListOfTrys.map(_.filter(_.isFailure))
ケビンの答えを試してみましたが、私のバージョンのScala(2.11.5)で不具合が発生しました。バージョン>
implicit class FutureCompanionOps(val f: Future.type) extends AnyVal {
/** Given a list of futures `fs`, returns the future holding the list of Try's of the futures from `fs`.
* The returned future is completed only once all of the futures in `fs` have been completed.
*/
def allAsTrys[T](fItems: /* future items */ List[Future[T]]): Future[List[Try[T]]] = {
val listOfFutureTrys: List[Future[Try[T]]] = fItems.map(futureToFutureTry)
Future.sequence(listOfFutureTrys)
}
def futureToFutureTry[T](f: Future[T]): Future[Try[T]] = {
f.map(Success(_)) .recover({case x => Failure(x)})
}
def allFailedAsTrys[T](fItems: /* future items */ List[Future[T]]): Future[List[Try[T]]] = {
allAsTrys(fItems).map(_.filter(_.isFailure))
}
def allSucceededAsTrys[T](fItems: /* future items */ List[Future[T]]): Future[List[Try[T]]] = {
allAsTrys(fItems).map(_.filter(_.isSuccess))
}
}
// Tests...
// allAsTrys tests
//
test("futureToFutureTry returns Success if no exception") {
val future = Future.futureToFutureTry(Future{"mouse"})
Thread.sleep(0, 100)
val futureValue = future.value
assert(futureValue == Some(Success(Success("mouse"))))
}
test("futureToFutureTry returns Failure if exception thrown") {
val future = Future.futureToFutureTry(Future{throw new IllegalStateException("bad news")})
Thread.sleep(5) // need to sleep a LOT longer to get Exception from failure case... interesting.....
val futureValue = future.value
assertResult(true) {
futureValue match {
case Some(Success(Failure(error: IllegalStateException))) => true
}
}
}
test("Future.allAsTrys returns Nil given Nil list as input") {
val future = Future.allAsTrys(Nil)
assert ( Await.result(future, 100 nanosecond).isEmpty )
}
test("Future.allAsTrys returns successful item even if preceded by failing item") {
val future1 = Future{throw new IllegalStateException("bad news")}
var future2 = Future{"dog"}
val futureListOfTrys = Future.allAsTrys(List(future1,future2))
val listOfTrys = Await.result(futureListOfTrys, 10 milli)
System.out.println("successItem:" + listOfTrys);
assert(listOfTrys(0).failed.get.getMessage.contains("bad news"))
assert(listOfTrys(1) == Success("dog"))
}
test("Future.allAsTrys returns successful item even if followed by failing item") {
var future1 = Future{"dog"}
val future2 = Future{throw new IllegalStateException("bad news")}
val futureListOfTrys = Future.allAsTrys(List(future1,future2))
val listOfTrys = Await.result(futureListOfTrys, 10 milli)
System.out.println("successItem:" + listOfTrys);
assert(listOfTrys(1).failed.get.getMessage.contains("bad news"))
assert(listOfTrys(0) == Success("dog"))
}
test("Future.allFailedAsTrys returns the failed item and only that item") {
var future1 = Future{"dog"}
val future2 = Future{throw new IllegalStateException("bad news")}
val futureListOfTrys = Future.allFailedAsTrys(List(future1,future2))
val listOfTrys = Await.result(futureListOfTrys, 10 milli)
assert(listOfTrys(0).failed.get.getMessage.contains("bad news"))
assert(listOfTrys.size == 1)
}
test("Future.allSucceededAsTrys returns the succeeded item and only that item") {
var future1 = Future{"dog"}
val future2 = Future{throw new IllegalStateException("bad news")}
val futureListOfTrys = Future.allSucceededAsTrys(List(future1,future2))
val listOfTrys = Await.result(futureListOfTrys, 10 milli)
assert(listOfTrys(0) == Success("dog"))
assert(listOfTrys.size == 1)
}
Scala 2.12ではFuture.transform
が改善されており、コードの少ないアンカーに適しています。
val futures = Seq(Future{1},Future{throw new Exception})
// instead of `map` and `recover`, use `transform`
val seq = Future.sequence(futures.map(_.transform(Success(_))))
val successes = seq.map(_.collect{case Success(x)=>x})
successes
//res1: Future[Seq[Int]] = Future(Success(List(1)))
val failures = seq.map(_.collect{case Failure(x)=>x})
failures
//res2: Future[Seq[Throwable]] = Future(Success(List(Java.lang.Exception)))
私はちょうどこの質問に出会い、提供する別のソリューションがあります:
def allSuccessful[A, M[X] <: TraversableOnce[X]](in: M[Future[A]])
(implicit cbf: CanBuildFrom[M[Future[A]], A, M[A]],
executor: ExecutionContext): Future[M[A]] = {
in.foldLeft(Future.successful(cbf(in))) {
(fr, fa) ⇒ (for (r ← fr; a ← fa) yield r += a) fallbackTo fr
} map (_.result())
}
ここでのアイデアは、フォールド内でリストの次の要素が完了するのを待っており(for-comprehension構文を使用)、次の要素が失敗した場合は、既にあるものにフォールバックするだけです。
オプションを使用して将来の結果を簡単にラップし、リストをフラット化できます。
def futureToFutureOption[T](f: Future[T]): Future[Option[T]] =
f.map(Some(_)).recover {
case e => None
}
val listOfFutureOptions = listOfFutures.map(futureToFutureOption(_))
val futureListOfOptions = Future.sequence(listOfFutureOptions)
val futureListOfSuccesses = futureListOfOptions.flatten