如何用 for-comprehension 表达以下嵌套的期货

Question

我的问题：是否可以用 for-comprehension 来简化这个嵌套表达式？

run(dbAction).flatMap(insertedJobs => {
  Future.sequence(insertedJobs.map { job =>
    recordingBean.findStreamsForInterval(job.mediaSource, job.begin, job.end) map { stream =>
      if (stream.nonEmpty) {
        recordingBean.findRecordingLocationsForInterval(stream.head.stream, job.begin, job.end).map(recordingLocations =>
          recordingLocations.map(_.size.getOrElse(0L)).sum).flatMap { expectedSizeInBytes =>
          updateSize(job.id.get, expectedSizeInBytes)
        }
        job
      } else {
        job
      }
    }
  })
})

Answer 1

因为推导很强大，但它们并不是你认为的万能的嵌套杀手。

for-comprehension 非常有用，除非您不将 SeqLike monads 与 non-SeqLike monads 混合使用。但是一旦你混合它们，你就回到了嵌套世界。而且它会比以前更糟，因为理解隐藏了细节。

让我们举几个例子，

val listOfListOfInt = List(List(1, 2, 3), List(2, 3, 4))

val listOfInt = for {
  loi <- listOfListOfInt
  i <- loi
} yield i + 4

// This will work just fine
// listOfInt: List[Int] = List(5, 6, 7, 6, 7, 8) 

现在让我们将List 与Future 混合，

val futureOfList = Future({ List(1, 2, 3) })

val iWillNotCompile = for {
  l <- futureOfList
  i <- list
} yield i + 4

// the above is equivalent to writing,
val iWillNotCompile = futureOfList.flatMap(l => l.map(i => i + 4))

// would have been following but does not make sense
// `Success(5, 6, 7)`

上面的代码不会编译，实际上它不应该编译。因为Future 是non-SeqLike monad。我的意思是，如果上面的代码有效，那将是 Success(5, 6, 7)，这没有意义。

同样，下面的代码也不起作用

val listOfFuture = List(Future({ 1 }), Future({ 2 }), Future({ 3 }) )

val iWillNotCompile = for {
  f <- listOfFuture
  i <- f
} yield i + 4

// this is equivalent to
val iWillNotCompile = listOfFuture.flatMap(f => f.map(i => i + 4)

// should have been following and it makes sense
// List(Success(5), Success(6), Success(7))

这个案例与前一个案例有很大不同，因为它符合常识，但仍然无法正常工作。原因是SeqLike-Monads 和Futures 对flatMap 和flatten 和map 的实现非常不同。

所以...如果正在处理List、Future、Option、Try 等的混合，请远离for-comprehension。尝试以更聪明的方式编写代码。