Question

我正在为博士研究编写代码并开始使用Scala。我经常要做文字处理。我已经习惯了Python，其'yield'语句对于在大型（通常是不规则结构化的）文本文件上实现复杂的迭代器非常有用。类似的结构存在于其他语言（例如C＃）中，这是有充分理由的。

是的我知道之前有过这样的帖子。但它们看起来像是黑客攻击（或至少解释得很糟糕）的解决方案，这些解决方案并不能很好地运作并且通常具有不明确的局限性。我想编写类似这样的代码：

import generator._

def yield_values(file:String) = {
  generate {
    for (x <- Source.fromFile(file).getLines()) {
      # Scala is already using the 'yield' keyword.
      give("something")
      for (field <- ":".r.split(x)) {
        if (field contains "/") {
          for (subfield <- "/".r.split(field)) { give(subfield) }
        } else {
          // Scala has no 'continue'.  IMO that should be considered
          // a bug in Scala.
          // Preferred: if (field.startsWith("#")) continue
          // Actual: Need to indent all following code
          if (!field.startsWith("#")) {
            val some_calculation = { ... do some more stuff here ... }
            if (some_calculation && field.startsWith("r")) {
              give("r")
              give(field.slice(1))
            } else {
              // Typically there will be a good deal more code here to handle different cases
              give(field)
            }
          }
        }
      }
    }
  }
}

我想看看实现generate（）和give（）的代码。 BTW give（）应命名为yield（），但Scala已经使用了该关键字。

我认为，由于我不理解的原因，Scala延续可能不适用于for语句。如果是这样，generate（）应该提供一个与for语句尽可能接近的等效函数，因为带有yield的迭代器代码几乎不可避免地位于for循环中。

请，我不希望得到以下任何答案：

'收益'很糟糕，延续更好。（是的，一般来说你可以用延续来做更多的事情。但是它们很难理解，99％的时候迭代器都是你想要的或者需要的。如果Scala提供了很多强大的工具但它们太难用了在实践中，语言不会成功。）
这是重复的。（请参阅上面的评论。）
您应该使用流，延续，递归等来重写您的代码。（请参阅＃1。我还将添加，从技术上讲，您也不需要循环。就此而言，从技术上讲，您可以完全做到一切你需要使用SKI combinators。）
你的功能太长了。将其分解成更小的部分，您将不需要“收益”。无论如何，你必须在生产代码中这样做。（首先，“你不需要'收益''在任何情况下都是值得怀疑的。其次，这不是生产代码。第三，对于像这样的文本处理，经常将功能分解成更小的部分 - 特别是当语言强制你这样做是因为它缺乏有用的结构 - 只使代码更难才能理解。）
使用传入的函数重写代码。（从技术上讲，是的，你可以这样做。但结果不再是迭代器，链接迭代器比链接函数更好。一般来说，语言不应该强迫我以不自然的方式写作 - 当然，Scala创作者一般都相信这一点，因为它们提供了大量的语法糖。）
用这个，那个或其他方式重写你的代码，或者我想到的其他一些很酷的，令人敬畏的方式。

Answer 1

你的问题的前提似乎是你想要Python的收益率，并且你不希望任何其他合理的建议在Scala中以不同的方式做同样的事情。如果这是真的，那对你来说很重要，为什么不使用Python呢？这是一个很好的语言。除非你的博士学位是在计算机科学，使用Scala是你论文的重要部分，如果你已经熟悉Python并且非常喜欢它的一些功能和设计选择，那么为什么不使用它呢？

无论如何，如果你真的想学习如何在Scala中解决你的问题，事实证明，对于你拥有的代码，分隔的延续是过度的。您只需要flatMapped迭代器。

这是你如何做到的。

// You want to write
for (x <- xs) { /* complex yield in here */ }
// Instead you write
xs.iterator.flatMap { /* Produce iterators in here */ }

// You want to write
yield(a)
yield(b)
// Instead you write
Iterator(a,b)

// You want to write
yield(a)
/* complex set of yields in here */
// Instead you write
Iterator(a) ++ /* produce complex iterator here */

就是这样！你的所有案件都可以减少到这三个案件中的一个。

在您的情况下，您的示例看起来像

Source.fromFile(file).getLines().flatMap(x =>
  Iterator("something") ++
  ":".r.split(x).iterator.flatMap(field =>
    if (field contains "/") "/".r.split(field).iterator
    else {
      if (!field.startsWith("#")) {
        /* vals, whatever */
        if (some_calculation && field.startsWith("r")) Iterator("r",field.slice(1))
        else Iterator(field)
      }
      else Iterator.empty
    }
  )
)

