Non-issue with coroutines that don't checkpoint

[davidbrochart]

Interestingly, the following code fails to run task_that_never_continues() with both asyncio or Trio (see Trio's documentation):

from anyio import create_task_group, run, sleep

async def do_nothing():
    pass

async def task_that_never_continues():
    print("some time for the other task to run...")
    await anyio.sleep(0.1)
    print("this part never runs")

async def task_that_never_lets_other_tasks_run():
    while True:
        await do_nothing()
        # await sleep(0)


async def main():
    async with create_task_group() as tg:
        tg.start_soon(task_that_never_continues)
        tg.start_soon(task_that_never_lets_other_tasks_run)

run(main)

But it is fine with tinyio:

import tinyio

def do_nothing():
    pass

def task_that_never_continues():
    print("some time for the other task to run...")
    yield tinyio.sleep(0.1)
    print("this part does run")

def task_that_never_lets_other_tasks_run():
    while True:
        yield do_nothing()


def main():
    yield [task_that_never_continues(), task_that_never_lets_other_tasks_run()]

loop = tinyio.Loop()
out = loop.run(main())

To me, not yielding back to the event loop when running an async function (even though it is secretly synchronous) is a big issue, since it should be a strong guarantee. So kudos to you @patrick-kidger for solving it in tinyio!

[patrick-kidger]

Thank you! I'm glad someone spotted this :) One of the more niche things I was happy to get in here.

---

In case you're curious, this is actually (one of) the reasons for the yield syntax over await.

await foo simply calls the foo.__await__ method, and maybe that offers a suspension point. So if foobar_io.Task.__await__ uses yield then writing await foobar_io.Task(coro) will indeed yield back to the event loop.

This introduces a footgun: writing await coro will call types.CoroutineType.__await__, but that does not use yield, and so there is no suspension point... leading to the issue you describe in your first snippet!

We solve this by simply using yield directly :)