close
method on sink::Wait
stream::iter
as stream::iter_result
FromIterator
implementation for FuturesOrdered
and FuturesUnordered
.prelude
module has been added to glob import from and pick up a whole bunch of useful typessync::mpsc::Sender::poll_ready
has been added as an APIsync::mpsc::Sender::try_send
has been added as an APIBiLock
methodsClone
for FutureResult
Stream
trait through SinkMapErr
stream::futures_ordered
next to futures_unordered
Stream::buffered
on top of stream::futures_ordered
(much more efficient at scale).with_notify
function for abstractions which previously required UnparkEvent
.get_ref
/get_mut
/into_inner
functions for stream take/skip methodsClone
implementation for SharedItem
and SharedError
mpsc::spawn
function to spawn a Stream
into an Executor
reunite
function for BiLock
and the split stream/sink types to rejoin two halves and reclaim the original item.stream::poll_fn
to behave similarly to future::poll_fn
Sink::with_flat_map
like Iterator::flat_map
AtomicTask
in the public API for managing synchronization around task notifications.Canceled
type of the sync
and unsync
modules.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.Stream::merge
method as it's less ergonomic than select
.oneshot::Sender::is_canceled
to test if a oneshot is canceled off a task.UnboundedSender::send
in favor of a method named unbounded_send
to avoid a conflict with Sink::send
.stream::iter
function in favor of an stream::iter_ok
adaptor to avoid the need to deal with Result
manually.inspect
function to the Future
and Stream
traits along the lines of Iterator::inspect
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:
FuturesUnordered::push
method was added and the FuturesUnordered
type itself was completely rewritten to efficiently track a large number of futures.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.get_ref
, get_mut
, and into_inner
methods for accessing internal futures and state.Stream::concat2
method was added which should be considered the “fixed” version of concat
, this one doesn't panic on empty streams.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:
task::park
function has been renamed to task::current
.Task::unpark
function has been renamed to Task::notify
, and in general terminology around “unpark” has shifted to terminology around “notify”Unpark
trait has been deprecated in favor of the Notify
trait mentioned above.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!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!stream::FromErr
and sink::SinkFromErr
PartialEq
and Eq
to mpsc::SendError
Shared
with spawn
instead of UnparkEvent
Stream::from_err
and Sink::from_err
SendError
to be Clone
when possibleThe 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:
Future::select2
was added for a heterogeneous select.Shared::peek
method was added to check to see if it's done.Sink::map_err
was implementedlog
dependency was removedDebug
trait are now generally available.stream::IterStream
type was renamed to stream::Iter
(with a reexport for the old name).Sink::wait
method which returns an adapter to use an arbitrary Sink
synchronously.Stream::concat
method was added to concatenate a sequence of lists.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.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).Shared
to work when handles may not get poll'd again.Send/Sync
of a few typesfuture::tail_fn
for more easily writing loopsfrom_err
Shared
implementationStream::take_while
stream::futures_unordered
Stream::for_each
Stream::chain
stream::repeat
&mut self
to &self
in UnboundedSender::send
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.FutureFrom
trait for future-based conversionReceiver::close
future::poll_fn
for quickly adapting a Poll
-based function to a future.Either
enum with two branches to easily create one future type based on two different futures created on two branches of control flow.'static
bound on Unpark
send_all
and forward
to send as many items as possible before calling poll_complete
.ok
, err
, and result
future to assist returning different varieties in different branches of a function.CpuFuture::forget
to allow the computation to continue running after a drop.stream::futures_unordered
combinator to turn a list of futures into a stream representing their order of completion.Clone
bound on the type parameter on UnboundedSender
#![no_std]
supportThis 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:
TaskRc
type is now deprecated in favor of BiLock
or otherwise Arc
sharing.future
module, not the top-level of the crate.Oneshot
and Complete
types are now replaced with the sync::oneshot
module.collect
are deprecated in favor of more appropriately named versions like join_all
finished
constructor is now ok
.failed
constructor is now err
.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:
buffer_unordered
combinatorSink
sync
module for synchronization primitivesBiLock
sync primitive for two-way sharingTaskRc
collect
to join_all
Events
for improved clone performanceStream::select
for selecting items from two streams like merge
but requiring the same types.stream::unfold
constructorsync::mpsc
module with a futures-aware multi-producer single-consumer queue. Both bounded (with backpressure) and unbounded (no backpressure) variants are provided.failed
, finished
, and done
combinators to err
, ok
, and result
.Stream::forward
to send all items to a sink, like Sink::send_all
Stream::split
for streams which are both sinks and streams to have separate ownership of the stream/sink halvesjoin_all
with concurrencyoneshot
for efficiency and removing allocations on send/recvStream::take
and Stream::skip
select_ok
combinator to pick the first of a list that succeedsSelectAllNext
typedefStream::chunks
for receiving chunks of datastream::channel
for efficiency, correctness, and removing allocationsSend + 'static
bounds on the stream::Empty
typeFutureSender
SendError
typeFuture::into_stream
to convert to a single-element streamFuture::flatten_to_stream
to convert a future of a stream to a streamStream::catch_unwind
Initial release!