P.S。 Scala 确实继续;它是这样完成的（通过抛出无堆栈（轻量级）异常实现）：

import scala.util.control.Breaks._
for (blah) { breakable { ... break ... } }

但是这不会得到你想要的东西，因为Scala没有你想要的产量。

Answer 2

'收益'很糟糕，延续更好

实际上，Python的yield 是的延续。

什么是延续？延续是将当前执行点保存为其所有状态，以便稍后可以继续。这正是Python的yield，以及它的实现方式。

然而，据我所知，Python的延续不是分隔。我对此并不了解 - 实际上我可能错了。我也不知道这可能是什么意思。

Scala的延续在运行时不起作用 - 事实上，有一个Java的延续库，它通过在运行时对字节码执行操作来工作，这不受Scala延续的约束。

Scala的延续完全在编译时完成，这需要相当多的工作。它还要求编译器准备“继续”的代码。

这就是为什么理解不起作用的原因。这样的陈述：

for { x <- xs } proc(x)

如果翻译成

xs.foreach(x => proc(x))

其中foreach是xs班级的方法。遗憾的是，xs类已被编译很长时间，因此无法修改为支持延续。作为旁注，这也是Scala没有continue的原因。

除此之外，是的，这是一个重复的问题，是的，您应该找到一种不同的方式来编写代码。

Answer 3

下面的实现提供了类似Python的生成器。

请注意，下面的代码中有一个名为_yield的函数，因为yield已经是Scala中的关键字，顺便说一句，它与yield没有任何关系从Python中了解。

import scala.annotation.tailrec
import scala.collection.immutable.Stream
import scala.util.continuations._

object Generators {
  sealed trait Trampoline[+T]

  case object Done extends Trampoline[Nothing]
  case class Continue[T](result: T, next: Unit => Trampoline[T]) extends Trampoline[T]

  class Generator[T](var cont: Unit => Trampoline[T]) extends Iterator[T] {
    def next: T = {
      cont() match {
        case Continue(r, nextCont) => cont = nextCont; r
        case _ => sys.error("Generator exhausted")
      }
    }

    def hasNext = cont() != Done
  }

  type Gen[T] = cps[Trampoline[T]]

  def generator[T](body: => Unit @Gen[T]): Generator[T] = {
    new Generator((Unit) => reset { body; Done })
  }

  def _yield[T](t: T): Unit @Gen[T] =
    shift { (cont: Unit => Trampoline[T]) => Continue(t, cont) }
}


object TestCase {
  import Generators._

  def sectors = generator {
    def tailrec(seq: Seq[String]): Unit @Gen[String] = {
      if (!seq.isEmpty) {
        _yield(seq.head)
        tailrec(seq.tail)
      }
    }

    val list: Seq[String] = List("Financials", "Materials", "Technology", "Utilities")
    tailrec(list)
  }

  def main(args: Array[String]): Unit = {
    for (s <- sectors) { println(s) }
  }
}

它运行良好，包括for循环的典型用法。

警告：我们需要记住Python和Scala在实现continuation方面有所不同。下面我们看看如何在Python中使用生成器，并与我们在Scala中使用它们的方式进行比较。然后，我们将在Scala中看到为什么需要这样。

如果你习惯用Python编写代码，你可能会使用这样的生成器：

// This is Scala code that does not compile :(
// This code naively tries to mimic the way generators are used in Python

def myGenerator = generator {
  val list: Seq[String] = List("Financials", "Materials", "Technology", "Utilities")
  list foreach {s => _yield(s)}
}

上面的代码无法编译。跳过所有复杂的理论方面，解释是：它无法编译，因为“for循环的类型”与作为延续的一部分所涉及的类型不匹配。我担心这个解释完全失败了。让我再试一次：

如果你编写了如下所示的代码，它就可以正常编译：

def myGenerator = generator {
  _yield("Financials")
  _yield("Materials")
  _yield("Technology")
  _yield("Utilities")
}

此代码编译是因为生成器可以按yield s的顺序分解，在这种情况下，yield匹配延续中涉及的类型。更准确地说，代码可以分解为链接块，其中每个块以yield结束。仅仅为了澄清，我们可以认为yield s的序列可以这样表达：

{ some code here; _yield("Financials")
    { some other code here; _yield("Materials")
        { eventually even some more code here; _yield("Technology")
            { ok, fine, youve got the idea, right?; _yield("Utilities") }}}}

同样，在没有深入复杂理论的情况下，重点是，在yield之后，您需要提供以yield结尾的另一个块，否则关闭链。这就是我们在上面的伪代码中所做的事情：在yield后我们打开另一个块，而另一个块又以yield结尾，后跟另一个yield，后者又以另一个结束yield，等等。显然这件事必须在某个时候结束。然后我们唯一允许做的就是关闭整个链条。

