I feel you! Coroutines can be tricky at first. I recommend Lewis Baker's blog about coroutines [1], which is detailed and insightful. Additionally, cppreference [2] is a great resource to understand how coroutines work in C++.

In a nutshell, C++ coroutines are almost like regular functions, except that they can be "paused" (suspended), and their state is stored on the heap so they can be resumed later. When you resume a coroutine, its state is loaded back, and execution continues from where it left off.

The complicated part comes from the interfaces through which you use coroutines in C++. Each coroutine needs to be associated with a promise object, which defines how the coroutine behaves (for example, what happens when you co_return a value). Then, there are awaiters, which define what happens when you co_await them. For example, C++ provides a built-in awaiter called suspend_always{}, which you can co_await to pause the coroutine.

If you take your time and go thoroughly through the blog and Cppreference, you'll definitely get the hang of it.

Hope this helps.

[1] https://lewissbaker.github.io/ [2] https://en.cppreference.com/w/cpp/language/coroutines

They're just green threads with some nice syntax sugar, right? Instead of an OS-level "pause" with a futex-wait or sleep (resumed by the kernel scheduler), they do an application-level pause and require some application-level scheduler. (But coroutines can still call library or kernel functions that block/sleep, breaking userspace scheduling?)

Yes, exactly. Coroutines are one possible implementation of green threads. Once they are scheduled/loaded on an OS thread, they behave just like regular functions with their own call stack. This means they can indeed call blocking operations at the OS level. A possible approach to handle such operations would be to wrap the blocking call, suspend the coroutine, and then resume it once the operation is complete, perhaps by polling(checking for completion).

Dumbed down way too far.

They are a function that can remember where they are in their own execution so when they are called later they continue execution where they left of.

There are many many ways of implementing that functionality, C++ standard coroutines are only one such implementation.

What you do with them is whatever you want, it's pretty common to handle IO using them but generators are also a pretty common example. But that is generally high level.

C++ coroutines are basic building blocks and are very low level, there is no executor ( rust tokio / python asyncio ) so don't be worried if it seems hard to use, it is hard to use.

Look at std::generator for how coroutines are used to implement a generator, cppcoro is also a pretty popular library that builds abstractions on top of coroutines and also has some executors if I remember correctly.

Do you mean C++ coroutines, or coroutines in general? If you're new to the concept I would try to start with Python's, then Javascript or C#. C++'s is way more complicated.

Note that C# and C++ are quite similar, the biggest difference are the lifetime gotchas and not having coroutines runtime on the standard library.

Their design has a common source, and the magic methods for awaitables as well.

Co-routines can be a nebulous sort of concept because it means different things in different places and not all of them have the same features. But some of the big points are:

- Heap allocated call frame. Instead of being pushed onto the stack, co-routines tend to have their call frame (local variables, arguments, etc.) placed into heap memory (or at least may be place-able into heap memory). This often enables the other features.

- Control can leave co-routines in more ways than standard function calls. Generally this means returning (often called "yield") to the caller without completing the whole function. It can then be later resumed, returning to where the function originally left off. Generators are a common pattern enabled by co-routines that rely on only this part (and so many systems can optimize out the heap usage, for example).

- A co-routine is usually an object with an interface that allows you to move it around and resume it in different places than it was originally called. This can include on different threads, or depending on the sophistication of the system, different processes or machines.

Those are the three big points in my mind. I'd recommend trying lua coroutines, personally (I like minmalist engines like defold to use it in) to really get a feel for how these are on the edge between "language feature" and "library feature".

imagine a virtual (green) thread which the kernel doesn't run in parallel until you tell it it's ok to do so (when you explicitly yield control) and then can continue from that place when you explicitly tell it to.

you can even try to run those virtual threads on real threads. much fun to be had.

One way to get a sense of coroutines is to consider the behavior presented by the async/await design pattern [1], where 'await' suspends the execution of the currently running code and yields control to the 'async' task. (As an adage goes, "async is not asynchronous, and await does not await anything.") Yet another pattern is "promise/future", where the code execution is (or may be) suspended as soon as the code tries to obtain the promised result.

[1] https://learn.microsoft.com/en-us/dotnet/csharp/asynchronous...

Coroutines themselves are a really simple concept. But in practice they give you all the headaches async stuff generally gives you. And in C++ there is a ton of extra complication, especially because there is no support library. I wrote this in a tutorial a while ago:

> they are functions that can suspend themselves, meaning they stop themselves without returning, even in the middle of their body and then can later can be resumed, continuing execution at the point they suspended from earlier.

If you want to use coroutines in C++ specifically you can have a look at this tutorial, if you want: https://theshoemaker.de/posts/yet-another-cpp-coroutine-tuto... I don't know of anyone that read it, but I spent a lot of time on it.

It essentially tries to explain how to build a coroutine support library yourself, but if you don't care about that, skip it and just use libcoro or cppcoro. They have examples too. My little async io library has some examples as well if you want to get an idea.

Coroutines are just multiple call stacks. If coroutine A calls coroutine B then B excutes on its on stack and can ‘yield’ a value back to A. Yielding is just a return across stacks without destroying the current stack. So A continued with the yielded valie on its own stack and when ready calls B again which continues on its own stack with the next statement after the previous yield. Etc.

Notice that this does not necessarily involve parallelism, although it can. For example, Lua has non parallel (cooperative) co-routines. Go had parallel coroutins, called goroutines, but theoretically only if they they use channels to exchange values. Otherwise, if they’re not exchanging information they would not becoroutins in the sense that they work together in solving something.

I didn't understand C++ coroutines until I learned to use Lua coroutines. It's basically not that different from gotos, if goto saved local state.

Yeah there aren't many good resources on it unfortunately. One thing to note is C++20's coroutine support is really low level. It's designed for library authors so that they can build the kinds of things "normal" people want - tasks, generators, futures, promises, etc.

This video is the best intro I've found. It actually explains what is happening in memory, which is the only way to really understand anything in C++.

https://youtu.be/aibjUHx7vew

Also this is decent:

https://www.scs.stanford.edu/~dm/blog/c++-coroutines.html

But don't try and write a coroutine library yourself. Use something like libcoro.