team

Wouldn't it be possible to implement all of the same semantics in pure Swift using a concurrent dispatch queue and some semaphores? I tried making a generator like the one in Hexagen: https://gist.github.com/Sidnicious/8e57892b14629c5ec740 I understand the main benefits of coroutines as: - Cheap creation - Cheap context switching - Predictable context switching …and I don't know the performance characteristics of Grand Central Dispatch. Could someone who's more familiar with GCD explain why using it for this kind of concurrency is an okay/bad idea and how it compares to coroutines? (FWIW I'm a huge fan of hacking async semantics into languages and made a thing like this for C++: https://github.com/Sidnicious/team)

Nice! I use Ghostery which blocks the 'Github Ribbon' by default - it took me a while to find the repo ( https://github.com/Sidnicious/team ) since it wasn't linked prominently elsewhere on the page. Thanks for sharing.

I'm working on a library for C++ called Team where this kind of flow control is possible. At its core it's got coroutines, so you can write code in a blocking style. The current (early!) socket APIs can all be called with a callback (which act like Node and call it as fast as possible), or without one (in which case they block). Here's an echo server that accepts connections as fast as possible, but does blocking reads and writes so only one chunk per client gets buffered at a time: https://github.com/Sidnicious/team/blob/b157ea2c58177a2587c9... The callbacks-as-fast-as-possible version is just implemented on top of the blocking one, so it'd be trivial to add flow control via a blocking callback (or by calling `accept()` in blocking style and making your own decision about when to call it again): https://github.com/Sidnicious/team/blob/b1