v1.5.0

API Documentation

This patch includes various quality of life improvements to async-std.
Including improved performance, stability, and the addition of various
Clone impls that replace the use of Arc in many cases.

Added

• Added links to various ecosystem projects from the README (#660)
• Added an example on FromStream for Result<T, E> (#643)
• Added stream::pending as "unstable" (#615)
• Added an example of stream::timeout to document the error flow (#675)
• Implement Clone for DirEntry (#682)
• Implement Clone for TcpStream (#689)

Changed

• Removed internal comment on stream::Interval (#645)
• The "unstable" feature can now be used without requiring the "default" feature (#647)
• Removed unnecessary trait bound on stream::FlatMap (#651)
• Updated the "broadcaster" dependency used by "unstable" to 1.0.0 (#681)
• Updated async-task to 1.2.1 (#676)
• task::block_on now parks after a single poll, improving performance in many cases (#684)
• Improved reading flow of the "client" part of the async-std tutorial (#550)
• Use take_while instead of scan in impl of Product, Sum and FromStream (#667)
• TcpStream::connect no longer uses a thread from the threadpool, improving performance (#687)

Fixed

• Fixed crate documentation typo (#655)
• Fixed documentation for UdpSocket::recv (#648)
• Fixed documentation for UdpSocket::send (#671)
• Fixed typo in stream documentation (#650)
• Fixed typo on sync::JoinHandle documentation (#659)
• Removed use of std::error::Error::description which failed CI (#661)
• Removed the use of rustfmt's unstable format_code_in_doc_comments option which failed CI (#685)
• Fixed a code typo in the task::sleep example (#688)

v1.4.0

API Documentation

This patch adds Future::timeout, providing a method counterpart to the
future::timeout free function. And includes several bug fixes around missing
APIs. Notably we're not shipping our new executor yet, first announced on our
blog.

Examples

use async_std::prelude::*;
use async_std::future;
use std::time::Duration;

let fut = future::pending::<()>(); // This future will never resolve.
let res = fut.timeout(Duration::from_millis(100)).await;
assert!(res.is_err()); // The future timed out, returning an err.

Added

• Added Future::timeout as "unstable" (#600)

Fixes

• Fixed a doc test and enabled it on CI (#597)
• Fixed a rendering issue with the stream submodule documentation (#621)
• Write::write_fmt's future is now correctly marked as #[must_use] (#628)
• Fixed the missing io::Bytes export (#633)
• Fixed the missing io::Chain export (#633)
• Fixed the missing io::Take export (#633)

v1.3.0

API Documentation

This patch introduces Stream::delay, more methods on DoubleEndedStream,
and improves compile times. Stream::delay is a new API that's similar to
task::sleep,
but can be passed as part of as stream, rather than as a separate block. This is
useful for examples, or when manually debugging race conditions.

Examples

let start = Instant::now();
let mut s = stream::from_iter(vec![0u8, 1]).delay(Duration::from_millis(200));

// The first time will take more than 200ms due to delay.
s.next().await;
assert!(start.elapsed().as_millis() >= 200);

// There will be no delay after the first time.
s.next().await;
assert!(start.elapsed().as_millis() <= 210);

Added

• Added Stream::delay as "unstable" (#309)
• Added DoubleEndedStream::next_back as "unstable" (#562)
• Added DoubleEndedStream::nth_back as "unstable" (#562)
• Added DoubleEndedStream::rfind as "unstable" (#562)
• Added DoubleEndedStream::rfold as "unstable" (#562)
• Added DoubleEndedStream::try_rfold as "unstable" (#562)
• stream::Once now implements DoubleEndedStream (#562)
• stream::FromIter now implements DoubleEndedStream (#562)

Changed

• Removed our dependency on async-macros, speeding up compilation (#610)

Fixes

• Fixed a link in the task docs (#598)
• Fixed the UdpSocket::recv example (#603)
• Fixed a link to task::block_on (#608)
• Fixed an incorrect API mention in task::Builder (#612)
• Fixed leftover mentions of futures-preview (#595)
• Fixed a typo in the tutorial (#614)
• <TcpStream as Write>::poll_close now closes the write half of the stream (#618)

v1.2.0

API Documentation

This patch includes some minor quality-of-life improvements, introduces a
new Stream::unzip API, and adds verbose errors to our networking types.

This means if you can't connect to a socket, you'll never have to wonder again
which address it was you couldn't connect to, instead of having to go through
the motions to debug what the address was.

Example

Unzip a stream of tuples into two collections:

use async_std::prelude::*;
use async_std::stream;

let s  = stream::from_iter(vec![(1,2), (3,4)]);

let (left, right): (Vec<_>, Vec<_>) = s.unzip().await;

assert_eq!(left, [1, 3]);
assert_eq!(right, [2, 4]);

Added

• Added Stream::unzip as "unstable".
• Added verbose errors to the networking types.

Changed

• Enabled CI on master branch.
• Future::join and Future::try_join can now join futures with different
  output types.

Fixed

• Fixed the docs and Debug output of BufWriter.
• Fixed a bug in Stream::throttle that made it consume too much CPU.

v1.1.0

API Documentation

This patch introduces a faster scheduler algorithm, Stream::throttle, and
stabilizes task::yield_now. Additionally we're introducing several more stream
APIs, bringing us to almost complete parity with the standard library.

Furthermore our path submodule now returns more context in errors. So if
opening a file fails, async-std will tell you which file was failed to open,
making it easier to write and debug programs.

Examples

let start = Instant::now();

let mut s = stream::interval(Duration::from_millis(5))
    .throttle(Duration::from_millis(10))
    .take(3);

s.next().await;
assert!(start.elapsed().as_millis() >= 5);

s.next().await;
assert!(start.elapsed().as_millis() >= 15);

s.next().await;
assert!(start.elapsed().as_millis() >= 25);

Added

• Added Stream::throttle as "unstable".
• Added Stream::count as "unstable".
• Added Stream::max as "unstable".
• Added Stream::successors as "unstable".
• Added Stream::by_ref as "unstable".
• Added Stream::partition as "unstable".
• Added contextual errors to the path submodule.
• Added os::windows::symlink_dir as "unstable".
• Added os::windows::symlink_file as "unstable".
• Stabilized task::yield_now.

Fixes

• We now ignore seek errors when rolling back failed read calls on File.
• Fixed a bug where Stream::max_by_key was returning the wrong result.
• Fixed a bug where Stream::min_by_key was returning the wrong result.

Changed

• Applied various fixes to the tutorial.
• Fixed an issue with Clippy.
• Optimized an internal code generation macro, improving compilation speeds.
• Removed an Unpin bound from stream::Once.
• Removed various extra internal uses of pin_mut!.
• Simplified Stream::any and Stream::all's internals.
• The surf example is now enabled again.
• Tweaked some streams internals.
• Updated futures-timer to 2.0.0, improving compilation speed.
• Upgraded async-macros to 2.0.0.
• Stream::merge now uses randomized ordering to reduce overall latency.
• The scheduler is now more efficient by keeping a slot for the next task to
  run. This is similar to Go's scheduler, and Tokio's scheduler.
• Fixed the documentation of the channel types to link back to the channel
  function.

v1.0.1

API Documentation

We were seeing a regression in our fs performance, caused by too many
long-running tasks. This patch fixes that regression by being more proactive
about closing down idle threads.

Changes

• Improved thread startup/shutdown algorithm in task::spawn_blocking.
• Fixed a typo in the tutorial.

v1.0.0

API Documentation

This release marks the 1.0.0 release of async-std; a major milestone for our
development. This release itself mostly includes quality of life improvements
for all of modules, including more consistent API bounds for a lot of our
submodules.

The biggest change is that we're now using the full semver range,
major.minor.patch, and any breaking changes to our "stable" APIs will require
an update of the major number.

We're excited we've hit this milestone together with you all. Thank you!

Added

• Added Future::join as "unstable", replacing future::join!.
• Added Future::try_join as "unstable", replacing future::try_join!.
• Enabled stable and beta channel testing on CI.
• Implemented FromIterator and Extend for PathBuf.
• Implemented FromStream for PathBuf.
• Loosened the trait bounds of io::copy on "unstable".

Changed

• Added a Sync bound to RwLock, resolving a memory safety issue.
• Fixed a bug in Stream::take_while where it could continue after it should've
  ended.
• Fixed a bug where our attributes Cargo feature wasn't working as intended.
• Improved documentation of Stream::merge, documenting ordering guarantees.
• Update doc imports in examples to prefer async-std's types.
• Various quality of life improvements to the future submodule.
• Various quality of life improvements to the path submodule.
• Various quality of life improvements to the stream submodule.

Removed

• Removed future::join! in favor of Future::join.
• Removed future::try_join! in favor of Future::try_join.

v0.99.12

API Documentation

This patch upgrades us to futures 0.3, support for async/await on Rust
Stable, performance improvements, and brand new module-level documentation.

Added

• Added Future::flatten as "unstable".
• Added Future::race as "unstable" (replaces future::select!).
• Added Future::try_race as "unstable" (replaces future::try_select!).
• Added Stderr::lock as "unstable".
• Added Stdin::lock as "unstable".
• Added Stdout::lock as "unstable".
• Added Stream::copied as "unstable".
• Added Stream::eq as "unstable".
• Added Stream::max_by_key as "unstable".
• Added Stream::min as "unstable".
• Added Stream::ne as "unstable".
• Added Stream::position as "unstable".
• Added StreamExt and FutureExt as enumerable in the prelude.
• Added TcpListener and TcpStream integration tests.
• Added stream::from_iter.
• Added sync::WakerSet for internal use.
• Added an example to handle both IP v4 and IP v6 connections.
• Added the default Cargo feature.
• Added the attributes Cargo feature.
• Added the std Cargo feature.

Changed

• Fixed a bug in the blocking threadpool where it didn't spawn more than one thread.
• Fixed a bug with Stream::merge where sometimes it ended too soon.
• Fixed a bug with our GitHub actions setup.
• Fixed an issue where our channels could spuriously deadlock.
• Refactored the task module.
• Removed a deprecated GitHub action.
• Replaced futures-preview with futures.
• Replaced lazy_static with once_cell.
• Replaced all uses of VecDequeue in the examples with stream::from_iter.
• Simplified sync::RwLock using the internal sync::WakerSet type.
• Updated the path submodule documentation to match std.
• Updated the mod-level documentation to match std.

Removed

• Removed future::select! (replaced by Future::race).
• Removed future::try_select! (replaced by Future::try_race).

v0.99.11

API Documentation

This patch introduces async_std::sync::channel, a novel asynchronous port of
the ultra-fast Crossbeam channels. This has been one of the most anticipated
features for async-std, and we're excited to be providing a first version of
this!

In addition to channels, this patch has the regular list of new methods, types,
and doc fixes.

Examples

Send and receive items from a channel

// Create a bounded channel with a max-size of 1
let (s, r) = channel(1);

// This call returns immediately because there is enough space in the channel.
s.send(1).await;

task::spawn(async move {
    // This call blocks the current task because the channel is full.
    // It will be able to complete only after the first message is received.
    s.send(2).await;
});

// Receive items from the channel
task::sleep(Duration::from_secs(1)).await;
assert_eq!(r.recv().await, Some(1));
assert_eq!(r.recv().await, Some(2));

Added

• Added Future::delay as "unstable"
• Added Stream::flat_map as "unstable"
• Added Stream::flatten as "unstable"
• Added Stream::max_by
• Added Stream::min_by_key
• Added Stream::product as "unstable"
• Added Stream::sum as "unstable"
• Added Stream::timeout as "unstable"
• Added sync::channel as "unstable".
• Added doc links from instantiated structs to the methods that create them.
• Implemented Extend + FromStream for PathBuf.

Changed

• Fixed an issue with block_on so it works even when nested.
• Fixed issues with our Clippy check on CI.
• Replaced our uses of cfg_if with our own macros, simplifying the codebase.
• Updated the homepage link in Cargo.toml to point to async.rs.
• Updated the module-level documentation for stream and sync.
• Various typos and grammar fixes.
• Removed redundant file flushes, improving the performance of File operations

Removed

Nothing was removed in this release.

v0.99.10

This patch stabilizes several core concurrency macros, introduces async versions
of Path and PathBuf, and adds almost 100 other commits.

API Documentation

Examples

Asynchronously read directories from the filesystem

use async_std::fs;
use async_std::path::Path;
use async_std::prelude::*;

let path = Path::new("/laputa");
let mut dir = fs::read_dir(&path).await.unwrap();
while let Some(entry) = dir.next().await {
    if let Ok(entry) = entry {
        println!("{:?}", entry.path());
    }
}

Cooperatively reschedule the current task on the executor

use async_std::prelude::*;
use async_std::task;

task::spawn(async {
    let x = fibonnacci(1000); // Do expensive work
    task::yield_now().await;  // Allow other tasks to run
    x + fibonnacci(100)       // Do more work
})

Create an interval stream

use async_std::prelude::*;
use async_std::stream;
use std::time::Duration;

let mut interval = stream::interval(Duration::from_secs(4));
while let Some(_) = interval.next().await {
    println!("prints every four seconds");
}

Added

• Added FutureExt to the prelude, allowing us to extend Future
• Added Stream::cmp
• Added Stream::ge
• Added Stream::last
• Added Stream::le
• Added Stream::lt
• Added Stream::merge as "unstable", replacing stream::join!
• Added Stream::partial_cmp
• Added Stream::take_while
• Added Stream::try_fold
• Added future::IntoFuture as "unstable"
• Added io::BufRead::split
• Added io::Write::write_fmt
• Added print!, println!, eprint!, eprintln! macros as "unstable"
• Added process as "unstable", re-exporting std types only for now
• Added std::net re-exports to the net submodule
• Added std::path::PathBuf with all associated methods
• Added std::path::Path with all associated methods
• Added stream::ExactSizeStream as "unstable"
• Added stream::FusedStream as "unstable"
• Added stream::Product
• Added stream::Sum
• Added stream::from_fn
• Added stream::interval as "unstable"
• Added stream::repeat_with
• Added task::spawn_blocking as "unstable", replacing task::blocking
• Added task::yield_now
• Added write! and writeln! macros as "unstable"
• Stabilized future::join! and future::try_join!
• Stabilized future::timeout
• Stabilized path
• Stabilized task::ready!

Changed

• Fixed BufWriter::into_inner so it calls flush before yielding
• Refactored io::BufWriter internals
• Refactored net::ToSocketAddrs internals
• Removed Travis CI entirely
• Rewrote the README.md
• Stabilized io::Cursor
• Switched bors over to use GitHub actions
• Updated the io documentation to match std's io docs
• Updated the task documentation to match std's thread docs

Removed

• Removed the "unstable" stream::join! in favor of Stream::merge
• Removed the "unstable" task::blocking in favor of task::spawn_blocking