rfcs

et platform, meaning that it will not support WASM, for example. But still no function colors, right? Unfortunately not: > This implementation [stackless coroutines] won’t be available immediately like the previous ones because it depends on reintroducing a special function calling convention and rewriting function bodies into state machines that don’t require an explicit stack to run. (Emphasis added.) And the function colors appear again. Now, to be fair, since there are multiple implementation options, you can avoid function colors, especially since `Io` is a value. But those options are either: * Use blocking I/O. * Use threads with blocking I/O. * Use green threads, which Rust removed [2] for good reasons [3]. It only works in Go because of the garbage collector. In short, the real options are: * Block (not async). * Use green threads (with their problems). * Function colors. It doesn't appear that the function colors problem has been defeated. Also, it appears to me that the Zig team decided to have every concurrency technique in the hope that it would appear innovative. [1]: https://gavinhoward.com/2022/04/i-believe-zig-has-function-c... [2]: https://github.com/aturon/rfcs/blob/remove-runtime/active/00... [3]: https://www.open-std.org/JTC1/SC22/WG21/docs/papers/2018/p13...

t to truly be a success, there should be clear-cut reasons people are employing it rather than another language. Rust needs to provide crisp, standout benefits to the organizations using it." https://github.com/aturon/rfcs/blob/roadmap-2017/text/0000-r...

ar drawbacks). Similarly, writing code purely in call-by-name style can be confusing and have difficult to predict performance impacts (e.g., Haskell lazy evaluation semantics). In their article the article "On the Duality of Operating System Structures", Lauer and Needham present a similar conclusion [3]: > "The principal conclusion we will draw from these observations is that the considerations for choosing which model to adopt in a given system [...] [are] a function of which set of primitive operations and mechanisms are easier to build or better suited to the constraints imposed by the machine architecture and hardware." In that passage they are describing message passing vs. procedure call systems, and I interpret this to be their acknowledgment that, though the systems are dual, one architecture or another is more appropriate in certain circumstances. Getting back to our original topic: this thread was about the decision of a Rust library to offer async or sync IO as its choice of primary primitive. I think async is the better general-purpose choice, because it's clean, simply, and straightforward to expose a synchronous interface on top of an async interfaces with futures; and the other way around is messy and difficult. Can you elaborate on the lightweight co-routine library that can be used to convert anything synchronous into async? I'm curious about that, because Rust previously had support for coroutines (green threads), and decided to remove them due to a number of problems [1]. Meanwhile, Rust developers were able to devise a zero-cost futures abstraction on top of asynchronous IO [2]. Unlikely the problematic green threads strategy, this approach doesn't impose any complicated constraints on the systems that use it (FFI requirements), and doesn't add runtime overhead. What co-routine library would you recommend that avoids the downsides in [1]? [1] https://github.com/aturon/rfcs/blob/remove-runtime/active/00... describes some pretty tricky challenges. [2] https://aturon.github.io/blog/2016/08/11/futures/ [3] https://pdfs.semanticscholar.org/2948/a0d014852ba47dd115fcc7...