Simulate edge cancellation

[davidbrochart]

I often want to be able to cancel an individual task, and have something that looks like asyncio's edge cancellation API, while keeping the advantages of structured concurrency.
In AnyIO this means creating a task group just for that task, but since this operation is async, one has to await the creation of the task group before being able to cancel the task, which is not the case in asyncio where launching and cancelling a task can be done in non-async functions:

from asyncio import create_task, run, sleep

async def foo():
    print("start")
    await sleep(10)
    print("stop")

async def main():
    task = create_task(foo())
    task.cancel()

run(main())

The following Cancellable class is close to asyncio's API, but cancelling needs to be awaited:

from anyio import Event, create_task_group, run, sleep

class Cancellable:
    def __init__(self, coro):
        self._coro = coro
        self._event = Event()

    async def cancel(self):
        await self._event.wait()
        self._tg.cancel_scope.cancel()

    async def run(self):
        async with create_task_group() as self._tg:
            self._event.set()
            await self._coro

async def foo():
    print("start")
    await sleep(10)
    print("stop")

async def main():
    async with create_task_group() as tg:
        cancellable = Cancellable(foo())
        tg.start_soon(cancellable.run)
        await cancellable.cancel()

run(main)

And the following version has a non-async cancellation:

from anyio import Event, create_task_group, run, sleep
from anyio.abc import TaskGroup

class Cancellable:
    def __init__(self, coro):
        self._coro = coro
        self._stop_event = Event()

    def cancel(self):
        self._stop_event.set()

    async def run(self):
        async with create_task_group() as tg:
            tg.start_soon(self._run, tg)
            tg.start_soon(self._check_stop, tg)

    async def _run(self, tg: TaskGroup):
        await self._coro
        tg.cancel_scope.cancel()

    async def _check_stop(self, tg: TaskGroup):
        await self._stop_event.wait()
        tg.cancel_scope.cancel()

async def foo():
    print("start")
    await sleep(10)
    print("stop")

async def main():
    async with create_task_group() as tg:
        cancellable = Cancellable(foo())
        tg.start_soon(cancellable.run)
        cancellable.cancel()

run(main)

I'm not sure this is the right way to do it, maybe I'm missing something simpler?
Do you think simulating edge cancellation is not a good idea in the first place?