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.

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

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

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

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

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.

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?

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?

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.

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