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

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 block 应以包含 <- 的语句开头.谁能解释一下 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)

(经过编辑以反射(reflect)@RexKerr 的观点，即 monad 正在执行捕获异常的工作。)

Answer 1

for 理解不捕获异常。 Try 确实如此，它有适当的方法参与 for-comprehensions，所以你可以

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

但是它一直期待 Try 除非你手动或隐式地有一种方法来切换容器类型(例如，将 Try 转换为 List )。

所以我不确定你的前提是否正确。您在 for-comprehension 中所做的任何作业都可以尽早完成。

(此外，在 for comprehension 中进行赋值只是为了产生准确的值是没有意义的。只需在 yield block 中进行计算即可。)

(此外，只是为了说明多种类型可以在 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

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