async-std changelog

Changelog History

Page 3

• v1.0.0 Changes

  November 11, 2019

  📚 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 Changes

  November 07, 2019

  📚 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 Changes

  October 29, 2019

  🔀 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::product as "unstable"
  • ➕ Added Stream::sum as "unstable"
  • Added Stream::min_by_key
  • ➕ Added Stream::max_by
  • ➕ 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 Changes

  October 16, 2019

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

  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

• v0.99.9 Changes

  October 08, 2019

  ⬆️ This patch upgrades our futures-rs version, allowing us to build on the 1.39 beta. Additionally we've introduced map and for_each to Stream. And we've ➕ added about a dozen new FromStream implementations for std types, bringing us up to par with std's FromIterator implementations.

  And finally we've added a new "unstable" task::blocking function which can be 👉 used to convert blocking code into async code using a threadpool. We've been using this internally for a while now to async-std to power our fs and net::SocketAddr implementations. With this patch userland code now finally has access to this too.

  Example

  Create a stream of tuples, and collect into a hashmap

  let a = stream::once(1u8);
  let b = stream::once(0u8);
  
  let s = a.zip(b);
  
  let map: HashMap<u8, u8> = s.collect().await;
  assert_eq!(map.get(&1), Some(&0u8));
  

  Spawn a blocking task on a dedicated threadpool

  task::blocking(async {
      println!("long-running task here");
  }).await;
  

  ➕ Added

  • ➕ Added stream::Stream::map
  • ➕ Added stream::Stream::for_each
  • Added stream::Stream::try_for_each
  • ➕ Added task::blocking as "unstable"
  • ➕ Added FromStream for all std::{option, collections, result, string, sync} types.
  • ➕ Added the path submodule as "unstable".

  🔄 Changed

  • ⚡️ Updated futures-preview to 0.3.0-alpha.19, allowing us to build on rustc 1.39.0-beta.
  • ⬆️ As a consequence of this upgrade, all of our concrete stream implementations now make use of Stream::size_hint to optimize internal allocations.
  • We now use GitHub Actions through actions-rs, in addition to Travis CI. We intend to fully switch in the near future.
  • 🛠 Fixed a bug introduced in 0.99.6 where Unix Domain Listeners would sometimes become unresponsive.
  • ⚡️ Updated our sync::Barrier docs to match std.
  • ⚡️ Updated our stream::FromStream docs to match std's FromIterator.

• v0.99.8 Changes

  September 28, 2019

  ➕ Added

  • ➕ Added README to examples directory.
  • ➕ Added concurrency documentation to the futures submodule.
  • ➕ Added io::Read::take method.
  • ➕ Added io::Read::by_ref method.
  • ➕ Added io::Read::chain method.

  🔄 Changed

  • ⬆️ Pin futures-preview to 0.3.0-alpha.18, to avoid rustc upgrade problems.
  • Simplified extension traits using a macro.
  • 🔀 Use the broadcast module with std::sync::Mutex, reducing dependencies.

• v0.99.7 Changes

  September 26, 2019

  ➕ Added

  • ➕ Added future::join macro as "unstable"
  • ➕ Added future::select macro as "unstable"
  • ➕ Added future::try_join macro as "unstable"
  • ➕ Added future::try_select macro as "unstable"
  • ➕ Added io::BufWriter struct
  • ➕ Added stream::Extend trait
  • ➕ Added stream::Stream::chain method
  • ➕ Added stream::Stream::filter method
  • ➕ Added stream::Stream::inspect method
  • ➕ Added stream::Stream::skip_while method
  • ➕ Added stream::Stream::skip method
  • ➕ Added stream::Stream::step_by method
  • ➕ Added sync::Arc struct from stdlib
  • ➕ Added sync::Barrier struct as "unstable"
  • ➕ Added sync::Weak struct from stdlib
  • ➕ Added task::ready macro as "unstable"

  🔄 Changed

  • 📌 Correctly marked the pin submodule as "unstable" in the docs
  • ⚡️ Updated tutorial to have certain functions suffixed with _loop
  • io traits are now re-exports of futures-rs types, allowing them to be implemented
  • stream traits are now re-exports of futures-rs types, allowing them to be implemented
  • prelude::* now needs to be in scope for functions io and stream traits to work

• v0.99.6 Changes

  September 19, 2019

  ➕ Added

  • ➕ Added stream::Stream::collect as "unstable"
  • ➕ Added stream::Stream::enumerate
  • ➕ Added stream::Stream::fuse
  • ➕ Added stream::Stream::fold
  • ➕ Added stream::Stream::scan
  • ➕ Added stream::Stream::zip
  • ➕ Added stream::join macro as "unstable"
  • ➕ Added stream::DoubleEndedStream as "unstable"
  • ➕ Added stream::FromStream trait as "unstable"
  • ➕ Added stream::IntoStream trait as "unstable"
  • ➕ Added io::Cursor as "unstable"
  • ➕ Added io::BufRead::consume method
  • ➕ Added io::repeat
  • ➕ Added io::Slice and io::SliceMut
  • ➕ Added documentation for feature flags
  • ➕ Added pin submodule as "unstable"
  • ➕ Added the ability to collect a stream of Result<T, E>s into a Result<impl FromStream<T>, E>

  🔄 Changed

  • 🔨 Refactored the scheduling algorithm of our executor to use work stealing
  • 🔨 Refactored the network driver, removing 400 lines of code
  • ✂ Removed the Send bound from task::block_on
  • ✂ Removed Unpin bound from impl<T: futures::stream::Stream> Stream for T

• v0.99.5 Changes

  September 12, 2019

  ➕ Added

  • ➕ Added tests for io::timeout
  • 📊 Added io::BufRead::fill_buf, an async fn counterpart to poll_fill_buf
  • Added fs::create_dir_all
  • ➕ Added future::timeout, a free function to time out futures after a threshold
  • ➕ Added io::prelude
  • ➕ Added net::ToSocketAddrs, a non-blocking version of std's ToSocketAddrs
  • ➕ Added stream::Stream::all
  • ➕ Added stream::Stream::filter_map
  • ➕ Added stream::Stream::find_map
  • ➕ Added stream::Stream::find
  • ➕ Added stream::Stream::min_by
  • ➕ Added stream::Stream::nth

  🔄 Changed

  • 💅 Polished the text and examples of the tutorial
  • cargo fmt on all examples
  • Simplified internals of TcpStream::connect_to
  • 👷 Modularized our CI setup, enabled a rustfmt fallback, and improved caching
  • ⬇️ Reduced our dependency on the futures-rs crate, improving compilation times
  • Split io::Read, io::Write, io::BufRead, and stream::Stream into multiple files
  • 👀 fs::File now flushes more often to prevent flushes during seek
  • ⚡️ Updated all dependencies
  • 🛠 Fixed a bug in the conversion of File into raw handle
  • 🛠 Fixed compilation errors on the latest nightly

  ✂ Removed

• v0.99.4 Changes

  August 21, 2019

  🔄 Changes

  • ✏️ Many small changes in the book, mostly typos
  • 📚 Documentation fixes correcting examples
  • Now works with recent nightly with stabilised async/await (> 2019-08-21)

• « First
• ‹ Prev
• 1
• 2
• 3
• 4
• Next ›
• Last »