Generator-based Coroutine Versus Native Coroutine

I just read PEP0492 talking about the new approach on coroutines but the PEP failed to make me understand the difference between generator-based coroutines and native ones. Can som

Solution 1:

To expand on what Mike S wrote: native coroutines in CPython share most of the same code as generators, so there's little functional difference. However, I think that PEP-492 rises above the threshold of just "syntactic sugar". Generators and native coroutines have separate purposes, so the new syntax clarifies an author's intent and can do things the old syntax cannot. Here are some examples:

• Generators are iterable, and native coroutines are not.
• Native coroutines also permit new syntaxes like async context managers and async iterators.
• Coroutines have useful debugging messages, e.g. a warning if you never await a coroutine object.

The new syntax also nicely mirrors the asyncio library and resembles keywords used in other languages.

Solution 2:

There is no functional difference. "Native coroutines" using the async and await keywords are just syntactic sugar for what was previously implemented in "generator-based coroutines."

The use of async and await is recommended in the 3.5 docs if there is no need to support older Python versions.

Solution 3:

Well, conventionally the way to write coroutines involved callbacks. Even though callbacks might be convenient initially, but in my opinion, they lead to highly complicated and complex code, which is not pythonic to say the least. Besides, yield (especially yield from since python 3.3), has made implementing coroutines a lot easier and pythonic.

With generators, you can easily divide your code into initial part and callbacks.

@asyncio.coroutine
def print_sum(x, y):
    result = yield from compute(x, y)

    #write callback code
    print("%s + %s = %s" % (x, y, result))