[Python-ideas] More alternative names for yield-from

[Arnaud Delobelle]

2009/2/20 Greg Ewing <greg.ewing at canterbury.ac.nz>:
> I still wish I could find a better name for it.

I think 'yield from' is better than all the other suggestions apart
from 'yield *' which would be my choice.

A while ago I created a function to almost exactly add the
functionality you describe in your PEP including the return behaviour,
which I implemented using raise RETURN( ... ).  I've slightly modified
it so it agrees with your specification and include it in this message
after some very simple examples.  Of course it would not help you
implement the PEP but I thought it may be handy to play with some
examples in order to fine tune the PEP.

The function is called 'co' and applied to a generator function it
turns it into a generator that implements the special behavior of
yield FROM ( ... ) raise RETURN ( ... ).  Here are some very simple
examples and the implementation of co() follows at the end.


#
# List flattener.
#

def coflatten(x):
    if isinstance(x, list):
        for y in x:
            yield FROM( coflatten(y) )
    else:
        yield x

flatten = co(coflatten)

>>> list(flatten([[[[1,2,3]]],4,5]))
[1, 2, 3, 4, 5]


#
# Something like Guido's tree example
#

class Tree(object):
    def __init__(self, label, children=()):
        self.label = label
        self.children = children
    @co
    def __iter__(self):
        skip = yield self.label
        if skip:
            yield 'SKIPPED'
        else:
            yield 'ENTER'
            for child in self.children:
                yield FROM( child )
            yield 'LEAVE'

>>> tree = Tree('A', [Tree('B'), Tree('C')])
>>>
>>> list(tree)
['A', 'ENTER', 'B', 'ENTER', 'LEAVE', 'C', 'ENTER', 'LEAVE', 'LEAVE']

>>> i = iter(tree)
>>> skip = None
>>> try:
...     while True:
...         a, skip = i.send(skip), None
...         print a
...         if a == 'B':
...             skip = True
... except StopIteration:
...     pass
...
A
ENTER
B
SKIPPED
C
ENTER
LEAVE
LEAVE


#
# Simple example with raise RETURN ( ... )
#

@co
def gen():
    a = yield FROM( co_nested() )
    yield a

def co_nested():
    yield FROM( [1, 2] )
    raise RETURN( 3 )

>>> list(gen())
[1, 2, 3]


#
# Implementation of co(), FROM, RETURN
#

class FROM(object):
    def __init__(self, gen, val=None):
        self.data = gen, val

class RETURN(StopIteration):
    def __init__(self, val=None):
        self.val = val

def co(cogen, val=None):
    def gen(*args, **kwargs):
        gen = cogen(*args, **kwargs)
        val = None
        callstack = []
        while True:
            try:
                ret = gen.next() if val is None else gen.send(val)
            except StopIteration, e:
                if callstack:
                    gen, val = callstack.pop(), getattr(e, 'val', None)
                    continue
                raise
            if type(ret) is FROM:
                callstack.append(gen)
                gen, val = ret.data
                gen = iter(gen)
            else:
                try:
                    val = yield ret
                except Exception, e:
                    if hasattr(gen, 'throw'):
                        val = yield gen.throw(e)
                    else:
                        raise
    return gen

-- 
Arnaud