Step 5 - A runnable Example

Lets take a look at our current concept by using a runnable example.

Loop v1

def loop(coroutine):
    """Loop v1"""

    step = 1
    while True:
        print("Loop step", step)
        try:
            next(coroutine)
            step += 1
        except StopIteration as e:
            return e.value

from loop import loop


def generator_one():
    print(generator_one.__name__, 1)
    yield
    print(generator_one.__name__, 2)


def generator_two():
    print(generator_two.__name__, 1)
    yield
    print(generator_two.__name__, 2)
    yield
    print(generator_two.__name__, 3)


def chaining_generator():
    print(chaining_generator.__name__, 1)
    yield from generator_one()
    print(chaining_generator.__name__, 2)
    yield from generator_two()
    print(chaining_generator.__name__, 3)


def main_generator():
    print(main_generator.__name__, 1)
    yield from chaining_generator()
    print(main_generator.__name__, 2)


result = loop(main_generator())
print("Loop finished with result", result)

Output:

Loop step 1
main_generator 1
chaining_generator 1
generator_one 1
Loop step 2
generator_one 2
chaining_generator 2
generator_two 1
Loop step 3
generator_two 2
Loop step 4
generator_two 3
chaining_generator 3
main_generator 2
Loop finished with result None

As a sequence diagram:

sequenceDiagram participant l as loop participant mg as Main Generator participant cg as Chaining Generator participant g1 as Generator One participant g2 as Generator Two activate l activate l l->>mg: next deactivate l activate mg activate mg mg->>cg: yield from deactivate mg activate cg activate cg cg->>g1: yield from deactivate cg activate g1 activate g1 g1-->>l: yield deactivate g1 activate l l->>g1: next deactivate l activate g1 g1->>cg: return deactivate g1 deactivate g1 activate cg cg->>g2: yield from deactivate cg activate g2 activate g2 g2-->>l: yield deactivate g2 activate l l->>g2: next deactivate l activate g2 g2-->>l: yield deactivate g2 activate l l->>g2: next deactivate l activate g2 g2->>cg: return deactivate g2 deactivate g2 activate cg cg->>mg: return deactivate cg deactivate cg activate mg mg->>l: return deactivate mg deactivate mg deactivate l

Summary

We have learned so far:

• yield suspends execution of a coroutine.

• Using yield from suspends the execution back to the initial caller at the root - the loop.

• The loop resumes the execution where the last yield was executed.

• A loop is easiest to be implemented as a function that gets a single coroutine passed as argument. This coroutine may call other coroutines.