Question

我想执行func方法，每个方法调用都具有前一个的结果并返回最终的方法值。

有没有一种方法可以使它变得不那么冗长和动态，以便如果必须执行100次以上，则最终不会有100行？

    val a : Future[String] = for {
      comp1Result <- Future { func(shopRequest) }
      comp2Result <- Future { func(comp1Result) }
      comp3Result <- Future { func(comp2Result) }
      comp4Result <- Future { func(comp3Result) }
      comp5Result <- Future { func(comp4Result) }
      comp6Result <- Future { func(comp5Result) }
      comp7Result <- Future { func(comp6Result) }
      comp8Result <- Future { func(comp7Result) }
      comp9Result <- Future { func(comp8Result) }
      comp10Result <- Future { func(comp9Result) }
      comp11Result <- Future { func(comp10Result) }
      comp12Result <- Future { func(comp11Result) }
      comp13Result <- Future { func(comp12Result) }
      comp14Result <- Future { func(comp13Result) }
      comp15Result <- Future { func(comp14Result) }
      comp16Result <- Future { func(comp15Result) }
      comp17Result <- Future { func(comp16Result) }
    } yield {comp17Result }

Answer 1

您可以创建一个简单的尾部递归方法，以通过Future{ func(result) }重复flatMap链接给定次数：

import scala.concurrent.Future
import scala.concurrent.ExecutionContext.Implicits.global

def func(s: String): String = ???

@scala.annotation.tailrec
def loopFutures(future: Future[String], n: Int): Future[String] = n match {
  case 1 => future
  case _ => loopFutures(future.flatMap(r => Future{ func(r) }), n - 1)
}

例如，使用方法loopFutures来执行for-comprehension：

loopFutures(Future{ func(shopRequest) }, 17)

Answer 2

在Future中执行每个计算没有意义，在一个Future中执行所有计算更为简单。然后可以使用简单的foldLeft操作：

Future((1 to 17).foldLeft(shopRequest) { case (r, _) => func(r) })

如果您确实想每次创建一个Future，则它看起来像这样：

(1 to 17).foldLeft(Future.successful(shopRequest)) {
  case (r, _) => r.flatMap(x => Future(func(x)))
}

用于理解链期货和结果的Scala Future

2 个答案: