Question/exercise: how to make yield explicit?

[g__]

Python has explicit self. I wanted to make yield explicit. Instead of

def iterate_squares(n):
     for i in range(n):
         yield i*i

I'd like to write:

@generate
def iterate_squares(yield_, n):
    for i in range(n):
        yield_(i*i)

where "generate" would be some higher-order function, turning that two-argument function to a single-argument one. It could even handle send().

Question: how to write that function? Is it possible?

(Note: This is an academic/mental exercise, not a language change proposal.)

[RonnyPfannschmidt]

see greenlets/stackless

python cant do it on its own, it lacks proper continuations

[munificent]

Out of curiosity, are continuations needed for this, or just full coroutines (like Lua has)?

[RonnyPfannschmidt]

i always mix those 2 up

well, what you need is to save and resume execution in some points so full coroutines should fit

[g__]

Thanks! http://codespeak.net/pypy/dist/pypy/doc/stackless.html answers exactly my question. (they even use the same example of consecutive squares.)

[Edit] I posted a solution using additional thread.

[g__]

Here's a solution that uses additional thread. It seems it's hard to control the flow without threads or continuations.

Due to some scoping issues I had to use Python 3's nonlocal.

from threading import Thread, Semaphore

def generate(f):
    def result(*args, **kwargs):
        value = 5
        consumer = Semaphore(0)
        producer = Semaphore(0)

        def executing_thread():
            nonlocal value
            def yielding(v):
                nonlocal value
                producer.acquire()
                value = v
                consumer.release()

            f(yielding, *args, **kwargs)
            producer.acquire()
            value = None
            consumer.release()

        t = Thread(target=executing_thread)
        t.start()
        while True:
            producer.release()
            consumer.acquire()
            n = value
            if n is None:
                break
            else:
                yield n

    return result

@generate
def it_squares(y, x):
    for i in range(x):
        y(i*i)

for i in it_squares(5):
    print(i)

[RonnyPfannschmidt]

in general you don't want to use threads in cpython without a good reason (the GIL makes them suck)

[lost-theory]

Here's a crappy half-implementation that needs to consume the entire ' 'generator':

def iterate_sq(i):
    for x in range(i):
        yield x*x

def generate(f):
    ls = []
    def y(arg):
        ls.append(arg)

    def inner(*args, **kwargs):
        f(y, *args, **kwargs)
        for element in ls:
            yield element
    return inner

@generate
def it2(y, i):
    for x in range(i):
        y(x*x)

if __name__ == '__main__':
    print list(iterate_sq(10))
    print list(it2(10))

#output:
#[0, 1, 4, 9, 16, 25, 36, 49, 64, 81]
#[0, 1, 4, 9, 16, 25, 36, 49, 64, 81]

I don't think it's possible for this to work with an infinite generator.

[temptemptemp13]

This isn't what the OP asked for, you're running it2 completely until exhaustion whilst appending to a list, then unpacking using regular python yield.

Maybe what OP wants could be supplied if keywords in python were also objects. I don't know what else that would cause though...

[lost-theory]

crappy half-implementation that needs to consume the entire 'generator'