this post was submitted on 12 Aug 2024
1 points (100.0% liked)
Rust
5989 readers
5 users here now
Welcome to the Rust community! This is a place to discuss about the Rust programming language.
Wormhole
Credits
- The icon is a modified version of the official rust logo (changing the colors to a gradient and black background)
founded 1 year ago
MODERATORS
you are viewing a single comment's thread
view the rest of the comments
view the rest of the comments
I wish Rust would adopt tokio (or any other, if better suited) as a default first citizen async runtime. Then everyone can be sure to write in that runtime , knowingly it will run. If people need a different runtime, they could still opt out of tokio and opt in to whatever they like. The freedom of choice would not be hindered, but we would gain a default runtime.
What's stopping this from happening?
Is that even desirable? There are other runtimes for specific things, e.g. for embedded, WASM, Fuchsia, etc. Doesn't seem like there's a one-size-fits-all runtime.
I guess the proper answer is some kind of minimum standard async interface, but presumably there's a reason they haven't done that.
I dunno really, I've avoided async Rust as much as possible due to the number of footguns it has.
Goal is to keep the std to the absolute minimum. It's a lot easier to change a normal library and switch over, than to change std. Just ask the c++ guys about their reflex support.
That's the reason rand, regex, num, chrono etc. aren't part of the std.
Or look at Python and their urllib, urllib2, new urllib, and the requests package on PyPi.
We already sort of saw this in Rust with crossbeam and standard channels, until of course they replaced the standard lib implementation with crossbeam's implementation.
Yeah, std can never break backwards compatibility. So any big thing that gets added needs to be sure it wont ever change. Something like tokio is far too large for that and already does not fit all use cases.
What I want to see is more support for interop between the different run times by providing standard interfaces for things between the various runtimes. For instance being able to spawn a task in for the runtime to take care of. You cannot do that without knowing which runtime you are using ATM. Which is highly anoying for developing libraries that need to do this. And that is only one of the many problems that could be solved in the std lib without needing to bring in the whole runtime - just create common interfaces we can use that can be implemented by each runtime,