rayon

s). Concurrency appears to have been an afterthought in Swift's case, explicitly: https://gist.github.com/lattner/31ed37682ef1576b16bca1432ea9... . See also https://doc.rust-lang.org/book/ch16-00-concurrency.html and https://blog.spencerkohan.com/impressions-of-rust-as-a-swift... Data parallelism and other forms of concurrency should become more and more important over time as models grow larger and larger, well beyond GPT-3's 175 billion parameters. This would favor rust.

failed branch prediction! If you manage to eliminate branch misprediction, you can easily make sorting twice as fast! At least that is the case if you're sorting items by an integer key, or a tuple of integers, or something primitive like that (i.e. when comparison is rather cheap). Pdqsort efficiently eliminates branch mispredictions and brings some other improvements over introsort as well - for example, the complexity becomes O(nk) if the input array is of length n and consists of only k different values. Of course, worst-case complexity is always O(n log n). Finally, last week I implemented parallel sorts for Rayon (Rust's data parallelism library) based on timsort and pdqsort[4]. Check out the links for more information and benchmarks. And before you start criticizing the benchmarks, please keep in mind that they're rather simplistic, so please take them with a grain of salt. I'd be happy to elaborate further and answer any questions. :) [1] https://github.com/rust-lang/rust/pull/38192 [2] https://github.com/rust-lang/rust/issues/40585 [3] https://github.com/rust-lang/rust/pull/40601 [4] https://github.com/nikomatsakis/rayon/pull/379

m/tokio-rs/tokio But it seems like you're most interested in Erlang-style actors with M:N green threads? The issue here is that—as best I remember the history of Rust—the Rust maintainers decided that green threads were simply too high a level of abstraction for Rust. I think Rust will eventually move back in that direction, first using futures+tokio+async I/O, and then by eventually adding async/await sugar on top. That way, you'll only pay for coroutines/green threads when you explicitly opt in. But it will take a year or so for all this to start maturing, I think. In the meantime, tokio's method-chaining syntax should actually be somewhat tolerable, especially because Rust has a `#[must_use]` attribute that prevents you from forgetting to use a future. If you're lazy, just run everything through rustfmt to get the indentation right.