Question

如何使用Scala continuation实现C＃yield return？我希望能够以相同的风格编写Scala Iterator。在this Scala news post的评论中有一个刺，但它不起作用（尝试使用Scala 2.8.0测试版）。 related question中的答案表明这是可能的，但是虽然我已经玩了一段时间的分隔延续，但我似乎无法完全理解如何做到这一点。

Answer 1

在我们介绍延续之前，我们需要构建一些基础架构。以下是对Iteration个对象进行操作的trampoline。迭代是一种计算，可以Yield一个新值，也可以是Done。

sealed trait Iteration[+R]
case class Yield[+R](result: R, next: () => Iteration[R]) extends Iteration[R]
case object Done extends Iteration[Nothing]

def trampoline[R](body: => Iteration[R]): Iterator[R] = {
  def loop(thunk: () => Iteration[R]): Stream[R] = {
    thunk.apply match {
      case Yield(result, next) => Stream.cons(result, loop(next))
      case Done => Stream.empty
    }
  }
  loop(() => body).iterator
}

蹦床使用内部循环将Iteration个对象的序列转换为Stream。然后，我们通过在生成的流对象上调用Iterator来获取iterator。使用Stream我们的评价是懒惰的;在需要之前，我们不会评估下一次迭代。

蹦床可用于直接构建迭代器。

val itr1 = trampoline {
  Yield(1, () => Yield(2, () => Yield(3, () => Done)))
}

for (i <- itr1) { println(i) }

编写这个非常糟糕，所以让我们使用分隔的延续来自动创建Iteration个对象。

我们使用shift和reset运算符将计算分解为Iteration s，然后使用trampoline将Iteration转换为Iterator。

import scala.continuations._
import scala.continuations.ControlContext.{shift,reset}

def iterator[R](body: => Unit @cps[Iteration[R],Iteration[R]]): Iterator[R] =
  trampoline {
    reset[Iteration[R],Iteration[R]] { body ; Done }
  }

def yld[R](result: R): Unit @cps[Iteration[R],Iteration[R]] =
  shift((k: Unit => Iteration[R]) => Yield(result, () => k(())))

现在我们可以重写我们的例子。

val itr2 = iterator[Int] {
  yld(1)
  yld(2)
  yld(3)
}

for (i <- itr2) { println(i) }

好多了！

现在，来自yield def power(number: Int, exponent: Int): Iterator[Int] = iterator[Int] { def loop(result: Int, counter: Int): Unit @cps[Iteration[Int],Iteration[Int]] = { if (counter < exponent) { yld(result) loop(result * number, counter + 1) } } loop(number, 0) } for (i <- power(2, 8)) { println(i) }的示例显示了一些更高级的用法。这些类型可能有点难以习惯，但一切正常。

{{1}}

Answer 2

经过几个小时的游戏后，我设法找到了一种方法。我认为这比我到目前为止看到的所有其他解决方案更简单，尽管我后来非常感谢Rich和Miles'解决方案。

def loopWhile(cond: =>Boolean)(body: =>(Unit @suspendable)): Unit @suspendable = {
  if (cond) {
    body
    loopWhile(cond)(body)
  }
}

  class Gen {
    var prodCont: Unit => Unit = { x: Unit => prod }
    var nextVal = 0
    def yld(i: Int) = shift { k: (Unit => Unit) => nextVal = i; prodCont = k }
    def next = { prodCont(); nextVal }
    def prod = {
      reset {
        // following is generator logic; can be refactored out generically
        var i = 0
        i += 1
        yld(i)
        i += 1
        yld(i)
        // scala continuations plugin can't handle while loops, so need own construct
        loopWhile (true) {
          i += 1
          yld(i)
        }
      }
    }
  }
  val it = new Gen
  println(it.next)
  println(it.next)
  println(it.next)

使用Scala continuation实现yield（yield return）

2 个答案: