Scala等同于Python生成器？

Question

是否可以在Scala中实现与Pythonyield语句等效的功能，在该语句中它记住使用该函数的局部状态，并在每次调用该函数时“产生”下一个值？

我希望有类似这样的东西可以将递归函数转换为迭代器。有点像这样：

# this is python
def foo(i):
  yield i
  if i > 0:
    for j in foo(i - 1):
      yield j

for i in foo(5):
  print i

除此以外，foo可能会更复杂并通过一些非循环对象图重复出现。

附加编辑： 让我添加一个更复杂的示例（但仍然很简单）：我可以编写一个简单的递归函数，以进行打印：

// this is Scala
def printClass(clazz:Class[_], indent:String=""): Unit = {
  clazz match {
    case null =>
    case _ =>
      println(indent + clazz)
      printClass(clazz.getSuperclass, indent + "  ")
      for (c <- clazz.getInterfaces) {
        printClass(c, indent + "  ")
      }
  }
}

理想情况下，我希望拥有一个可以轻松更改一些语句并将其用作迭代器的库：

// this is not Scala
def yieldClass(clazz:Class[_]): Iterator[Class[_]] = {
  clazz match {
    case null =>
    case _ =>
      sudoYield clazz
      for (c <- yieldClass(clazz.getSuperclass)) sudoYield c
      for (c <- clazz.getInterfaces; d <- yieldClasss(c)) sudoYield d
  }
}

似乎延续允许这样做，但我只是不理解这个shift/reset概念。延续将最终使其进入主编译器，并且有可能提取出库中的复杂性吗？

Answer 1

尽管Python生成器很酷，但尝试复制它们确实不是Scala中最好的方法。例如，以下代码可以完成所需的工作：

def classStream(clazz: Class[_]): Stream[Class[_]] = clazz match {
  case null => Stream.empty
  case _ => (
    clazz 
    #:: classStream(clazz.getSuperclass) 
    #::: clazz.getInterfaces.toStream.flatMap(classStream) 
    #::: Stream.empty
  )
}

在其中，流是延迟生成的，因此它不会处理任何元素，直到被询问为止，您可以通过运行以下命令进行验证：

def classStream(clazz: Class[_]): Stream[Class[_]] = clazz match {
  case null => Stream.empty
  case _ => (
    clazz 
    #:: { println(clazz.toString+": super"); classStream(clazz.getSuperclass) } 
    #::: { println(clazz.toString+": interfaces"); clazz.getInterfaces.toStream.flatMap(classStream) } 
    #::: Stream.empty
  )
}

结果可以被转换成Iterator简单地通过调用.iterator对所得Stream：

def classIterator(clazz: Class[_]): Iterator[Class[_]] = classStream(clazz).iterator

使用的foo定义Stream将这样呈现：

scala> def foo(i: Int): Stream[Int] = i #:: (if (i > 0) foo(i - 1) else Stream.empty)
foo: (i: Int)Stream[Int]

scala> foo(5) foreach println
5
4
3
2
1
0

另一种选择是将各种迭代器串联起来，注意不要预先计算它们。这是一个示例，其中还包含调试消息以帮助跟踪执行：

def yieldClass(clazz: Class[_]): Iterator[Class[_]] = clazz match {
  case null => println("empty"); Iterator.empty
  case _ =>
    def thisIterator = { println("self of "+clazz); Iterator(clazz) }
    def superIterator = { println("super of "+clazz); yieldClass(clazz.getSuperclass) }
    def interfacesIterator = { println("interfaces of "+clazz); clazz.getInterfaces.iterator flatMap yieldClass }
    thisIterator ++ superIterator ++ interfacesIterator
}

这非常接近您的代码。取而代之的是sudoYield，我有了定义，然后按需要将它们串联起来。

因此，尽管这是一个无法解决的问题，但我只是认为您在这里树错了树。尝试在Scala中编写Python肯定是徒劳的。在实现相同目标的Scala习惯用法上加倍努力。