2
0
Fork 1
mirror of https://github.com/async-rs/async-std.git synced 2025-04-04 07:26:40 +00:00
No description
Find a file
bors[bot] c8475ca95e
Merge #207
207: Added the ability to collect a stream of results r=yoshuawuyts a=sunjay

As requested here: https://twitter.com/yoshuawuyts/status/1174026374316773377

The standard library has a very useful implementation of `FromIterator` that takes an iterator of `Result<T, E>` values and is able to produce a value of type `Result<Vec<T>, E>`. I asked for this in `async-std` and @yoshuawuyts recommended that I contribute the impl. It turns out that the implementation in the standard library is even more general than I initially thought. It allows any collection that implements `FromIterator` to be collected from an iterator of `Result<T, E>` values. That means that you can collect into `Result<Vec<T>, E>`, `Result<HashSet<T>, E>`, etc.

I wanted to add a similarly generic impl for this crate so we can also support collecting into any collection that implements `FromStream`. 

The implementation for this is based heavily on [what exists in `std`](9150f844e2/src/libcore/result.rs (L1379-L1429)). I made a new `result` module since that's where this impl is in `std`. I still wanted to maintain the conventions of this repo, so I copied the `vec` module that @yoshuawuyts created in #125. Much like in that PR, the new `result` module is private.

There is a doctest in the documentation for `collect` that both teaches that this feature exists and tests that it works in some simple cases.

## Documentation Screenshot

![image](https://user-images.githubusercontent.com/530939/65075935-de89ae00-d965-11e9-9cd6-8b19b694ed3e.png)


Co-authored-by: Sunjay Varma <varma.sunjay@gmail.com>
2019-09-17 22:35:00 +00:00
benches remove async_await feature gate 2019-08-21 00:29:35 -07:00
ci Restore Version Sort (#121) 2019-08-28 17:16:02 +02:00
docs Fix a typo 2019-09-11 17:29:33 +02:00
examples Clean up the fs module and a few other places 2019-09-14 01:24:31 +02:00
src Merge #207 2019-09-17 22:35:00 +00:00
tests Make sure ownership is transferred in into_raw_fd 2019-09-06 10:36:25 +01:00
.gitignore Initial commit 2019-08-08 14:44:48 +02:00
.travis.yml Update .travis.yml 2019-09-12 18:47:21 +01:00
bors.toml Add bors.toml 2019-09-04 19:32:47 +02:00
Cargo.toml Implement simple work stealing 2019-09-17 11:12:47 +02:00
CHANGELOG.md Prepare release for 0.99.5 2019-09-12 13:17:29 +02:00
CODE_OF_CONDUCT.md Create CODE_OF_CONDUCT.md 2019-08-12 20:02:31 +02:00
LICENSE-APACHE Initial commit 2019-08-08 14:44:48 +02:00
LICENSE-MIT Initial commit 2019-08-08 14:44:48 +02:00
README.md Merge #202 2019-09-16 14:08:50 +00:00
rustfmt.toml Add rustfmt config 2019-08-08 16:04:14 +02:00

Async version of the Rust standard library

Build Status License Cargo Documentation chat

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.

Documentation

async-std comes with extensive API documentation and a book.

Quickstart

Add the following lines to your Cargo.toml:

[dependencies]
async-std = "0.99"

Or use cargo add if you have it installed:

$ cargo add async-std

Hello world

use async_std::task;

fn main() {
    task::block_on(async {
        println!("Hello, world!");
    })
}

Low-Friction Sockets with Built-In Timeouts

use std::time::Duration;

use async_std::{
    prelude::*,
    task,
    io,
    net::TcpStream,
};

async fn get() -> io::Result<Vec<u8>> {
    let mut stream = TcpStream::connect("example.com:80").await?;
    stream.write_all(b"GET /index.html HTTP/1.0\r\n\r\n").await?;

    let mut buf = vec![];

    io::timeout(Duration::from_secs(5), async {
        stream.read_to_end(&mut buf).await?;
        Ok(buf)
    }).await
}

fn main() {
    task::block_on(async {
        let raw_response = get().await.expect("request");
        let response = String::from_utf8(raw_response)
            .expect("utf8 conversion");
        println!("received: {}", response);
    });
}

Features

async-std is strongly commited to following semver. This means your code won't break unless you decide to upgrade.

However every now and then we come up with something that we think will work great for async-std, and we want to provide a sneak-peek so you can try it out. This is what we call "unstable" features. You can try out the unstable features by enabling the unstable feature in your Cargo.toml file:

[dependencies]
[dependencies.async-std]
version = "0.99"
features = ["unstable"]

Just be careful when using these features, as they may change between versions.

Take a look around

Clone the repo:

git clone git@github.com:async-rs/async-std.git && cd async-std

Generate docs:

cargo doc --features docs.rs --open

Check out the examples. To run an example:

cargo run --example hello-world

Contributing

See our contribution document.

License

Licensed under either of

at your option.

Contribution

Unless you explicitly state otherwise, any contribution intentionally submitted for inclusion in the work by you, as defined in the Apache-2.0 license, shall be dual licensed as above, without any additional terms or conditions.