问题描述
我有一些副作用函数，
def f（）：Future [Int] = {
val n = Random.nextInt（）
println（sGenerated $ n）
Future（n）
}
，我想重复执行它直到谓词返回true。
def成功（n：Int）：布尔= n％2 == 0
我的计划是建立 Stream 结果
val s = Stream.fill（10）（f ）
然后使用 Future.find 来获得满足谓词的第一个结果。
Future.find（s）（成功）map println
问题在于 Future.find 并行运行所有期货，希望它依次执行期货，直到谓词返回true。
scala> Future.find（s）（成功）map println
已生成-237492703
已生成-935476293
已生成-1155819556
已生成-375506595
生成-912504491
生成-1307379057
生成-1522265611
生成1163971151
生成-516152076
res8：scala.concurrent.Future [Unit] = scala.concurrent.impl.Promise$DefaultPromise@37d28f02
一些（-1155819556）
问题是如何顺序执行期货流，直到谓词返回真正？在标准库或第三方库中是否有适合的函数？
不使用流，我建议使用另一种方法。使用未来的筛选器并以递归方式恢复：
def findFirst [A]（futureGen：=> Future [A]，谓词： A => Boolean）：Future [A] = {
futureGen.filter（predicate）.recoverWith {case _ => findFirst（futureGen，predicate）}
}
findFirst（f，success）
这将一个接一个地调用期货，直到'成功'将返回true。
I have some side-effectful function,
def f(): Future[Int] = {
val n = Random.nextInt()
println(s"Generated $n")
Future(n)
}
and I want to execute it repeatedly until predicate returns true.
def success(n: Int): Boolean = n % 2 == 0
My plan is to build Stream of results
val s = Stream.fill(10)(f)
and then use Future.find to get the first result that satisfies predicate.
Future.find(s)(success) map println
The problem is that Future.find runs all the futures in parallel and I want it to execute futures sequentially one after the other until predicate returns true.
scala> Future.find(s)(success) map println Generated -237492703 Generated -935476293 Generated -1155819556 Generated -375506595 Generated -912504491 Generated -1307379057 Generated -1522265611 Generated 1163971151 Generated -516152076 res8: scala.concurrent.Future[Unit] = scala.concurrent.impl.Promise$DefaultPromise@37d28f02 Some(-1155819556)
The question is how to execute stream of futures sequentially until predicate returns true? Are there any suitable functions in standard or third-party library?
Instead of using Stream I suggest using another approach. Using The Future's filter and recoverWith recursively:
def findFirst[A](futureGen: => Future[A], predicate: A => Boolean): Future[A] = {
futureGen.filter(predicate).recoverWith { case _ => findFirst(futureGen, predicate) }
}
findFirst(f, success)
This will call the Futures one after the other until 'success' will return true.
这篇关于有顺序的Future.find吗？的文章就介绍到这了，希望我们推荐的答案对大家有所帮助，也希望大家多多支持！