Scala equivalent to Python generators?

Question

Is it possible to implement in Scala something equivalent to the Python `yield` statement where it remembers the local state of the function where it is used and "yields" the next value each time it is called? I wanted to have something like this to convert a recursive function into an iterator. Sort of like this: ``` # 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 ``` Except, `foo` may be more complex and recurs through some acyclic object graph. Additional Edit: Let me add a more complex example (but still simple): I can write a simple recursive function printing things as it goes along: ``` // 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 + " ") } } } ``` Ideally I would like to have a library that allows me to easily change a few statements and…

Accepted Answer

While Python generators are cool, trying to duplicate them really isn't the best way to go about in Scala. For instance, the following code does the equivalent job to what you want:

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

In it the stream is generated lazily, so it won't process any of the elements until asked for, which you can verify by running this:

```
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
  )
}
```

The result can be converted into an `Iterator` simply by calling `.iterator` on the resulting `Stream`:

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

The `foo` definition, using `Stream`, would be rendered thus:

```
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
```

Another alternative would be concatenating the various iterators, taking care to not pre-compute them. Here's an example, also with debugging messages to help trace the execution:

```
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
}
```

This is pretty close to your code. Instead of `sudoYield`, I have definitions, and then I just concatenate them as I wish.

So, while this is a non-answer, I just think you are barking up the wrong tree here. Trying to write Python in Scala is bound to be unproductive. Work harder at the Scala idioms that accomplish the same goals.

Scala equivalent to Python generators?

Solution

Problem

Related problems