Experimental language-level polyfills for Async Rust.
Async Rust is a work in progress. The language has enabled us to do some fantastic things, but not everything is figured out yet. This crate exists to polyfill language-level support for async idioms before they can be part of the language.
A great example of this is
async fn main, which we first introduced as
part of the
Its premise is that if
async fn is required for every
await call, it
makes sense to apply that even to
fn main. Unfortunately this would
require compiler support to enable, so we've provided an experimental
polyfill for it in the mean time.
Why isn't this crate part of async-std?
We want to make sure
async-std's surface area is stable, and only includes
things that would make sense to be part of "an async version of std".
Language level support is really important, but not part of the standard
This has some distinct benefits: in particular it allows us to version both crates at a different pace. And as features are added to the language (or we decide they weren't a great idea after all), we can incrementally shrink the surface area of this crate.
The other big benefit is that it allows libraries to depend on
without needing to pull in the rather heavy
proc-macro2 crates. This should help keep compilation times snappy for
This crate uses
#![deny(unsafe_code)] to ensure everything is implemented in
100% Safe Rust.
Want to join us? Check out our "Contributing" guide and take a look at some of these issues:
- https://docs.rs/runtime-attributes - our original experiments with
async fn main.
- https://docs.rs/async-trait - async trait support by the fantastic David Tolnay.
- https://docs.rs/futures-async-stream - for iterating and defining streams by the skilled Taiki Endo.
MIT OR Apache-2.0