ba1ee2d204
* tutorial/receiving_messages: fix future output type bound * tutorial/receiving_messages: remove unneeded message trimming Trimming was done twice on messages, so one of the two instances can be removed. I personally think removing the first instance, in which we are splitting names from messages makes the code more readable than removing the second instance, but other examples further in the tutorial show the second instance removed. * tutorial/receiving_messages: declare use of TcpStream and io::BufReader Readers couldn't see the `use` lines corresponding to these two structures. * tutorial/connecting_readers_and_writers: typos and grammar fixes * tutorial/all_together: remove unneeded use async_std::io * tutorial: use SinkExt consistently from futures::sink::SinkExt * tutorial/handling_disconnection: hide mpsc use clause and remove empty lines The empty lines translate to the output making it look weird. * tutorial/handling_disconnection: fix typos * tutorial/handling_disconnection: use ? in broker_handle.await We were happy to return an Err variant from the broker_handle before and nothing has changed in this regard, so bubbling it up to run(). |
||
|---|---|---|
| .github/workflows | ||
| benches | ||
| ci | ||
| docs | ||
| examples | ||
| src | ||
| tests | ||
| .gitignore | ||
| bors.toml | ||
| Cargo.toml | ||
| CHANGELOG.md | ||
| CODE_OF_CONDUCT.md | ||
| LICENSE-APACHE | ||
| LICENSE-MIT | ||
| README.md | ||
| rustfmt.toml | ||
async-std
API Docs | Book | Releases | Contributing
This crate provides an async version of std. It provides all the interfaces
you are used to, but in an async version and ready for Rust's async/await
syntax.
Features
- Modern: Built from the ground up for
std::futureandasync/awaitwith blazing fast compilation time. - Fast: Our robust allocator and threadpool designs provide ultra-high throughput with predictably low latency.
- Intuitive: Complete parity with the stdlib means you only need to learn APIs once.
- Clear: Detailed documentation and accessible guides mean using async Rust was never easier.
Examples
use async_std::task;
fn main() {
task::block_on(async {
println!("Hello, world!");
})
}
More examples, including networking and file access, can be found in our
examples directory.
Philosophy
We believe Async Rust should be as easy to pick up as Sync Rust. We also believe that the best API is the one you already know. And finally, we believe that providing an asynchronous counterpart to the standard library is the best way stdlib provides a reliable basis for both performance and productivity.
Async-std is the embodiment of that vision. It combines single-allocation task creation, with an adaptive lock-free executor, threadpool and network driver to create a smooth system that processes work at a high pace with low latency, using Rust's familiar stdlib API.
Installation
With cargo add installed run:
$ cargo add async-std
We also provide a set of "unstable" features with async-std. See the features documentation on how to enable them.
License
Licensed under either of Apache License, Version 2.0 or MIT license at your option.Unless you explicitly state otherwise, any contribution intentionally submitted for inclusion in this crate by you, as defined in the Apache-2.0 license, shall be dual licensed as above, without any additional terms or conditions.