> The reason is that await does not offer a suspension point to an event loop (it just calls `__await__` and maybe that offers a suspension point), so if we wanted to use that syntax then we'd need to replace `yield coro` with something like await `tinyio.Task(coro)`. The traditional syntax is not worth the extra class.

From the readme:

> ”Ever used asyncio and wished you hadn't?”

Yes, that’s me. I always found the yield-based approach to coroutines much easier to reason about. It’s just a generator function.

I have a question. Why do you prefix your package files with an underscore?

In fact, you write all of your python like you really have something to hide ;) Like `_Todo`.

Where did you get this pattern?

(I’m way more curious than accusatory. Are people embracing private modules these days as a convention, and I just missed it?)

I just want to say this is brilliant. I've had my share of problems with asyncio and went back to using sync python and deque instead.

This is how static type checkers are told that an imported object is part of the public API for that file. (In addition to anything else present in that file.)

C.f. "the intention here is that only names imported using the form X as X will be exported" from PEP484. [1]

I'm generally a fan of the style of putting all the implementation in private modules (whose names start with an underscore) and then using __init__.py files solely to declare the public API.

[1] https://peps.python.org/pep-0484/

Yes. If a function contains the yield statement, calling that function returns a generator instead of executing its body. For example, here's defining and calling a regular function:

  >>> def foo_function():
  ...     print('In a function!')
  ...     return
  ...
  >>> foo_function()
  In a function!

And here's defining and calling a generator:

  >>> def foo_generator():
  ...     print('In a generator!')
  ...     return
  ...     yield
  ...
  >>> foo_generator()
  <generator object foo_generator at 0x10321aa40>
  >>> next(foo_generator())
  In a generator!
  Traceback (most recent call last):
    File "<python-input-6>", line 1, in <module>
      next(foo_generator())
      ~~~~^^^^^^^^^^^^^^^^^
  StopIteration

Notice that the generator's body isn't evaluated until you consume the generator. StopIteration isn't actually an error in usual cases. It just says that the generator doesn't have any more values to return and has exited. For example, that's how Python's for-loop works:

  >>> for _ in foo_generator():
  ...     continue
  ...
  In bar!

Here it executes the generator's body (including the print() call) until it gets to the return statement. Because it's a generator, it returns as normal and then raises a StopIteration exception, which tells the loop to stop looping.