C-Coroutines VS coro-chat

A coroutine is an execution context + all necessary data for restoring the execution context. This includes a place for saving/restoring the stack and the registers. I always loved the simplicity and beauty of the coroutine_yield32: assembly implementation of this library. It's literally just swapping out stack and registers with another context in userspace. Async-await patterns are an abstraction around this to decide when to switch and when not to switch. Note that at no point a thread is started or stopped, or communicated with other threads/cores. Yielding is literally a series of unconditional moves.

Or take advantage of the ABI of the runtime, and use assembly. [1] Yeah, not portable. But using setjmp()/longjmp() has issues as well (way too easy to mess it up because it doesn't do what you think it's doing).

[1] https://github.com/spc476/C-Coroutines

Stackless means when you resume a coroutine you're still using the same OS thread stack. Coroutine contexts/activation records are conceptually heap allocated (although in some cases that can be optimized away).

You can use coroutines for what you say, but there are no execution contexts (like a thread pool or an event loop) in C++20 standard library in which to execute coroutines, so to async I/O you need to use a library or DIY. This will come later as part of the Executors proposal.

You can currently use C++ native coroutines withe ASIO library, but this is probably subject to quite a bit of API churn in the future:

https://www.boost.org/doc/libs/1_75_0/doc/html/boost_asio/ov...

You can also wrap things like ASIO yourself. I did this in 2018 when I was learning about C++ coroutines to create a simple telnet based chatroom:

https://github.com/heavenlake/coro-chat/blob/master/chat.cpp

Note that this code is likely garbage by todays standards.