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?

[–] Flipper 13 points 3 months ago* (last edited 3 months ago) (1 children)

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 regex support.

That's the reason rand, regex, num, chrono etc. aren't part of the std.

[–] TehPers@beehaw.org 8 points 3 months ago (1 children)

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.

[–] nous@programming.dev 2 points 3 months ago

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,

[–] FizzyOrange@programming.dev 6 points 3 months ago

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.