[Python-Dev] PEP 492: What is the real goal?

[Greg Ewing]

Paul Moore wrote:
> I agree. While I don't use coroutines/asyncio, and I may never do so,
> I will say that I find Python's approach very difficult to understand.

Well, I tried to offer something easier to understand.
The idea behind PEP 3152 is that writing async code
should be just like writing threaded code, except that
the suspension points are explicit. But apparently
that was too simple, or something.

> Looking at the Wikipedia article on coroutines, I see an example of
> how a producer/consumer process might be written with coroutines:
> 
> var q := new queue
> 
> coroutine produce
>     loop
>         while q is not full
>             create some new items
>             add the items to q
>         yield to consume
> 
> coroutine consume
>     loop
>         while q is not empty
>             remove some items from q
>             use the items
>         yield to produce

Aaargh, this is what we get for overloading the word
"coroutine". The Wikipedia article is talking about a
technique where coroutines yield control to other
explicitly identified coroutines.

Coroutines in asyncio don't work that way; instead
they just suspend themselves, and the event loop
takes care of deciding which one to run next.

> I can't even see how to relate that to PEP 429 syntax. I'm not allowed
> to use "yield",

You probably wouldn't need to explicitly yield, since
you'd use an asyncio.Queue for passing data between the
tasks, which takes care of suspending until data
becomes available.

You would only need to yield if you were implementing
some new synchronisation primitive. Yury's answer to
that appears to be that you don't do it with an async
def function, you create an object that implements
the awaitable-object protocol directly.

-- 
Greg