理解是否有“flatYield”之类的东西？

Question

我有一些类似的代码

//all data have different types
val data1Future = loadData1(params)
val data2Future = loadData2(params)
val data3Future = loadData3(params)

def saveResult(rez): Future[_] = ???

data1Future.flatMap { data1 =>
  data2Future.flatMap { data2 =>
    data3Future.flatMap { data3 =>
      //do some computation
      //several rows and several vals
      val rez = ???
      saveResult(rez)
   }
  }
}

但这有点难看 :) 不幸的是，我不能用于理解，因为我需要像“flatYield”这样的东西

for {
  data1 <- data1Future
  data1 <- data1Future
  data1 <- data1Future
} flatYield {
  //do some computation
  //several rows and several vals
  val rez = data1 + data2 + data3
  saveResult(rez)
}

你知道像“用于理解”这样优雅的模式，但在链的末端使用 flatMap 而不是 map？

Answer 1

你可以这样做：

for {
  data1 <- data1Future
  data2 <- data2Future
  data3 <- data3Future
  rez = {
    //do some computation
    //several rows and several vals
    data1 + data2 + data3
  }
  r <- saveResult(rez)
} yield r

这转化为

data1Future.flatMap { data1 =>
  data2Future.flatMap { data2 =>
    data3Future.flatMap { data3 =>
      val rez = {
        //do some computation
        //several rows and several vals
        data1 + data2 + data3
      }
      saveResult(rez).map(r => r)
    }
  }
}

与您的代码同构。

Answer 2

看起来你只是想在你的理解中再写一行，所有“其他计算”都应该放在另一个函数中以保持干净：

for {
  data1 <- data1Future
  data2 <- data2Future
  data3 <- data3Future
  rez <- otherFunction(data1, data2, data3)
} yield rez 

def otherFunction(d1: ?, d2: ?, d3: ?): Future[?] = {
  //do some computation
  //several rows and several vals
}

或者你可以使用这样的东西：

(for {
  data1 <- data1Future
  data2 <- data2Future
  data3 <- data3Future
} yield {
  (data1, data2, data3)
}) flatMap { case (data1, data2, data3) =>
  //do some computation
  //several rows and several vals
  saveResult(rez)
}

Answer 3

使用 for 理解（如您声明的目标）相当于在一系列 flatMap 操作中定义未来，将等待每个未来的结果，然后再进行下一个。由于您的未来不依赖于彼此，您可以在不等待前一个完成的情况下启动它们 - 这就是您在初始示例中所做的。

同时启动它们并按​​顺序存储期货使用 Future.sequence 将期货集合变成一个单一的未来，直到它们全部完成（或其中任何一个失败）才会完成。然后在未来完成时保存您的结果。

val data1Future = loadData1(params) //type = Future[foo]
val data2Future = loadData2(params)
val data3Future = loadData3(params)

val listOfFutures = List(data1Future,data2Future,data3Future) //type = List[Future[foo]]

val futureOfList = Future.sequence(listOfFutures)  //type = Future[List[foo]]

futureOfList.onComplete( list => saveResult(list.reduce(_ + _))