corocc module implements execution of coroutines with explicit
suspend and continuation, inspired by Kotlin.
This is useful for integrating coroutines with environments that can't run a full PEP 3156 event loop, but that still provide support for executing callbacks.
See the blog post for details about the topic.
corocc allows a coroutine to willingly suspend itself and, before
suspension, get a reference to a callable that will continue its
execution. Here is a very simple example that just stores the
continuation in a global variable:
import corocc async def always_suspending(): global cont i = 1 while True: async with corocc.suspending() as cont: print('suspension', i) i += 1 >>> corocc.start(always_suspending()) suspension 1 >>> cont() suspension 2 >>> cont() suspension 3 ...
This doesn't look too useful since driving a coroutine from the
outside can be achieved with the
send coroutine method. But
corocc allows for the coroutine to continue itself, without
relying on an outside agent to "drive" it.
For example, this is an equivalent of
continues the current coroutine in a different thread:
import corocc, threading async def thread_sleep(delay): async with corocc.suspending() as cont: t = threading.Timer(delay, cont) t.start() async def greet(): print('hello...') await thread_sleep(1) print('...world') >>> corocc.start(greet()) hello... >>> ...world
An equivalent coroutine that uses the GLib main loop:
async def glib_sleep(delay): async with corocc.suspending() as cont: GLib.timeout_add(delay * 1000, cont)
corocc is distributed under the terms of the MIT license, see
LICENSE-MIT for details. Contributing changes is
assumed to signal agreement with these licensing terms.