行。但是......我们如何yield多条信息？答案有点模糊，但在你知道答案后很有意义：我们需要使用尾递归，并且块的最后一个语句必须是yield。

  def myGenerator = generator {
    def tailrec(seq: Seq[String]): Unit @Gen[String] = {
      if (!seq.isEmpty) {
        _yield(seq.head)
        tailrec(seq.tail)
      }
    }

    val list = List("Financials", "Materials", "Technology", "Utilities")
    tailrec(list)
  }

让我们分析一下这里发生了什么：

我们的生成器函数myGenerator包含一些获取生成信息的逻辑。在这个例子中，我们只使用一系列字符串。
我们的生成器函数myGenerator调用一个递归函数，该函数负责yield从我们的字符串序列中获取的多条信息。
递归函数必须在使用前声明，否则编译器崩溃。
递归函数tailrec提供了我们需要的尾递归。

这里的经验法则很简单：用递归函数替换for循环，如上所示。

请注意，为了澄清，tailrec只是我们找到的一个方便的名称。特别是，tailrec不需要是我们的生成器函数的最后一个语句;不必要。唯一的限制是你必须提供一系列与yield类型匹配的块，如下所示：

  def myGenerator = generator {

    def tailrec(seq: Seq[String]): Unit @Gen[String] = {
      if (!seq.isEmpty) {
        _yield(seq.head)
        tailrec(seq.tail)
      }
    }

    _yield("Before the first call")
    _yield("OK... not yet...")
    _yield("Ready... steady... go")

    val list = List("Financials", "Materials", "Technology", "Utilities")
    tailrec(list)

    _yield("done")
    _yield("long life and prosperity")
  }

更进一步，您必须想象真实生活应用程序的外观，特别是如果您使用多个生成器。如果您找到一种方法来围绕单个模式标准化您的生成器，这将证明在大多数情况下都很方便，那将是一个好主意。

我们来看看下面的例子。我们有三个生成器：sectors，industries和companies。为简洁起见，仅完全显示sectors。该生成器采用tailrec函数，如上所述。这里的技巧是其他生成器也使用相同的tailrec函数。我们所要做的就是提供不同的body功能。

type GenP = (NodeSeq, NodeSeq, NodeSeq)
type GenR = immutable.Map[String, String]

def tailrec(p: GenP)(body: GenP => GenR): Unit @Gen[GenR] = {
  val (stats, rows, header)  = p
  if (!stats.isEmpty && !rows.isEmpty) {
    val heads: GenP = (stats.head, rows.head, header)
    val tails: GenP = (stats.tail, rows.tail, header)
    _yield(body(heads))
    // tail recursion
    tailrec(tails)(body)
  }
}

def sectors = generator[GenR] {
  def body(p: GenP): GenR = {
      // unpack arguments
      val stat, row, header = p
      // obtain name and url
      val name = (row \ "a").text
      val url  = (row \ "a" \ "@href").text
      // create map and populate fields: name and url
      var m = new scala.collection.mutable.HashMap[String, String]
      m.put("name", name)
      m.put("url",  url)
      // populate other fields
      (header, stat).zipped.foreach { (k, v) => m.put(k.text, v.text) }
      // returns a map
      m
  }

  val root  : scala.xml.NodeSeq = cache.loadHTML5(urlSectors) // obtain entire page
  val header: scala.xml.NodeSeq = ... // code is omitted
  val stats : scala.xml.NodeSeq = ... // code is omitted
  val rows  : scala.xml.NodeSeq = ... // code is omitted
  // tail recursion
  tailrec((stats, rows, header))(body)
} 

def industries(sector: String) = generator[GenR] {
  def body(p: GenP): GenR = {
      //++ similar to 'body' demonstrated in "sectors"
      // returns a map
      m
  }

  //++ obtain NodeSeq variables, like demonstrated in "sectors" 
  // tail recursion
  tailrec((stats, rows, header))(body)
} 

def companies(sector: String) = generator[GenR] {
  def body(p: GenP): GenR = {
      //++ similar to 'body' demonstrated in "sectors"
      // returns a map
      m
  }

  //++ obtain NodeSeq variables, like demonstrated in "sectors" 
  // tail recursion
  tailrec((stats, rows, header))(body)
}

致Rich Dougherty和huynhjl的信用请参阅此SO帖子：Implementing yield (yield return) using Scala continuations *
向Miles Sabin致信，将上面的一些代码放在一起 http://github.com/milessabin/scala-cont-jvm-coro-talk/blob/master/src/continuations/Generators.scala

在Scala中实现'yield'的首选方法是什么？

3 个答案: