Ask HN: What problems do Generators solve in Java? | Hacker News Reader

Ask HN: What problems do Generators solve in Java?

There has been some discussions lately about the need to support generators now that Virtual threads are a thing. I am reading up some examples and I still don't understand what is a generator and why is it powerful.

Some examples from Python: https://www.programiz.com/python-programming/generator

Some examples using plain Java 8: https://www.mguenther.net/2016/01/functional_generators_in_java_8/index.html

I am a little confused why this is regarded as a powerful pattern. It seems I can implement the same using a normal `Iterator`. For instance, from the Python example:

  class PowTwoGen {
    final int max;
    int n = 0;

    PowTwoGen(int max) { this.max = max;}

    boolean hasNext() { return n <= max;}

    int next() { return Math.pow(2, n++); }
  }

The examples for the Java 8 article can also be done with a simple method call but instead the examples with the Generator seems overly complex. What am I missing?

View on HN

I think that guy just made up a generator class for fun. It’s not too different from the interator except it doesn’t have a hasNext() method so it either returns results forever or it has to return a sentinel value like null or return an exception to end iteration.

Somebody could make the case that returning a sentinel value or an exception is a better API since there is no risk somebody else is going to call the next() method after you call hasNext() and next(). Writing a generator that wraps a generator is a little simpler than writing an interest or that wraps an iteration because you don’t have to write a hasNext() function, which can occasionally be awkward.

That generator library has a few functions, like map that work on generators, unfortunately the Java stdlib doesn’t come with anything like that. (There is the streams API but it is over-complicated.)

I’ll point out this library I wrote

https://github.com/paulhoule/pidove

which does a lot of what the Steams library does but it works on iterators without creating streams. If you like those generator examples you might like pidove.

As for Python it is kinda accidental that generators would up related to coroutines, that is, generators were an easy way to implement coroutines, later async/await and stuff like that got added.

A generator function can always be implemented via an iterator class, but often the generator is more convenient. Without generators, you manually need to convert loops and conditionals (typical programming) into an explicit state machine (atypical programming, and more verbose)

Your example in Python:

    class Pow2:
        def __init__(self, n):
            self.value = 0
            self.n = n

        def __iter__(self):
            return self

        def __next__(self):
            if self.value < self.n:
                ans = self.value * self.value
                self.value += 1
                return ans
            else:
                raise StopIteration
    
    iter(Pow2(n))

is semantically equivalent to

    def pow2(n):
        value = 0
        while value < n:
            yield value * value
            value += 1
    
    pow2(n)

and

    (i * i for i in range(n))

but both the generators are a lot less code.

The generator expression (last one) can actually be implemented right now in Java streams (something like `IntRange::to(n).map(i => i * i)`). But the generator functions which use `yield` are necessary for more complex expressions: the ones which have nested loops, resources, exceptions, etc. which are even more verbose when converted into generator classes

> I am a little confused why this is regarded as a powerful pattern

The power of the generator is that, unlike an iterator, the collection of values doesn't "exist", it is created on the fly. This comes in to play when iterating over, say the set of integers, or something else that would take significant amounts of memory.

Also, as functions, generators can be passed around in any language that treats functions a first-class types.

Even in the iterator implementation, the values are created on the fly, correct?

What is an example, where a generator would be able to dynamically produce the values while an iterator would need all the source value to exist in some memory?

All generators are iterators. Not all iterators are generators.

Sorry for being thick. You said:

The power of the generator is that, unlike an iterator, the collection of values doesn't "exist", it is created on the fly.

What is a specific example where this is true?

Python: <https://wiki.python.org/moin/Generators>

Javascript: <https://www.digitalocean.com/community/tutorials/understandi...>

The Python example is more to the point. The Javascript one gets there, but goes in a roundabout way.

I still don't see where the iterator version would need to have all the values already exist but thanks for the links.

To me it seems the benefit is conciseness of the implementation and its usage at the call site.

Reply on news.ycombinator.com