qcoro VS may

Yes, with boost.asio and with a self written Qt Networking Coroutine Library like QCoro.

You're not completely wrong, but I think this overstating things by a lot. I'll grant you the containers for example, but you can generally use STL algorithms with them. And plenty of old ways of doing things have left modern Qt-based codebases and moved to more modern ways of doing things, including a fair amount of moc macro usage (and yes, you can remove the moc these days, but it has different perf characteristics - cf. the verdigris project).

The community around Qt is pretty active at adopting modern C++, e.g. imho https://github.com/danvratil/qcoro is leading work.

I though that with the meager support for coroutines that C++ 20 has, it would take ages till I could use that in Qt, but I discovered that it's actually quite nice with QCoro, which is a 3rd part library that is able to leverage coroutines in Qt's event loop with just an add on. I thought it would require extra facilities in the language/library, plus some large patch to Qt to have the first support of them.

If you want to use coroutines with Qt, QCoro yends to work well: https://qcoro.dvratil.cz/

Have a look at https://github.com/danvratil/qcoro

https://github.com/Xudong-Huang/may

The project has some serious restrictions and unsound footguns (e.g. around TLS), but otherwise it's usable enough. There are also a number of C/C++ libraries, but I can not comment on those.

> e.g. Linux mutexes

You don't want to use blocking mutexes anyway with async.

> or Rust's Rc

This is only half true. The danger is that two `Rc` that point to the same data are in different threads. But it should be safe to move all of them at once from one thread to another, which is exactly the case if all the `Rc`s involved live inside a `Future`. The problem is that this is a non-local property that's hard to encode in the type system.

> By the way, if you wish to test uncolored async in Rust, you can find an implementation here: https://github.com/Xudong-Huang/may .

FYI that's known to be unsound due to thread locals. And more generally it doesn't seem to give much attention to safety (see for example how it allowed unsound scoped tasks, or the fact it allows doing unsafe operations in some of its macros due to wrong scoping of `unsafe` blocks).

It seems that rust removed native green threads as against it's philosophy: https://stackoverflow.com/questions/29428318/why-did-rust-remove-the-green-threading-model-whats-the-disadvantage#29430403 but there are good CSP libraries e.g. https://github.com/Xudong-Huang/may and yet people really like e.g. Tokio for Async/Await (although it also has greenthreads!) What am I missing?

Can you admit that you failed in making it a pleasant experience to write async, especially for library authors? I don’t think it’s too late to admit failure and implement something like May https://github.com/Xudong-Huang/may

Your benchmark is comparing apples to oranges, you're benchmarking different things. If you wanted to compare a Rust solution to something like what Go does, you would need to use something like this library.

Yep. This is the best coroutine library right now https://github.com/Xudong-Huang/may

I am still intrigued by the stackful coroutine library, May https://github.com/Xudong-Huang/may. I would like to see how far this library can push the boundaries of being a higher level alternative to async

There is also "may" which attempts to be a Rust version of goroutines. I have not used it though, so can't comment on anything further about it.

This library https://github.com/Xudong-Huang/may implement Stackful Coroutines in Rust which I believe is pretty close to what you're asking about. I believe it's a reasonably complete implementation, but it doesn't have much traction because most of the Rust ecosystem is using either async/await or native threads.

I've never worked with C# so I need to look into that.

The one saving grace with Rust is if everyone decides to say "screw async" and just builds synchronous APIs, then we use something like [May](https://github.com/Xudong-Huang/may) for green threading.