GCC 11 Enables Co-Routines Support In C++20 Mode

[kpedersen]

IIRC, C# -- pronounced "Chash" (the first "h" is silent) -- was intended to be a better Java than Java..

Exactly. It has nothing to do with C.

In fact the C in the name was due to two things:

1) The obvious marketing tactic by Microsoft to spread uncertainty and cash in on the popularity and benefits of C++
2) CSharp used to be called "Microsoft Cool" (How gross is that!). So the "C" derives from that name.

Don't fall for it kids! C++ is a vastly superior tool and will outlive this cheap Java clone.

C++/clr on the other hand was fairly good. I could work with twits and yet not have to use their twit language

[kreijack]

I'm kind of curious about what the motivation is for co-routines, though, since threads are better and fully supported.

Coroutine and thread are different things; for example the former, doesn't need synchronization primitive. And typically the latter are use to run different codes in parallel.
However I have to point out that there are some overlap between the different technologies, mostly if the thread is implemented as "cooperative" thread.

[bug77]

Afaik, coroutines don't typically run in parallel (i.e. they only multiplex work on one thread). On the other hand Go's version, goroutines, are spread by the runtime over any number of available threads.
How do these C++ coroutines work? (I've been out of the loop wit C and C++ for quite a while.)

[sindr]

On the other hand Go's version, goroutines, are spread by the runtime over any number of available threads.

Yep, see also Erlang and Project Loom's implementations.

[pal666]

I think C++ deserves a pat on the back for trying to catch up to Rust

you live in an alternative universe where rust had coroutines before c++?

[pal666]

these new coroutines are extremely hard to use. Everyone who doesn’t believe welcome to try. I have no idea why it was not possible to provide stackfull coroutines python or java script style ??

it is possible, boost provides one. stackful and stackless both have their pros and cons, it's good to have both(or something combined, and there was an effort to combine them, but it wasn't successful yet)

However I know the current implementation in the standard was proposed by a guy from Microsoft.

microsoft was impatient because they need them for their api

[pal666]

std::cout << i << std::endl;

https://www.youtube.com/watch?v=6WeEMlmrfOI

[dev_null]

The current implementation is the basic plumbing on which it is possible to build a library support. The intended use is not for the generic developer. You should look to a library like cppcoro https://github.com/lewissbaker/cppcoro which is a lot more user friendly :

using cppcoro;
generator<const std::uint64_t> fibonacci() {
std::uint64_t a = 0, b = 1;
while (true) {
co_yield b;
auto tmp = a;
a = b;
b += tmp;
}
}
void usage() {
for (auto i : fibonacci()) {
if (i > 1'000'000)
break;
std::cout << i << std::endl;
}
}

Thanks!. Looks like it won't work on Linux at full power though, and most likely won't work at gcc-10 without some adoption.

[dev_null]

it is possible, boost provides one. stackful and stackless both have their pros and cons, it's good to have both(or something combined, and there was an effort to combine them, but it wasn't successful yet)
microsoft was impatient because they need them for their api

I personally want to resolve an asynchronous hell. It's when you have a lot of lambdas/callbacks like described here but for C++ https://blog.hellojs.org/asynchronou...t-9b9ceb63c8e8
So I was extremely disappointed that the new coroutines just don't allow me to do this anyhow easily.

[pal666]

I'm kind of curious about what the motivation is for co-routines, though, since threads are better and fully supported.

coroutines have nothing to do with threads, they are syntactic sugar for callbacks(single threaded). they don't run concurrently and do not require synchronization, which has impact on reasoning and on execution