Vfrdtyky

I know that in Python, generators are invoked lazily. For example:

>>> def G():

...     print('this was evaluated now 1')

...     yield 1

...     print('this was evaluated now 2')

...     yield 2

...

>>> g = G()

>>> next(g)

this was evaluated now 1

1

>>> next(g)

this was evaluated now 2

2

The line print('this was evaluated now 1') was evaluated only after the first next(g) was called.

I wonder whether there is a simple way to invoke the generator non-lazily. This means that when calling g = G(), the function would calculate everything up to and including the first yield result, without actually yielding. Then, on the first call to next(g), the already-calculated result will be yielded, and also everything up to and including the second yield result would be calculated. And so on.

How can this be achieved?

Here is the expected behavior under this non-lazy scheme:

>>> g = G()

this was evaluated now 1

>>> next(g)

1

this was evaluated now 2

>>> next(g)

2

Here is a solution attempt, which does not work:

>>> class NonLazyGenerator():

...     def __init__(self,G):

...         self.g = G()

...         self.next_value = next(self.g)

...

...     def __next__(self):

...         current_value = self.next_value

...         try:

...             self.next_value = next(self.g)

...         except StopIteration:

...             pass

...         return current_value

...

>>> g = NonLazyGenerator(G)

this was evaluated now 1

>>> next(g)

this was evaluated now 2

1

>>> next(g)

2

This fails since the value is yielded only after the return statement, while the calculation of everything up to the next yield happens before the return statement. This example made me realize that it may not be possible to perform what I am seeking for, since it would require doing steps after the function has returned (might require multi-threading).

You could probably write some kind of decorator for it, such as:

def eagergenerator(mygen):

    class GeneratorWrapper:

        def __init__(self, *args, **kwargs):

            self.g = mygen(*args, **kwargs)

            self.last = next(self.g)

        def __iter__(self):

            return self

        def __next__(self):

            if self.last is self:

                raise StopIteration

            fake_yield = self.last

            try:

                self.last = next(self.g)

                return fake_yield

            except StopIteration:

                self.last = self

                return fake_yield

    return GeneratorWrapper

Then you can simply decorate your normal generators:

@eagergenerator

def G():

    print("one")

    yield 1

    print("two")

    yield 2

which will work as follows:

>>> g = G()                               

one                                       

>>> next(g)                               

two                                       

1                                         

>>> next(g)                               

2                                         

>>> next(g)                               

Traceback (most recent call last):        

  File "<stdin>", line 1, in <module>     

  File "eagergen.py", line 10, in __next__

    raise StopIteration                   

StopIteration                             

>>>                                       

credit: this was inspired by @L3viathan answer

In this version, itertools.tee is used to store the one yielded value the wrapper is behind the original generator.

import itertools



def eagergenerator(mygen):

    class GeneratorWrapper:

        def __init__(self, *args, **kwargs):

            self.g0, self.g1 = itertools.tee(mygen(*args, **kwargs))

            self._next0()

        def _next0(self):

            try:

                next(self.g0)

            except StopIteration:

                pass

        def __iter__(self):

            return self

        def __next__(self):

            self._next0()

            return next(self.g1)

    return GeneratorWrapper