| # 0.3.29 - 2023-10-26 |
| |
| * Add `TryStreamExt::try_ready_chunks` (#2757) |
| * Add `TryStreamExt::{try_all,try_any}` (#2783) |
| * Add `UnboundedSender::{len,is_empty}` (#2750) |
| * Fix `Sync` impl of `FuturesUnordered` (#2788) |
| * Fix infinite loop caused by invalid UTF-8 bytes (#2785) |
| * Fix build error with -Z minimal-versions (#2761) |
| |
| # 0.3.28 - 2023-03-30 |
| |
| * Update to syn 2. This raises MSRV of utility crates to 1.56. (#2730, #2733) |
| * Fix bug in `FlattenUnordered` (#2726, #2728) |
| |
| # 0.3.27 - 2023-03-11 |
| |
| * Add `TryFlattenUnordered` (#2577, #2590, #2606, #2607) |
| * Add `AbortHandle::is_aborted` (#2710) |
| * Add `AbortRegistration::handle` (#2712) |
| * Make `BiLock` strict-provenance compatible (#2716) |
| |
| # 0.3.26 - 2023-01-30 |
| |
| * Add `Either::as_pin_mut` and `Either::as_pin_ref` (#2691) |
| * Add `Shared::ptr_eq` and `Shared::ptr_hash` (#2691) |
| * Implement `FusedStream` for `Buffered` (#2676) |
| * Implement `FusedStream` for all streams in `ReadyChunks` (#2693) |
| * Fix bug in `FuturesOrdered::push_front` (#2664) |
| * Remove `Fut::Output: Clone` bounds from some `Shared` methods (#2662) |
| * Remove `T: Debug` bounds from `Debug` implementations of `mpsc` and `oneshot` types (#2666, #2667) |
| |
| # 0.3.25 - 2022-10-20 |
| |
| * Fix soundness issue in `join!` and `try_join!` macros (#2649) |
| * Implement `Clone` for `sink::Drain` (#2650) |
| |
| # 0.3.24 - 2022-08-29 |
| |
| * Fix incorrect termination of `select_with_strategy` streams (#2635) |
| |
| # 0.3.23 - 2022-08-14 |
| |
| * Work around MSRV increase due to a cargo bug. |
| |
| # 0.3.22 - 2022-08-14 |
| |
| * Fix `Sync` impl of `BiLockGuard` (#2570) |
| * Fix partial iteration in `FuturesUnordered` (#2574) |
| * Fix false detection of inner panics in `Shared` (#2576) |
| * Add `Mutex::lock_owned` and `Mutex::try_lock_owned` (#2571) |
| * Add `io::copy_buf_abortable` (#2507) |
| * Remove `Unpin` bound from `TryStreamExt::into_async_read` (#2599) |
| * Make `run_until_stalled` handle self-waking futures (#2593) |
| * Use `FuturesOrdered` in `try_join_all` (#2556) |
| * Fix orderings in `LocalPool` waker (#2608) |
| * Fix `stream::Chunk` adapters size hints (#2611) |
| * Add `push_front` and `push_back` to `FuturesOrdered` (#2591) |
| * Deprecate `FuturesOrdered::push` in favor of `FuturesOrdered::push_back` (#2591) |
| * Performance improvements (#2583, #2626) |
| * Documentation improvements (#2579, #2604, #2613) |
| |
| # 0.3.21 - 2022-02-06 |
| |
| * Fix potential data race in `FlattenUnordered` that introduced in 0.3.20 (#2566) |
| |
| # 0.3.20 - 2022-02-06 |
| |
| NOTE: This release has been yanked due to a bug fixed in 0.3.21. |
| |
| * Fix stacked borrows violations when `-Zmiri-tag-raw-pointers` is enabled. This raises MSRV of `futures-task` to 1.45. (#2548, #2550) |
| * Change `FuturesUnordered` to respect yielding from future (#2551) |
| * Add `StreamExt::{flatten_unordered, flat_map_unordered}` (#2083) |
| |
| # 0.3.19 - 2021-12-18 |
| |
| * Remove unstable `read-initializer` feature (#2534) |
| * Fix panic in `FuturesUnordered` (#2535) |
| * Fix compatibility issue with `FuturesUnordered` and tokio's cooperative scheduling (#2527) |
| * Add `StreamExt::count` (#2495) |
| |
| # 0.3.18 - 2021-11-23 |
| |
| NOTE: This release has been yanked. See #2529 for details. |
| |
| * Fix unusable `Sink` implementation on `stream::Scan` (#2499) |
| * Make `task::noop_waker_ref` available without `std` feature (#2505) |
| * Add async `LineWriter` (#2477) |
| * Remove dependency on `proc-macro-hack`. This raises MSRV of utility crates to 1.45. (#2520) |
| |
| # 0.3.17 - 2021-08-30 |
| |
| * Use `FuturesOrdered` in `join_all` (#2412) |
| * Add `{future, stream}::poll_immediate` (#2452) |
| * Add `stream_select!` macro (#2262) |
| * Implement `Default` for `OptionFuture` (#2471) |
| * Add `Peekable::{peek_mut, poll_peek_mut}` (#2488) |
| * Add `BufReader::seek_relative` (#2489) |
| |
| # 0.3.16 - 2021-07-23 |
| |
| * Add `TryStreamExt::try_chunks` (#2438) |
| * Add `StreamExt::{all, any}` (#2460) |
| * Add `stream::select_with_strategy` (#2450) |
| * Update to new `io_slice_advance` interface (#2454) |
| |
| # 0.3.15 - 2021-05-11 |
| |
| * Use `#[proc_macro]` at Rust 1.45+ to fix an issue where proc macros don't work with rust-analyzer (#2407) |
| * Support targets that do not have atomic CAS on stable Rust (#2400) |
| * futures-test: Add async `#[test]` function attribute (#2409) |
| * Add `stream::abortable` (#2410) |
| * Add `FuturesUnordered::clear` (#2415) |
| * Implement `IntoIterator` for `FuturesUnordered` (#2423) |
| * Implement `Send` and `Sync` for `FuturesUnordered` iterators (#2416) |
| * Make `FuturesUnordered::iter_pin_ref` public (#2423) |
| * Add `SelectAll::clear` (#2430) |
| * Add `SelectAll::{iter, iter_mut}` (#2428) |
| * Implement `IntoIterator` for `SelectAll` (#2428) |
| * Implement `Clone` for `WeakShared` (#2396) |
| |
| # 0.3.14 - 2021-04-10 |
| |
| * Add `future::SelectAll::into_inner` (#2363) |
| * Allow calling `UnboundedReceiver::try_next` after `None` (#2369) |
| * Reexport non-Ext traits from the root of `futures_util` (#2377) |
| * Add `AsyncSeekExt::stream_position` (#2380) |
| * Add `stream::Peekable::{next_if, next_if_eq}` (#2379) |
| |
| # 0.3.13 - 2021-02-23 |
| |
| * Mitigated starvation issues in `FuturesUnordered` (#2333) |
| * Fixed race with dropping `mpsc::Receiver` (#2304) |
| * Added `Shared::{strong_count, weak_count}` (#2346) |
| * Added `no_std` support for `task::noop_waker_ref` (#2332) |
| * Implemented `Stream::size_hint` for `Either` (#2325) |
| |
| # 0.3.12 - 2021-01-15 |
| |
| * Fixed `Unpin` impl of `future::{MaybeDone, TryMaybeDone}` where trait bounds were accidentally added in 0.3.9. (#2317) |
| |
| # 0.3.11 - 2021-01-14 |
| |
| * Fixed heap buffer overflow in `AsyncReadExt::{read_to_end, read_to_string}` (#2314) |
| |
| # 0.3.10 - 2021-01-13 |
| |
| NOTE: This release has been yanked. See #2310 for details. |
| |
| * Fixed type-inference in `sink::unfold` by specifying more of its types (breaking change -- see #2311) |
| |
| # 0.3.9 - 2021-01-08 |
| |
| NOTE: This release has been yanked. See #2310 for details. |
| |
| * Significantly improved compile time when `async-await` crate feature is disabled (#2273) |
| * Added `stream::repeat_with` (#2279) |
| * Added `StreamExt::unzip` (#2263) |
| * Added `sink::unfold` (#2268) |
| * Added `SinkExt::feed` (#2155) |
| * Implemented `FusedFuture` for `oneshot::Receiver` (#2300) |
| * Implemented `Clone` for `sink::With` (#2290) |
| * Re-exported `MapOkOrElse`, `MapInto`, `OkInto`, `TryFlatten`, `WriteAllVectored` (#2275) |
| |
| # 0.3.8 - 2020-11-04 |
| |
| NOTE: This release has been yanked. See #2310 for details. |
| |
| * Switched proc-macros to use native `#[proc_macro]` at Rust 1.45+ (#2243) |
| * Added `WeakShared` (#2169) |
| * Added `TryStreamExt::try_buffered` (#2245) |
| * Added `StreamExt::cycle` (#2252) |
| * Implemented `Clone` for `stream::{Empty, Pending, Repeat, Iter}` (#2248, #2252) |
| * Fixed panic in some `TryStreamExt` combinators (#2250) |
| |
| # 0.3.7 - 2020-10-23 |
| |
| NOTE: This release has been yanked. See #2310 for details. |
| |
| * Fixed unsoundness in `MappedMutexGuard` (#2240) |
| * Re-exported `TakeUntil` (#2235) |
| * futures-test: Prevent double panic in `panic_waker` (#2236) |
| |
| # 0.3.6 - 2020-10-06 |
| |
| NOTE: This release has been yanked. See #2310 for details. |
| |
| * Fixed UB due to missing 'static on `task::waker` (#2206) |
| * Added `AsyncBufReadExt::fill_buf` (#2225) |
| * Added `TryStreamExt::try_take_while` (#2212) |
| * Added `is_connected_to` method to `mpsc::{Sender, UnboundedSender}` (#2179) |
| * Added `is_connected_to` method to `oneshot::Sender` (#2158) |
| * Implement `FusedStream` for `FuturesOrdered` (#2205) |
| * Fixed documentation links |
| * Improved documentation |
| * futures-test: Added `track_closed` method to `AsyncWriteTestExt` and `SinkTestExt` (#2159) |
| * futures-test: Implemented more traits for `InterleavePending` (#2208) |
| * futures-test: Implemented more traits for `AssertUnmoved` (#2208) |
| |
| # 0.3.5 - 2020-05-08 |
| |
| NOTE: This release has been yanked. See #2310 for details. |
| |
| * Added `StreamExt::flat_map`. |
| * Added `StreamExt::ready_chunks`. |
| * Added `*_unpin` methods to `SinkExt`. |
| * Added a `cancellation()` future to `oneshot::Sender`. |
| * Added `reunite` method to `ReadHalf` and `WriteHalf`. |
| * Added `Extend` implementations for `Futures(Un)Ordered` and `SelectAll`. |
| * Added support for reexporting the `join!` and `select!` macros. |
| * Added `no_std` support for the `pending!` and `poll!` macros. |
| * Added `Send` and `Sync` support for `AssertUnmoved`. |
| * Fixed a bug where `Shared` wasn't relinquishing control to the executor. |
| * Removed the `Send` bound on the output of `RemoteHandle`. |
| * Relaxed bounds on `FuturesUnordered`. |
| * Reorganized internal tests to work under different `--feature`s. |
| * Reorganized the bounds on `StreamExt::forward`. |
| * Removed and replaced a large amount of internal `unsafe`. |
| |
| # 0.3.4 - 2020-02-06 |
| |
| NOTE: This release has been yanked. See #2310 for details. |
| |
| * Fixed missing `Drop` for `UnboundedReceiver` (#2064) |
| |
| # 0.3.3 - 2020-02-04 |
| |
| NOTE: This release has been yanked. See #2310 for details. |
| |
| * Fixed compatibility issue with pinned facade (#2062) |
| |
| # 0.3.2 - 2020-02-03 |
| |
| NOTE: This release has been yanked. See #2310 for details. |
| |
| * Improved buffering performance of `SplitSink` (#1969) |
| * Added `select_biased!` macro (#1976) |
| * Added `hash_receiver` method to mpsc channel (#1962) |
| * Added `stream::try_unfold` (#1977) |
| * Fixed bug with zero-size buffers in vectored IO (#1998) |
| * `AtomicWaker::new()` is now `const fn` (#2007) |
| * Fixed bug between threadpool and user park/unparking (#2010) |
| * Added `stream::Peekable::peek` (#2021) |
| * Added `StreamExt::scan` (#2044) |
| * Added impl of `AsyncRead`/`Write` for `BufReader`/`Writer` (#2033) |
| * Added impl of `Spawn` and `LocalSpawn` for `Arc<impl Spawn` and `Rc<impl Spawn>` (#2039) |
| * Fixed `Sync` issues with `FuturesUnordered` (#2054) |
| * Added `into_inner` method for `future::Ready` (#2055) |
| * Added `MappedMutexGuard` API (#2056) |
| * Mitigated starvation issues in `FuturesUnordered` (#2049) |
| * Added `TryFutureExt::map_ok_or_else` (#2058) |
| |
| # 0.3.1 - 2019-11-07 |
| |
| NOTE: This release has been yanked. See #2310 for details. |
| |
| * Fix signature of `SpawnExt` and `LocalSpawnExt` trait (breaking change -- see #1959) |
| |
| # 0.3.0 - 2019-11-05 |
| |
| NOTE: This release has been yanked. See #2310 for details. |
| |
| * Stable release along with stable async/await! |
| * Added async/await to default features (#1953) |
| * Changed `Spawn` trait and `FuturesUnordered::push` to take `&self` (#1950) |
| * Moved `Spawn` and `FutureObj` out of `futures-core` and into `futures-task` (#1925) |
| * Changed case convention for feature names (#1937) |
| * Added `executor` feature (#1949) |
| * Moved `copy_into`/`copy_buf_into` (#1948) |
| * Changed `SinkExt::send_all` to accept a `TryStream` (#1946) |
| * Removed `ThreadPool::run` (#1944) |
| * Changed to use our own definition of `io::Cursor` (#1943) |
| * Removed `BufReader::poll_seek_relative` (#1938) |
| * Changed `skip` to take a `usize` rather than `u64` (#1931) |
| * Removed `Stream` impl for `VecDeque` (#1930) |
| * Renamed `Peekable::peek` to `poll_peek` (#1928) |
| * Added immutable iterators for `FuturesUnordered` (#1922) |
| * Made `ThreadPool` optional (#1910) |
| * Renamed `oneshot::Sender::poll_cancel` to `poll_canceled` (#1908) |
| * Added some missing `Clone` implementations |
| * Documentation fixes |
| |
| # 0.3.0-alpha.19 - 2019-09-25 |
| |
| * Stabilized the `async-await` feature (#1816) |
| * Made `async-await` feature no longer require `std` feature (#1815) |
| * Updated `proc-macro2`, `syn`, and `quote` to 1.0 (#1798) |
| * Exposed unstable `BiLock` (#1827) |
| * Renamed "nightly" feature to "unstable" (#1823) |
| * Moved to our own `io::{Empty, Repeat, Sink}` (#1829) |
| * Made `AsyncRead::initializer` API unstable (#1845) |
| * Moved the `Never` type from `futures-core` to `futures-util` (#1836) |
| * Fixed use-after-free on panic in `ArcWake::wake_by_ref` (#1797) |
| * Added `AsyncReadExt::chain` (#1810) |
| * Added `Stream::size_hint` (#1853) |
| * Added some missing `FusedFuture` (#1868) and `FusedStream` implementations (#1831) |
| * Added a `From` impl for `Mutex` (#1839) |
| * Added `Mutex::{get_mut, into_inner}` (#1839) |
| * Re-exported `TryConcat` and `TryFilter` (#1814) |
| * Lifted `Unpin` bound and implemented `AsyncBufRead` for `io::Take` (#1821) |
| * Lifted `Unpin` bounds on `get_pin_mut` (#1820) |
| * Changed `SendAll` to flush the `Sink` when the source `Stream` is pending (#1877) |
| * Set default threadpool size to one if `num_cpus::get()` returns zero (#1835) |
| * Removed dependency on `rand` by using our own PRNG (#1837) |
| * Removed `futures-core` dependency from `futures-sink` (#1832) |
| |
| # 0.3.0-alpha.18 - 2019-08-09 |
| |
| * Rewrote `join!` and `try_join!` as procedural macros to allow passing expressions (#1783) |
| * Banned manual implementation of `TryFuture` and `TryStream` for forward compatibility. See #1776 for more details. (#1777) |
| * Changed `AsyncReadExt::read_to_end` to return the total number of bytes read (#1721) |
| * Changed `ArcWake::into_waker` to a free function `waker` (#1676) |
| * Supported trailing commas in macros (#1733) |
| * Removed futures-channel dependency from futures-executor (#1735) |
| * Supported `channel::oneshot` in no_std environment (#1749) |
| * Added `Future` bounds to `FusedFuture` (#1779) |
| * Added `Stream` bounds to `FusedStream` (#1779) |
| * Changed `StreamExt::boxed` to return `BoxStream` (#1780) |
| * Added `StreamExt::boxed_local` (#1780) |
| * Added `AsyncReadExt::read_to_string` (#1721) |
| * Implemented `AsyncWrite` for `IntoAsyncRead` (#1734) |
| * Added get_ref, get_mut and into_inner methods to `Compat01As03` and `Compat01As03Sink` (#1705) |
| * Added `ThreadPool::{spawn_ok, spawn_obj_ok}` (#1750) |
| * Added `TryStreamExt::try_flatten` (#1731) |
| * Added `FutureExt::now_or_never` (#1747) |
| |
| # 0.3.0-alpha.17 - 2019-07-03 |
| |
| * Removed `try_ready!` macro in favor of `ready!(..)?`. (#1602) |
| * Removed `io::Window::{set_start, set_end}` in favor of `io::Window::set`. (#1667) |
| * Re-exported `pin_utils::pin_mut!` macro. (#1686) |
| * Made all extension traits unnamed in the prelude. (#1662) |
| * Allowed `?Sized` types in some methods and structs. (#1647) |
| * Added `Send + Sync` bounds to `ArcWake` trait to fix unsoundness. (#1654) |
| * Changed `AsyncReadExt::copy_into` to consume `self`. (#1674) |
| * Renamed `future::empty` to `pending`. (#1689) |
| * Added `#[must_use]` to some combinators. (#1600) |
| * Added `AsyncWriteExt::{write, write_vectored}`. (#1612) |
| * Added `AsyncReadExt::read_vectored`. (#1612) |
| * Added `TryFutureExt::try_poll_unpin`. (#1613) |
| * Added `TryFutureExt::try_flatten_stream`. (#1618) |
| * Added `io::BufWriter`. (#1608) |
| * Added `Sender::same_receiver` and `UnboundedSender::same_receiver`. (#1617) |
| * Added `future::try_select`. (#1622) |
| * Added `TryFutureExt::{inspect_ok, inspect_err}`. (#1630) |
| * Added `Compat::get_ref`. (#1648) |
| * Added `io::Window::set`. (#1667) |
| * Added `AsyncWriteExt::into_sink`. (#1675) |
| * Added `AsyncBufReadExt::copy_buf_into`. (#1674) |
| * Added `stream::pending`. (#1689) |
| * Implemented `std::error::Error` for `SpawnError`. (#1604) |
| * Implemented `Stream` for `FlattenSink`. (#1651) |
| * Implemented `Sink` for `TryFlattenStream`. (#1651) |
| * Implemented `AsyncRead`, `AsyncWrite`, `AsyncSeek`, `AsyncBufRead`, `FusedFuture` and `FusedStream` for Either. (#1695) |
| * Replaced empty enums with `Never` type, an alias for `core::convert::Infallible`. |
| * Removed the `futures-channel` dependency from `futures-sink` and make `futures-sink` |
| an optional dependency of `futures-channel`. |
| * Renamed `Sink::SinkError` to `Sink::Error`. |
| * Made a number of dependencies of `futures-util` optional. |
| |
| # 0.3.0-alpha.16 - 2019-05-10 |
| |
| * Updated to new nightly `async_await`. |
| * Changed `AsyncRead::poll_vectored_read` and `AsyncWrite::poll_vectored_write` to use |
| stabilized `std::io::{IoSlice, IoSliceMut}` instead of `iovec::IoVec`, and renamed to |
| `AsyncRead::poll_read_vectored` and `AsyncWrite::poll_write_vectored`. |
| * Added `LocalBoxFuture` and `FutureExt::boxed_local`. |
| * Added `TryStreamExt::{try_filter, inspect_ok, inspect_err}`. |
| * Added `try_future::select_ok`. |
| * Added `AsyncBufReadExt::{read_line, lines}`. |
| * Added `io::BufReader`. |
| |
| # 0.3.0-alpha.15 - 2019-04-26 |
| |
| * Updated to stabilized `futures_api`. |
| * Removed `StreamObj`, cautioned against usage of `FutureObj`. |
| * Changed `StreamExt::select` to a function. |
| * Added `AsyncBufRead` and `AsyncSeek` traits. |
| * Expanded trait impls to include more pinned pointers and ?Sized types. |
| * Added `future::Fuse::terminated` constructor. |
| * Added `never_error` combinator. |
| * Added `StreamExt::enumerate`. |
| * Re-added `TryStreamExt::{and_then, or_else}`. |
| * Added functions to partially progress a local pool. |
| * Changed to use our own `Either` type rather than the one from the `either` crate. |
| |
| # 0.3.0-alpha.14 - 2019-04-15 |
| |
| * Updated to new nightly `futures_api`. |
| * Changed `Forward` combinator to drop sink after completion, and allow `!Unpin` `Sink`s. |
| * Added 0.1 <-> 0.3 compatibility shim for `Sink`s. |
| * Changed `Sink::Item` to a generic parameter `Sink<Item>`, allowing `Sink`s to accept |
| multiple different types, including types containing references. |
| * Changed `AsyncRead` and `AsyncWrite` to take `Pin<&mut Self>` rather than `&mut self`. |
| * Added support for `no_std` + `alloc` use. |
| * Changed `join` and `try_join` combinators to functions. |
| * Fixed propagation of `cfg-target-has-atomic` feature. |
| |
| # 0.3.0-alpha.13 - 2019-02-20 |
| |
| * Updated to new nightly with stabilization candidate API. |
| * Removed `LocalWaker`. |
| * Added `#[must_use]` to `Stream` and `Sink` traits. |
| * Enabled using `!Unpin` futures in `JoinAll`. |
| * Added the `try_join_all` combinator. |
| * Stopped closing a whole channel upon closing of one sender. |
| * Removed `TokioDefaultSpawner` and `tokio-compat`. |
| * Moved intra-crate dependencies to exact versions. |
| |
| # 0.3.0-alpha.12 - 2019-01-14 |
| |
| * Updated to new nightly with a modification to `Pin::set`. |
| * Expose `AssertUnmoved` and `PendingOnce`. |
| * Prevent double-panic in `AssertUnmoved`. |
| * Support nested invocations of the `select!` macro. |
| * Implement `Default` for `Mutex` and `SelectAll`. |
| |
| # 0.3.0-alpha.11 - 2018-12-27 |
| |
| * Updated to newly stabilized versions of the `pin` and `arbitrary_self_types` features. |
| * Re-added `select_all` for streams. |
| * Added `TryStream::into_async_read` for converting from a stream of bytes into |
| an `AsyncRead`. |
| * Added `try_poll_next_unpin`. |
| * Rewrote `select!` as a procedural macro for better error messages |
| * Exposed `join_all` from the facade |
| |
| # 0.3.0-alpha.10 - 2018-11-27 |
| |
| * Revamped `select!` macro |
| * Added `select_next_some` method for getting only the `Some` elements of a stream from `select!` |
| * Added `futures::lock::Mutex` for async-aware synchronization. |
| * Fixed bug converting `Pin<Box<_>>` to `StreamObj` |
| * Improved performance of futures::channel |
| * Improved performance and documentation of `Shared` |
| * Add `new` method and more `derive`s to the `Compat` type |
| * Enabled spawning on a borrowed threadpool |
| * Re-added `join_all` |
| * Added `try_concat` |
| |
| # 0.3.0-alpha.9 - 2018-10-18 |
| |
| * Fixed in response to new nightly handling of 2018 edition + `#![no_std]` |
| |
| # 0.3.0-alpha.8 - 2018-10-16 |
| |
| * Fixed stack overflow in 0.1 compatibility layer |
| * Added AsyncRead / AsyncWrite compatibility layer |
| * Added Spawn -> 0.1 Executor compatibility |
| * Made 0.1 futures usable on 0.3 executors without an additional global `Task`, accomplished by wrapping 0.1 futures in an 0.1 `Spawn` when using them as 0.3 futures. |
| * Cleanups and improvements to the `AtomicWaker` implementation. |
| |
| # 0.3.0-alpha.7 - 2018-10-01 |
| |
| * Update to new nightly which removes `Spawn` from `task::Context` and replaces `Context` with `LocalWaker`. |
| * Add `Spawn` and `LocalSpawn` traits and `FutureObj` and `LocalFutureObj` types to `futures-core`. |
| |
| # 0.3.0-alpha.6 - 2018-09-10 |
| |
| * Replace usage of `crate` visibility with `pub(crate)` now that `crate` visibility is no longer included in the 2018 edition |
| * Remove newly-stabilized "edition" feature in Cargo.toml files |
| |
| # 0.3.0-alpha.5 - 2018-09-03 |
| |
| * Revert usage of cargo crate renaming feature |
| |
| # 0.3.0-alpha.4 - 2018-09-02 |
| |
| **Note: This release does not work, use `0.3.0-alpha.5` instead** |
| |
| * `future::ok` and `future:err` to create result wrapping futures (similar to `future::ready`) |
| * `futures-test` crate with testing utilities |
| * `StreamExt::boxed` combinator |
| * Unsoundness fix for `FuturesUnordered` |
| * `StreamObj` (similar to `FutureObj`) |
| * Code examples for compatibility layer functions |
| * Use cargo create renaming feature to import `futures@0.1` for compatibility layer |
| * Import pinning APIs from `core::pin` |
| * Run Clippy in CI only when it is available |
| |
| # 0.3.0-alpha.3 - 2018-08-15 |
| |
| * Compatibility with newest nightly |
| * Futures 0.1 compatibility layer including Tokio compatibility |
| * Added `spawn!` and `spawn_with_handle!` macros |
| * Added `SpawnExt` methods `spawn` and `spawn_with_handle` |
| * Extracted pin macros into `pin_utils` crate |
| * Added `FutureExt` combinators `boxed` and `unit_error` |
| * Remove prelude from all doc examples (The prelude is still recommended for usage in playground examples. However, for doc examples we determined that fully expanded imports are more helpful) |
| * Improvements to `select!` and `join!` macros |
| * Added `try_join!` macro |
| * Added `StreamExt` combinator methods `try_join` and `for_each_concurrent` |
| * Added `TryStreamExt` combinator methods `into_stream`, `try_filter_map`, `try_skip_while`, `try_for_each_concurrent` and `try_buffer_unordered` |
| * Fix stream termination bug in `StreamExt::buffered` and `StreamExt::buffer_unordered` |
| * Added docs for `StreamExt::buffered`, `StreamExt::buffer_unordered` |
| * Added `task::local_waker_ref_from_nonlocal` and `task::local_waker_ref` functions |
| * CI improvements |
| * Doc improvements to `StreamExt::select` |
| |
| # 0.3.0-alpha.2 - 2018-07-30 |
| |
| * The changelog is back! |
| * Compatibility with futures API in latest nightly |
| * Code examples and doc improvements |
| * IO: Methods of traits `AsyncReadExt`, `AsyncWriteExt` |
| * Future: |
| * Methods of trait `TryFutureExt` |
| * Free functions `empty`, `lazy`, `maybe_done`, `poll_fn` and `ready` |
| * Type `FutureOption` |
| * Macros `join!`, `select!` and `pending!` |
| * Stream: Methods of trait `TryStreamExt` |
| * Added `TryStreamExt` combinators `map_ok`, `map_err`, `err_into`, `try_next` and `try_for_each` |
| * Added `Drain`, a sink that will discard all items given to it. Can be created using the `drain` function |
| * Bugfix for the `write_all` combinator |
| * `AsyncWrite` impl for `Cursor<T: AsMut<[u8]>>` |
| * `FuturesUnordered` optimization: Since the context stores a `&LocalWaker` reference, it was possible to avoid cloning the `Arc` of the waker |
| * Futures-rs now uses Clippy |
| * We now use in-band lifetimes |
| * The `join!` and `select!` macros are now exposed by the `futures` crate |
| * The project logo was added to the `README.md` |
| * `sink::MapErr::get_pinned_mut` is now called `get_pin_mut` |
| * We now use the unstable `use_extern_macros` feature for macro reexports |
| * CI improvements: Named CI jobs, tests are now run on macOS and Linux, the docs are generated and Clippy needs to pass |
| * `#[deny(warnings)]` was removed from all crates and is now only enforced in the CI |
| * We now have a naming convention for type parameters: `Fut` future, `F` function, `St` stream, `Si` sink, `S` sink & stream, `R` reader, `W` writer, `T` value, `E` error |
| * "Task" is now defined as our term for "lightweight thread". The code of the executors and `FuturesUnordered` was refactored to align with this definition. |
| |
| # 0.3.0-alpha.1 - 2018-07-19 |
| |
| * Major changes: See [the announcement](https://rust-lang-nursery.github.io/futures-rs/blog/2018/07/19/futures-0.3.0-alpha.1.html) on our new blog for details. The changes are too numerous to be covered in this changelog because nearly every line of code was modified. |
| |
| # 0.1.17 - 2017-10-31 |
| |
| * Add a `close` method on `sink::Wait` |
| * Undeprecate `stream::iter` as `stream::iter_result` |
| * Improve performance of wait-related methods |
| * Tweak buffered sinks with a 0 capacity to forward directly to the underlying |
| sink. |
| * Add `FromIterator` implementation for `FuturesOrdered` and `FuturesUnordered`. |
| |
| # 0.1.16 - 2017-09-15 |
| |
| * A `prelude` module has been added to glob import from and pick up a whole |
| bunch of useful types |
| * `sync::mpsc::Sender::poll_ready` has been added as an API |
| * `sync::mpsc::Sender::try_send` has been added as an API |
| |
| # 0.1.15 - 2017-08-24 |
| |
| * Improve performance of `BiLock` methods |
| * Implement `Clone` for `FutureResult` |
| * Forward `Stream` trait through `SinkMapErr` |
| * Add `stream::futures_ordered` next to `futures_unordered` |
| * Reimplement `Stream::buffered` on top of `stream::futures_ordered` (much more |
| efficient at scale). |
| * Add a `with_notify` function for abstractions which previously required |
| `UnparkEvent`. |
| * Add `get_ref`/`get_mut`/`into_inner` functions for stream take/skip methods |
| * Add a `Clone` implementation for `SharedItem` and `SharedError` |
| * Add a `mpsc::spawn` function to spawn a `Stream` into an `Executor` |
| * Add a `reunite` function for `BiLock` and the split stream/sink types to |
| rejoin two halves and reclaim the original item. |
| * Add `stream::poll_fn` to behave similarly to `future::poll_fn` |
| * Add `Sink::with_flat_map` like `Iterator::flat_map` |
| * Bump the minimum Rust version to 1.13.0 |
| * Expose `AtomicTask` in the public API for managing synchronization around task |
| notifications. |
| * Unify the `Canceled` type of the `sync` and `unsync` modules. |
| * Deprecate the `boxed` methods. These methods have caused more confusion than |
| they've solved historically, so it's recommended to use a local extension |
| trait or a local helper instead of the trait-based methods. |
| * Deprecate the `Stream::merge` method as it's less ergonomic than `select`. |
| * Add `oneshot::Sender::is_canceled` to test if a oneshot is canceled off a |
| task. |
| * Deprecates `UnboundedSender::send` in favor of a method named `unbounded_send` |
| to avoid a conflict with `Sink::send`. |
| * Deprecate the `stream::iter` function in favor of an `stream::iter_ok` adaptor |
| to avoid the need to deal with `Result` manually. |
| * Add an `inspect` function to the `Future` and `Stream` traits along the lines |
| of `Iterator::inspect` |
| |
| # 0.1.14 - 2017-05-30 |
| |
| This is a relatively large release of the `futures` crate, although much of it |
| is from reworking internals rather than new APIs. The banner feature of this |
| release is that the `futures::{task, executor}` modules are now available in |
| `no_std` contexts! A large refactoring of the task system was performed in |
| PR #436 to accommodate custom memory allocation schemes and otherwise remove |
| all dependencies on `std` for the task module. More details about this change |
| can be found on the PR itself. |
| |
| Other API additions in this release are: |
| |
| * A `FuturesUnordered::push` method was added and the `FuturesUnordered` type |
| itself was completely rewritten to efficiently track a large number of |
| futures. |
| * A `Task::will_notify_current` method was added with a slightly different |
| implementation than `Task::is_current` but with stronger guarantees and |
| documentation wording about its purpose. |
| * Many combinators now have `get_ref`, `get_mut`, and `into_inner` methods for |
| accessing internal futures and state. |
| * A `Stream::concat2` method was added which should be considered the "fixed" |
| version of `concat`, this one doesn't panic on empty streams. |
| * An `Executor` trait has been added to represent abstracting over the concept |
| of spawning a new task. Crates which only need the ability to spawn a future |
| can now be generic over `Executor` rather than requiring a |
| `tokio_core::reactor::Handle`. |
| |
| As with all 0.1.x releases this PR is intended to be 100% backwards compatible. |
| All code that previously compiled should continue to do so with these changes. |
| As with other changes, though, there are also some updates to be aware of: |
| |
| * The `task::park` function has been renamed to `task::current`. |
| * The `Task::unpark` function has been renamed to `Task::notify`, and in general |
| terminology around "unpark" has shifted to terminology around "notify" |
| * The `Unpark` trait has been deprecated in favor of the `Notify` trait |
| mentioned above. |
| * The `UnparkEvent` structure has been deprecated. It currently should perform |
| the same as it used to, but it's planned that in a future 0.1.x release the |
| performance will regress for crates that have not transitioned away. The |
| primary primitive to replace this is the addition of a `push` function on the |
| `FuturesUnordered` type. If this does not help implement your use case though, |
| please let us know! |
| * The `Task::is_current` method is now deprecated, and you likely want to use |
| `Task::will_notify_current` instead, but let us know if this doesn't suffice! |
| |
| # 0.1.13 - 2017-04-05 |
| |
| * Add forwarding sink/stream impls for `stream::FromErr` and `sink::SinkFromErr` |
| * Add `PartialEq` and `Eq` to `mpsc::SendError` |
| * Reimplement `Shared` with `spawn` instead of `UnparkEvent` |
| |
| # 0.1.12 - 2017-04-03 |
| |
| * Add `Stream::from_err` and `Sink::from_err` |
| * Allow `SendError` to be `Clone` when possible |
| |
| # 0.1.11 - 2017-03-13 |
| |
| The major highlight of this release is the addition of a new "default" method on |
| the `Sink` trait, `Sink::close`. This method is used to indicate to a sink that |
| no new values will ever need to get pushed into it. This can be used to |
| implement graceful shutdown of protocols and otherwise simply indicates to a |
| sink that it can start freeing up resources. |
| |
| Currently this method is **not** a default method to preserve backwards |
| compatibility, but it's intended to become a default method in the 0.2 series of |
| the `futures` crate. It's highly recommended to audit implementations of `Sink` |
| to implement the `close` method as is fit. |
| |
| Other changes in this release are: |
| |
| * A new select combinator, `Future::select2` was added for a heterogeneous |
| select. |
| * A `Shared::peek` method was added to check to see if it's done. |
| * `Sink::map_err` was implemented |
| * The `log` dependency was removed |
| * Implementations of the `Debug` trait are now generally available. |
| * The `stream::IterStream` type was renamed to `stream::Iter` (with a reexport |
| for the old name). |
| * Add a `Sink::wait` method which returns an adapter to use an arbitrary `Sink` |
| synchronously. |
| * A `Stream::concat` method was added to concatenate a sequence of lists. |
| * The `oneshot::Sender::complete` method was renamed to `send` and now returns a |
| `Result` indicating successful transmission of a message or not. Note that the |
| `complete` method still exists, it's just deprecated. |
| |
| # 0.1.10 - 2017-01-30 |
| |
| * Add a new `unsync` module which mirrors `sync` to the extent that it can but |
| is intended to not perform cross-thread synchronization (only usable within |
| one thread). |
| * Tweak `Shared` to work when handles may not get poll'd again. |
| |
| # 0.1.9 - 2017-01-18 |
| |
| * Fix `Send/Sync` of a few types |
| * Add `future::tail_fn` for more easily writing loops |
| * Export SharedItem/SharedError |
| * Remove an unused type parameter in `from_err` |
| |
| # 0.1.8 - 2017-01-11 |
| |
| * Fix some race conditions in the `Shared` implementation |
| * Add `Stream::take_while` |
| * Fix an unwrap in `stream::futures_unordered` |
| * Generalize `Stream::for_each` |
| * Add `Stream::chain` |
| * Add `stream::repeat` |
| * Relax `&mut self` to `&self` in `UnboundedSender::send` |
| |
| # 0.1.7 - 2016-12-18 |
| |
| * Add a `Future::shared` method for creating a future that can be shared |
| amongst threads by cloning the future itself. All derivative futures |
| will resolve to the same value once the original future has been |
| resolved. |
| * Add a `FutureFrom` trait for future-based conversion |
| * Fix a wakeup bug in `Receiver::close` |
| * Add `future::poll_fn` for quickly adapting a `Poll`-based function to |
| a future. |
| * Add an `Either` enum with two branches to easily create one future |
| type based on two different futures created on two branches of control |
| flow. |
| * Remove the `'static` bound on `Unpark` |
| * Optimize `send_all` and `forward` to send as many items as possible |
| before calling `poll_complete`. |
| * Unify the return types of the `ok`, `err`, and `result` future to |
| assist returning different varieties in different branches of a function. |
| * Add `CpuFuture::forget` to allow the computation to continue running |
| after a drop. |
| * Add a `stream::futures_unordered` combinator to turn a list of futures |
| into a stream representing their order of completion. |
| |
| # 0.1.6 - 2016-11-22 |
| |
| * Fix `Clone` bound on the type parameter on `UnboundedSender` |
| |
| # 0.1.5 - 2016-11-22 |
| |
| * Fix `#![no_std]` support |
| |
| # 0.1.4 - 2016-11-22 |
| |
| This is quite a large release relative to the previous point releases! As |
| with all 0.1 releases, this release should be fully compatible with the 0.1.3 |
| release. If any incompatibilities are discovered please file an issue! |
| |
| The largest changes in 0.1.4 are the addition of a `Sink` trait coupled with a |
| reorganization of this crate. Note that all old locations for types/traits |
| still exist, they're just deprecated and tagged with `#[doc(hidden)]`. |
| |
| The new `Sink` trait is used to represent types which can periodically over |
| time accept items, but may take some time to fully process the item before |
| another can be accepted. Essentially, a sink is the opposite of a stream. This |
| trait will then be used in the tokio-core crate to implement simple framing by |
| modeling I/O streams as both a stream and a sink of frames. |
| |
| The organization of this crate is to now have three primary submodules, |
| `future`, `stream`, and `sink`. The traits as well as all combinator types are |
| defined in these submodules. The traits and types like `Async` and `Poll` are |
| then reexported at the top of the crate for convenient usage. It should be a |
| relatively rare occasion that the modules themselves are reached into. |
| |
| Finally, the 0.1.4 release comes with a new module, `sync`, in the futures |
| crate. This is intended to be the home of a suite of futures-aware |
| synchronization primitives. Currently this is inhabited with a `oneshot` module |
| (the old `oneshot` function), a `mpsc` module for a new multi-producer |
| single-consumer channel, and a `BiLock` type which represents sharing ownership |
| of one value between two consumers. This module may expand over time with more |
| types like a mutex, rwlock, spsc channel, etc. |
| |
| Notable deprecations in the 0.1.4 release that will be deleted in an eventual |
| 0.2 release: |
| |
| * The `TaskRc` type is now deprecated in favor of `BiLock` or otherwise `Arc` |
| sharing. |
| * All future combinators should be accessed through the `future` module, not |
| the top-level of the crate. |
| * The `Oneshot` and `Complete` types are now replaced with the `sync::oneshot` |
| module. |
| * Some old names like `collect` are deprecated in favor of more appropriately |
| named versions like `join_all` |
| * The `finished` constructor is now `ok`. |
| * The `failed` constructor is now `err`. |
| * The `done` constructor is now `result`. |
| |
| As always, please report bugs to https://github.com/rust-lang-nursery/futures-rs and |
| we always love feedback! If you've got situations we don't cover, combinators |
| you'd like to see, or slow code, please let us know! |
| |
| Full changelog: |
| |
| * Improve scalability of `buffer_unordered` combinator |
| * Fix a memory ordering bug in oneshot |
| * Add a new trait, `Sink` |
| * Reorganize the crate into three primary modules |
| * Add a new `sync` module for synchronization primitives |
| * Add a `BiLock` sync primitive for two-way sharing |
| * Deprecate `TaskRc` |
| * Rename `collect` to `join_all` |
| * Use a small vec in `Events` for improved clone performance |
| * Add `Stream::select` for selecting items from two streams like `merge` but |
| requiring the same types. |
| * Add `stream::unfold` constructor |
| * Add a `sync::mpsc` module with a futures-aware multi-producer single-consumer |
| queue. Both bounded (with backpressure) and unbounded (no backpressure) |
| variants are provided. |
| * Renamed `failed`, `finished`, and `done` combinators to `err`, `ok`, and |
| `result`. |
| * Add `Stream::forward` to send all items to a sink, like `Sink::send_all` |
| * Add `Stream::split` for streams which are both sinks and streams to have |
| separate ownership of the stream/sink halves |
| * Improve `join_all` with concurrency |
| |
| # 0.1.3 - 2016-10-24 |
| |
| * Rewrite `oneshot` for efficiency and removing allocations on send/recv |
| * Errors are passed through in `Stream::take` and `Stream::skip` |
| * Add a `select_ok` combinator to pick the first of a list that succeeds |
| * Remove the unnecessary `SelectAllNext` typedef |
| * Add `Stream::chunks` for receiving chunks of data |
| * Rewrite `stream::channel` for efficiency, correctness, and removing |
| allocations |
| * Remove `Send + 'static` bounds on the `stream::Empty` type |
| |
| # 0.1.2 - 2016-10-04 |
| |
| * Fixed a bug in drop of `FutureSender` |
| * Expose the channel `SendError` type |
| * Add `Future::into_stream` to convert to a single-element stream |
| * Add `Future::flatten_to_stream` to convert a future of a stream to a stream |
| * impl Debug for SendError |
| * Add stream::once for a one element stream |
| * Accept IntoIterator in stream::iter |
| * Add `Stream::catch_unwind` |
| |
| # 0.1.1 - 2016-09-09 |
| |
| Initial release! |
