Question

根据Scala Language Specification（§6.19），“枚举器序列始终以生成器开头”。为什么呢？

我有时会发现这个限制在使用for - 对monad的理解时会成为障碍，因为这意味着你不能做这样的事情：

def getFooValue(): Future[Int] = {
  for {
    manager = Manager.getManager() // could throw an exception
    foo <- manager.makeFoo() // method call returns a Future
    value = foo.getValue()
  } yield value
}

事实上，scalac拒绝此错误消息'<-' expected but '=' found。

如果这是Scala中的有效语法，一个优点是Manager.getManager()抛出的任何异常都会被Future理解中使用的for monad捕获，并且会导致它产生一个失败的Future，这就是我想要的。将呼叫转移到Manager.getManager()之外的for的解决方法没有这个优势：

def getFooValue(): Future[Int] = {
  val manager = Manager.getManager()

  for {
    foo <- manager.makeFoo()
    value = foo.getValue()
  } yield value
}

在这种情况下，foo.getValue()抛出的异常将产生失败的Future（这就是我想要的），但Manager.getManager()抛出的异常将被抛回调用者getFooValue()（这不是我想要的）。处理异常的其他可能方式更详细。

我发现这个限制尤其令人费解，因为在Haskell的其他类似do表示法中，并不要求do块应以包含<-的语句开头。任何人都可以解释Scala和Haskell之间的区别吗？

以下是一个完整的工作示例，展示Future中for monad如何捕获异常 - 理解：

import scala.concurrent._
import scala.concurrent.duration._
import scala.concurrent.ExecutionContext.Implicits.global
import scala.util.{Try, Success, Failure}

class Foo(val value: Int) {
  def getValue(crash: Boolean): Int = {
    if (crash) {
      throw new Exception("failed to get value")
    } else {
      value
    }
  }
}

class Manager {
  def makeFoo(crash: Boolean): Future[Foo] = {
    if (crash) {
      throw new Exception("failed to make Foo")
    } else {
      Future(new Foo(10))
    }
  }
}

object Manager {
  def getManager(crash: Boolean): Manager = {
    if (crash) {
      throw new Exception("failed to get manager")
    } else {
      new Manager()
    }
  }
}

object Main extends App {

  def getFooValue(crashGetManager: Boolean,
                  crashMakeFoo: Boolean,
                  crashGetValue: Boolean): Future[Int] = {
    for {
      manager <- Future(Manager.getManager(crashGetManager))
      foo <- manager.makeFoo(crashMakeFoo)
      value = foo.getValue(crashGetValue)
    } yield value
  }

  def waitForValue(future: Future[Int]): Unit = {
    val result = Try(Await.result(future, Duration("10 seconds")))
    result match {
      case Success(value) => println(s"Got value: $value")
      case Failure(e) => println(s"Got error: $e")
    }
  }

  val future1 = getFooValue(false, false, false)
  waitForValue(future1)
  val future2 = getFooValue(true, false, false)
  waitForValue(future2)
  val future3 = getFooValue(false, true, false)
  waitForValue(future3)
  val future4 = getFooValue(false, false, true)
  waitForValue(future4)
}

这是输出：

Got value: 10
Got error: java.lang.Exception: failed to get manager
Got error: java.lang.Exception: failed to make Foo
Got error: java.lang.Exception: failed to get value

这是一个简单的例子，但我正在开发一个项目，其中我们有许多依赖于这种行为的非平凡代码。据我了解，这是使用Future（或Try）作为monad的主要优势之一。我觉得奇怪的是我必须写

manager <- Future(Manager.getManager(crashGetManager))

而不是

manager = Manager.getManager(crashGetManager)

（编辑反映@ RexKerr指出monad正在做捕捉异常的工作。）

Answer 1

for理解不会捕获异常。 Try有，并且它有适当的方法来参与for-comprehension，所以你可以

for {
  manager <- Try { Manager.getManager() }
  ...
}

但是，除非您手动或隐式地切换容器类型（例如将Try转换为Try），否则它会一直向下List。

所以我不确定你的前提是否合适。你在for-comprehension中所做的任何任务都可以提前完成。

（另外，为了得到那个确切的值，在for comprehension中做一个赋值是没有意义的。只需在yield块中进行计算。）

（另外，只是为了说明多种类型可以在for理解中发挥作用，因此对于如何根据以后的类型包装早期作业，没有一个非常明显的正确答案：

// List and Option, via implicit conversion
for {i <- List(1,2,3); j <- Option(i).filter(_ <2)} yield j

// Custom compatible types with map/flatMap
// Use :paste in the REPL to define A and B together
class A[X] { def flatMap[Y](f: X => B[Y]): A[Y] = new A[Y] }
class B[X](x: X) { def map[Y](f: X => Y): B[Y] = new B(f(x)) }
for{ i <- (new A[Int]); j <- (new B(i)) } yield j.toString

即使您采用第一种类型，您仍然会遇到是否存在唯一的“绑定”（换行方式）以及是否双重包装已经是正确类型的问题。所有这些事情都可能有规则，但是理解力已经足够难以学习了，不是吗？）

Answer 2

Haskell将等效的for { manager = Manager.getManager(); ... }转换为等效的lazy val manager = Manager.getManager(); for { ... }。这似乎有效：

scala> lazy val x: Int = throw new Exception("")
x: Int = <lazy>

scala> for { y <- Future(x + 1) } yield y
res8: scala.concurrent.Future[Int] = scala.concurrent.impl.Promise$DefaultPromise@fedb05d

scala> Try(Await.result(res1, Duration("10 seconds")))
res9: scala.util.Try[Int] = Failure(java.lang.Exception: )

Answer 3

我认为无法做到这一点的原因是因为for循环是 flatMap 和 map 方法的语法糖（除非你使用的是条件）在for循环中，在这种情况下，它使用方法 withFilter 进行了解雇。当您存储在不可变变量中时，您无法使用这些方法。这就是你可以使用Rex Kerr指出的尝试的原因。在这种情况下，您应该能够使用 map 和 flatMap 方法。

为什么Scala for-comprehension必须从生成器开始？

3 个答案: