我每次都需要绕过一个问题。我无法使用for推导式对包含在Future中的内容进行映射。
例如：
import scala.concurrent.ExecutionContext.Implicits.global
import scala.concurrent.Future
val f = Future( List("A", "B", "C") )
for {
list <- f
e <- list
} yield (e -> 1)
这给了我一个错误：
error: type mismatch;
found : List[(String, Int)]
required: scala.concurrent.Future[?]
e <- list
^
但是如果我这样做，它可以正常工作：
f.map( _.map( (_ -> 1) ) )
如果我不能使用for推导来做这件事，那么在我的另一个例子中它能够工作的原因是我没有使用flatmap吗？我正在使用Scala 2.10.0。
当您在单个for循环中使用多个生成器时，您正在展开结果类型。也就是说，您不会得到一个List[List[T]]，而是得到一个List[T]：
scala> val list = List(1, 2, 3)
list: List[Int] = List(1, 2, 3)
scala> for (a <- list) yield for (b <- list) yield (a, b)
res0: List[List[(Int, Int)]] = List(List((1,1), (1,2), (1,3)), List((2,1
), (2,2), (2,3)), List((3,1), (3,2), (3,3)))
scala> for (a <- list; b <- list) yield (a, b)
res1: List[(Int, Int)] = List((1,1), (1,2), (1,3), (2,1), (2,2), (2,3),
(3,1), (3,2), (3,3))
Future[List[T]] ？它不能是一个 Future[T]，因为你将会得到多个 T，而一个 Future（与 List 不同）只能存储其中一个。顺便说一下，Option 也存在同样的问题：scala> for (a <- Some(3); b <- list) yield (a, b)
<console>:9: error: type mismatch;
found : List[(Int, Int)]
required: Option[?]
for (a <- Some(3); b <- list) yield (a, b)
^
scala> for {
| list <- f
| } yield for {
| e <- list
| } yield (e -> 1)
res3: scala.concurrent.Future[List[(String, Int)]] = scala.concurrent.im
pl.Promise$DefaultPromise@4f498585
map 版本还是 for yield for 嵌套版本？ - Mortimer嗯，我想我明白了。我需要将其包装在Future中，因为for推导式会添加flatmap。
这样做是有效的：
for {
list <- f
e <- Future( list )
} yield (e -> 1)
当我添加上述内容时，我还没有看到任何答案。但是，可以在一个for-comprehension内完成工作。不确定是否值得使用Future来降低开销（通过使用successful应该没有开销）。
for {
list1 <- f
list2 <- Future.successful( list1.map( _ -> 1) )
list3 <- Future.successful( list2.filter( _._2 == 1 ) )
} yield list3
半年后的附加说明。
解决此问题的另一种方法是在拥有与初始映射返回类型不同的其他类型时，直接使用赋值=而不是<-。
使用赋值时，该行不会被平铺。您现在可以自由地进行显式映射（或其他转换），以返回不同类型。
如果您有几个转换步骤，其中一个步骤的返回类型与其他步骤不同，但仍希望使用for-comprehension语法，因为它使您的代码更易读，则此方法非常有用。
import scala.concurrent.ExecutionContext.Implicits.global
import scala.concurrent.Future
val f = Future( List("A", "B", "C") )
def longRunning( l:List[(String, Int)] ) = Future.successful( l.map(_._2) )
for {
list <- f
e = list.map( _ -> 1 )
s <- longRunning( e )
} yield s
你原始的版本无法编译，因为List和Future是不同的单子。为了解释为什么这是一个问题，请考虑它的展开形式：
f.flatMap(list => list.map(e => e -> 1))
list.map(_ -> 1)是一个由(String, Int)对组成的列表，因此我们需要将其作为参数传递给flatMap函数，该函数将字符串列表映射到这些对组成的列表。但我们需要将字符串列表映射到某种类型的Future。因此，这段代码无法编译。f.flatMap(list => Future(list).map(e => e -> 1))
Future中提取出值，将其放回到一个Future中，并映射结果。因此，我们最终得到的是Future[(List[String], Int)]类型的东西，而我们想要的是Future[List[(String, Int)]]。
你所做的是一种双重映射操作，涉及两个（不同的）嵌套单子，这不是for理解式能帮助你解决的问题。幸运的是，f.map(_.map(_ -> 1))正好做到了你想要的，并且清晰简洁。我认为这个表格比串行映射或串行产量更易读：
for (vs <- future(data);
xs = for (x <- vs) yield g(x)
) yield xs
以元组映射为代价：
f.map((_, xs)).map(_._2)
更准确地说：
f.map((vs: List[Int]) => (vs, for (x <- vs) yield g(x))).map(_._2)