Struct futures::stream::futures_unordered::FuturesUnordered
source · [−]pub struct FuturesUnordered<Fut> { /* private fields */ }Expand description
A set of futures which may complete in any order.
This structure is optimized to manage a large number of futures.
Futures managed by FuturesUnordered will only be polled when they
generate wake-up notifications. This reduces the required amount of work
needed to poll large numbers of futures.
FuturesUnordered can be filled by collecting an
iterator of futures into a FuturesUnordered, or by
pushing futures onto an existing
FuturesUnordered. When new futures are added,
poll_next must be called in order to begin receiving
wake-ups for new futures.
Note that you can create a ready-made FuturesUnordered via the
collect method, or you can start with an empty set
with the FuturesUnordered::new constructor.
This type is only available when the std or alloc feature of this
library is activated, and it is activated by default.
Implementations
sourceimpl<Fut> FuturesUnordered<Fut>
impl<Fut> FuturesUnordered<Fut>
sourcepub fn new() -> FuturesUnordered<Fut>
pub fn new() -> FuturesUnordered<Fut>
Constructs a new, empty FuturesUnordered.
The returned FuturesUnordered does not contain any futures.
In this state, FuturesUnordered::poll_next will
return Poll::Ready(None).
sourcepub fn len(&self) -> usize
pub fn len(&self) -> usize
Returns the number of futures contained in the set.
This represents the total number of in-flight futures.
sourcepub fn push(&self, future: Fut)
pub fn push(&self, future: Fut)
Push a future into the set.
This method adds the given future to the set. This method will not
call poll on the submitted future. The caller must
ensure that FuturesUnordered::poll_next is called
in order to receive wake-up notifications for the given future.
sourcepub fn iter(&self) -> Iter<'_, Fut>ⓘNotable traits for Iter<'a, Fut>impl<'a, Fut> Iterator for Iter<'a, Fut> where
Fut: Unpin, type Item = &'a Fut; where
Fut: Unpin,
pub fn iter(&self) -> Iter<'_, Fut>ⓘNotable traits for Iter<'a, Fut>impl<'a, Fut> Iterator for Iter<'a, Fut> where
Fut: Unpin, type Item = &'a Fut; where
Fut: Unpin,
Fut: Unpin, type Item = &'a Fut;
Returns an iterator that allows inspecting each future in the set.
sourcepub fn iter_pin_ref(self: Pin<&FuturesUnordered<Fut>>) -> IterPinRef<'_, Fut>ⓘNotable traits for IterPinRef<'a, Fut>impl<'a, Fut> Iterator for IterPinRef<'a, Fut> type Item = Pin<&'a Fut>;
pub fn iter_pin_ref(self: Pin<&FuturesUnordered<Fut>>) -> IterPinRef<'_, Fut>ⓘNotable traits for IterPinRef<'a, Fut>impl<'a, Fut> Iterator for IterPinRef<'a, Fut> type Item = Pin<&'a Fut>;
Returns an iterator that allows inspecting each future in the set.
sourcepub fn iter_mut(&mut self) -> IterMut<'_, Fut>ⓘNotable traits for IterMut<'a, Fut>impl<'a, Fut> Iterator for IterMut<'a, Fut> where
Fut: Unpin, type Item = &'a mut Fut; where
Fut: Unpin,
pub fn iter_mut(&mut self) -> IterMut<'_, Fut>ⓘNotable traits for IterMut<'a, Fut>impl<'a, Fut> Iterator for IterMut<'a, Fut> where
Fut: Unpin, type Item = &'a mut Fut; where
Fut: Unpin,
Fut: Unpin, type Item = &'a mut Fut;
Returns an iterator that allows modifying each future in the set.
sourcepub fn iter_pin_mut(
self: Pin<&mut FuturesUnordered<Fut>>
) -> IterPinMut<'_, Fut>ⓘNotable traits for IterPinMut<'a, Fut>impl<'a, Fut> Iterator for IterPinMut<'a, Fut> type Item = Pin<&'a mut Fut>;
pub fn iter_pin_mut(
self: Pin<&mut FuturesUnordered<Fut>>
) -> IterPinMut<'_, Fut>ⓘNotable traits for IterPinMut<'a, Fut>impl<'a, Fut> Iterator for IterPinMut<'a, Fut> type Item = Pin<&'a mut Fut>;
Returns an iterator that allows modifying each future in the set.
sourceimpl<Fut> FuturesUnordered<Fut>
impl<Fut> FuturesUnordered<Fut>
Trait Implementations
sourceimpl<Fut> Debug for FuturesUnordered<Fut>
impl<Fut> Debug for FuturesUnordered<Fut>
sourceimpl<Fut> Default for FuturesUnordered<Fut>
impl<Fut> Default for FuturesUnordered<Fut>
sourcefn default() -> FuturesUnordered<Fut>
fn default() -> FuturesUnordered<Fut>
Returns the “default value” for a type. Read more
sourceimpl<Fut> Drop for FuturesUnordered<Fut>
impl<Fut> Drop for FuturesUnordered<Fut>
sourceimpl<Fut> Extend<Fut> for FuturesUnordered<Fut>
impl<Fut> Extend<Fut> for FuturesUnordered<Fut>
sourcefn extend<I>(&mut self, iter: I) where
I: IntoIterator<Item = Fut>,
fn extend<I>(&mut self, iter: I) where
I: IntoIterator<Item = Fut>,
Extends a collection with the contents of an iterator. Read more
sourcefn extend_one(&mut self, item: A)
fn extend_one(&mut self, item: A)
extend_one)Extends a collection with exactly one element.
sourcefn extend_reserve(&mut self, additional: usize)
fn extend_reserve(&mut self, additional: usize)
extend_one)Reserves capacity in a collection for the given number of additional elements. Read more
sourceimpl<Fut> FromIterator<Fut> for FuturesUnordered<Fut>
impl<Fut> FromIterator<Fut> for FuturesUnordered<Fut>
sourcefn from_iter<I>(iter: I) -> FuturesUnordered<Fut> where
I: IntoIterator<Item = Fut>,
fn from_iter<I>(iter: I) -> FuturesUnordered<Fut> where
I: IntoIterator<Item = Fut>,
Creates a value from an iterator. Read more
sourceimpl<Fut> FusedStream for FuturesUnordered<Fut> where
Fut: Future,
impl<Fut> FusedStream for FuturesUnordered<Fut> where
Fut: Future,
sourcefn is_terminated(&self) -> bool
fn is_terminated(&self) -> bool
Returns true if the stream should no longer be polled.
sourceimpl<Fut> IntoIterator for FuturesUnordered<Fut> where
Fut: Unpin,
impl<Fut> IntoIterator for FuturesUnordered<Fut> where
Fut: Unpin,
type Item = Fut
type Item = Fut
The type of the elements being iterated over.
sourcefn into_iter(self) -> <FuturesUnordered<Fut> as IntoIterator>::IntoIter
fn into_iter(self) -> <FuturesUnordered<Fut> as IntoIterator>::IntoIter
Creates an iterator from a value. Read more
sourceimpl<'a, Fut> IntoIterator for &'a FuturesUnordered<Fut> where
Fut: Unpin,
impl<'a, Fut> IntoIterator for &'a FuturesUnordered<Fut> where
Fut: Unpin,
sourcefn into_iter(self) -> <&'a FuturesUnordered<Fut> as IntoIterator>::IntoIter
fn into_iter(self) -> <&'a FuturesUnordered<Fut> as IntoIterator>::IntoIter
Creates an iterator from a value. Read more
sourceimpl<'a, Fut> IntoIterator for &'a mut FuturesUnordered<Fut> where
Fut: Unpin,
impl<'a, Fut> IntoIterator for &'a mut FuturesUnordered<Fut> where
Fut: Unpin,
sourcefn into_iter(self) -> <&'a mut FuturesUnordered<Fut> as IntoIterator>::IntoIter
fn into_iter(self) -> <&'a mut FuturesUnordered<Fut> as IntoIterator>::IntoIter
Creates an iterator from a value. Read more
sourceimpl<'_> LocalSpawn for FuturesUnordered<LocalFutureObj<'_, ()>>
impl<'_> LocalSpawn for FuturesUnordered<LocalFutureObj<'_, ()>>
sourcefn spawn_local_obj(
&self,
future_obj: LocalFutureObj<'static, ()>
) -> Result<(), SpawnError>
fn spawn_local_obj(
&self,
future_obj: LocalFutureObj<'static, ()>
) -> Result<(), SpawnError>
Spawns a future that will be run to completion. Read more
sourcefn status_local(&self) -> Result<(), SpawnError>
fn status_local(&self) -> Result<(), SpawnError>
Determines whether the executor is able to spawn new tasks. Read more
sourceimpl<'_> Spawn for FuturesUnordered<FutureObj<'_, ()>>
impl<'_> Spawn for FuturesUnordered<FutureObj<'_, ()>>
sourceimpl<Fut> Stream for FuturesUnordered<Fut> where
Fut: Future,
impl<Fut> Stream for FuturesUnordered<Fut> where
Fut: Future,
sourcefn poll_next(
self: Pin<&mut FuturesUnordered<Fut>>,
cx: &mut Context<'_>
) -> Poll<Option<<FuturesUnordered<Fut> as Stream>::Item>>
fn poll_next(
self: Pin<&mut FuturesUnordered<Fut>>,
cx: &mut Context<'_>
) -> Poll<Option<<FuturesUnordered<Fut> as Stream>::Item>>
Attempt to pull out the next value of this stream, registering the
current task for wakeup if the value is not yet available, and returning
None if the stream is exhausted. Read more
impl<Fut> Send for FuturesUnordered<Fut> where
Fut: Send,
impl<Fut> Sync for FuturesUnordered<Fut> where
Fut: Sync,
impl<Fut> Unpin for FuturesUnordered<Fut>
Auto Trait Implementations
impl<Fut> !RefUnwindSafe for FuturesUnordered<Fut>
impl<Fut> !UnwindSafe for FuturesUnordered<Fut>
Blanket Implementations
sourceimpl<T> BorrowMut<T> for T where
T: ?Sized,
impl<T> BorrowMut<T> for T where
T: ?Sized,
const: unstable · sourcefn borrow_mut(&mut self) -> &mut T
fn borrow_mut(&mut self) -> &mut T
Mutably borrows from an owned value. Read more
sourceimpl<Sp> LocalSpawnExt for Sp where
Sp: LocalSpawn + ?Sized,
impl<Sp> LocalSpawnExt for Sp where
Sp: LocalSpawn + ?Sized,
sourcefn spawn_local<Fut>(&self, future: Fut) -> Result<(), SpawnError> where
Fut: 'static + Future<Output = ()>,
fn spawn_local<Fut>(&self, future: Fut) -> Result<(), SpawnError> where
Fut: 'static + Future<Output = ()>,
Spawns a task that polls the given future with output () to
completion. Read more
sourcefn spawn_local_with_handle<Fut>(
&self,
future: Fut
) -> Result<RemoteHandle<<Fut as Future>::Output>, SpawnError> where
Fut: 'static + Future,
fn spawn_local_with_handle<Fut>(
&self,
future: Fut
) -> Result<RemoteHandle<<Fut as Future>::Output>, SpawnError> where
Fut: 'static + Future,
Spawns a task that polls the given future to completion and returns a future that resolves to the spawned future’s output. Read more
sourceimpl<Sp> SpawnExt for Sp where
Sp: Spawn + ?Sized,
impl<Sp> SpawnExt for Sp where
Sp: Spawn + ?Sized,
sourcefn spawn<Fut>(&self, future: Fut) -> Result<(), SpawnError> where
Fut: 'static + Future<Output = ()> + Send,
fn spawn<Fut>(&self, future: Fut) -> Result<(), SpawnError> where
Fut: 'static + Future<Output = ()> + Send,
Spawns a task that polls the given future with output () to
completion. Read more
sourcefn spawn_with_handle<Fut>(
&self,
future: Fut
) -> Result<RemoteHandle<<Fut as Future>::Output>, SpawnError> where
Fut: 'static + Future + Send,
<Fut as Future>::Output: Send,
fn spawn_with_handle<Fut>(
&self,
future: Fut
) -> Result<RemoteHandle<<Fut as Future>::Output>, SpawnError> where
Fut: 'static + Future + Send,
<Fut as Future>::Output: Send,
Spawns a task that polls the given future to completion and returns a future that resolves to the spawned future’s output. Read more
sourceimpl<T> StreamExt for T where
T: Stream + ?Sized,
impl<T> StreamExt for T where
T: Stream + ?Sized,
sourcefn next(&mut self) -> Next<'_, Self>ⓘNotable traits for Next<'_, St>impl<'_, St> Future for Next<'_, St> where
St: Stream + Unpin + ?Sized, type Output = Option<<St as Stream>::Item>; where
Self: Unpin,
fn next(&mut self) -> Next<'_, Self>ⓘNotable traits for Next<'_, St>impl<'_, St> Future for Next<'_, St> where
St: Stream + Unpin + ?Sized, type Output = Option<<St as Stream>::Item>; where
Self: Unpin,
St: Stream + Unpin + ?Sized, type Output = Option<<St as Stream>::Item>;
Creates a future that resolves to the next item in the stream. Read more
sourcefn into_future(self) -> StreamFuture<Self>ⓘNotable traits for StreamFuture<St>impl<St> Future for StreamFuture<St> where
St: Stream + Unpin, type Output = (Option<<St as Stream>::Item>, St); where
Self: Unpin,
fn into_future(self) -> StreamFuture<Self>ⓘNotable traits for StreamFuture<St>impl<St> Future for StreamFuture<St> where
St: Stream + Unpin, type Output = (Option<<St as Stream>::Item>, St); where
Self: Unpin,
St: Stream + Unpin, type Output = (Option<<St as Stream>::Item>, St);
sourcefn map<T, F>(self, f: F) -> Map<Self, F> where
F: FnMut(Self::Item) -> T,
fn map<T, F>(self, f: F) -> Map<Self, F> where
F: FnMut(Self::Item) -> T,
Maps this stream’s items to a different type, returning a new stream of the resulting type. Read more
sourcefn enumerate(self) -> Enumerate<Self>
fn enumerate(self) -> Enumerate<Self>
Creates a stream which gives the current iteration count as well as the next value. Read more
sourcefn filter<Fut, F>(self, f: F) -> Filter<Self, Fut, F> where
F: FnMut(&Self::Item) -> Fut,
Fut: Future<Output = bool>,
fn filter<Fut, F>(self, f: F) -> Filter<Self, Fut, F> where
F: FnMut(&Self::Item) -> Fut,
Fut: Future<Output = bool>,
Filters the values produced by this stream according to the provided asynchronous predicate. Read more
sourcefn filter_map<Fut, T, F>(self, f: F) -> FilterMap<Self, Fut, F> where
F: FnMut(Self::Item) -> Fut,
Fut: Future<Output = Option<T>>,
fn filter_map<Fut, T, F>(self, f: F) -> FilterMap<Self, Fut, F> where
F: FnMut(Self::Item) -> Fut,
Fut: Future<Output = Option<T>>,
Filters the values produced by this stream while simultaneously mapping them to a different type according to the provided asynchronous closure. Read more
sourcefn then<Fut, F>(self, f: F) -> Then<Self, Fut, F> where
F: FnMut(Self::Item) -> Fut,
Fut: Future,
fn then<Fut, F>(self, f: F) -> Then<Self, Fut, F> where
F: FnMut(Self::Item) -> Fut,
Fut: Future,
Computes from this stream’s items new items of a different type using an asynchronous closure. Read more
sourcefn collect<C>(self) -> Collect<Self, C>ⓘNotable traits for Collect<St, C>impl<St, C> Future for Collect<St, C> where
St: Stream,
C: Default + Extend<<St as Stream>::Item>, type Output = C; where
C: Default + Extend<Self::Item>,
fn collect<C>(self) -> Collect<Self, C>ⓘNotable traits for Collect<St, C>impl<St, C> Future for Collect<St, C> where
St: Stream,
C: Default + Extend<<St as Stream>::Item>, type Output = C; where
C: Default + Extend<Self::Item>,
St: Stream,
C: Default + Extend<<St as Stream>::Item>, type Output = C;
Transforms a stream into a collection, returning a future representing the result of that computation. Read more
sourcefn unzip<A, B, FromA, FromB>(self) -> Unzip<Self, FromA, FromB>ⓘNotable traits for Unzip<St, FromA, FromB>impl<St, A, B, FromA, FromB> Future for Unzip<St, FromA, FromB> where
St: Stream<Item = (A, B)>,
FromA: Default + Extend<A>,
FromB: Default + Extend<B>, type Output = (FromA, FromB); where
FromA: Default + Extend<A>,
FromB: Default + Extend<B>,
Self: Stream<Item = (A, B)>,
fn unzip<A, B, FromA, FromB>(self) -> Unzip<Self, FromA, FromB>ⓘNotable traits for Unzip<St, FromA, FromB>impl<St, A, B, FromA, FromB> Future for Unzip<St, FromA, FromB> where
St: Stream<Item = (A, B)>,
FromA: Default + Extend<A>,
FromB: Default + Extend<B>, type Output = (FromA, FromB); where
FromA: Default + Extend<A>,
FromB: Default + Extend<B>,
Self: Stream<Item = (A, B)>,
St: Stream<Item = (A, B)>,
FromA: Default + Extend<A>,
FromB: Default + Extend<B>, type Output = (FromA, FromB);
Converts a stream of pairs into a future, which resolves to pair of containers. Read more
sourcefn concat(self) -> Concat<Self>ⓘNotable traits for Concat<St>impl<St> Future for Concat<St> where
St: Stream,
<St as Stream>::Item: Extend<<<St as Stream>::Item as IntoIterator>::Item>,
<St as Stream>::Item: IntoIterator,
<St as Stream>::Item: Default, type Output = <St as Stream>::Item; where
Self::Item: Extend<<Self::Item as IntoIterator>::Item>,
Self::Item: IntoIterator,
Self::Item: Default,
fn concat(self) -> Concat<Self>ⓘNotable traits for Concat<St>impl<St> Future for Concat<St> where
St: Stream,
<St as Stream>::Item: Extend<<<St as Stream>::Item as IntoIterator>::Item>,
<St as Stream>::Item: IntoIterator,
<St as Stream>::Item: Default, type Output = <St as Stream>::Item; where
Self::Item: Extend<<Self::Item as IntoIterator>::Item>,
Self::Item: IntoIterator,
Self::Item: Default,
St: Stream,
<St as Stream>::Item: Extend<<<St as Stream>::Item as IntoIterator>::Item>,
<St as Stream>::Item: IntoIterator,
<St as Stream>::Item: Default, type Output = <St as Stream>::Item;
Concatenate all items of a stream into a single extendable destination, returning a future representing the end result. Read more
sourcefn count(self) -> Count<Self>
fn count(self) -> Count<Self>
Drives the stream to completion, counting the number of items. Read more
sourcefn fold<T, Fut, F>(self, init: T, f: F) -> Fold<Self, Fut, T, F>ⓘNotable traits for Fold<St, Fut, T, F>impl<St, Fut, T, F> Future for Fold<St, Fut, T, F> where
St: Stream,
F: FnMut(T, <St as Stream>::Item) -> Fut,
Fut: Future<Output = T>, type Output = T; where
F: FnMut(T, Self::Item) -> Fut,
Fut: Future<Output = T>,
fn fold<T, Fut, F>(self, init: T, f: F) -> Fold<Self, Fut, T, F>ⓘNotable traits for Fold<St, Fut, T, F>impl<St, Fut, T, F> Future for Fold<St, Fut, T, F> where
St: Stream,
F: FnMut(T, <St as Stream>::Item) -> Fut,
Fut: Future<Output = T>, type Output = T; where
F: FnMut(T, Self::Item) -> Fut,
Fut: Future<Output = T>,
St: Stream,
F: FnMut(T, <St as Stream>::Item) -> Fut,
Fut: Future<Output = T>, type Output = T;
Execute an accumulating asynchronous computation over a stream, collecting all the values into one final result. Read more
sourcefn any<Fut, F>(self, f: F) -> Any<Self, Fut, F> where
F: FnMut(Self::Item) -> Fut,
Fut: Future<Output = bool>,
fn any<Fut, F>(self, f: F) -> Any<Self, Fut, F> where
F: FnMut(Self::Item) -> Fut,
Fut: Future<Output = bool>,
Execute predicate over asynchronous stream, and return true if any element in stream satisfied a predicate. Read more
sourcefn all<Fut, F>(self, f: F) -> All<Self, Fut, F> where
F: FnMut(Self::Item) -> Fut,
Fut: Future<Output = bool>,
fn all<Fut, F>(self, f: F) -> All<Self, Fut, F> where
F: FnMut(Self::Item) -> Fut,
Fut: Future<Output = bool>,
Execute predicate over asynchronous stream, and return true if all element in stream satisfied a predicate. Read more
sourcefn flatten(self) -> Flatten<Self> where
Self::Item: Stream,
fn flatten(self) -> Flatten<Self> where
Self::Item: Stream,
Flattens a stream of streams into just one continuous stream. Read more
sourcefn flatten_unordered(
self,
limit: impl Into<Option<usize>>
) -> FlattenUnordered<Self> where
Self::Item: Stream,
Self::Item: Unpin,
fn flatten_unordered(
self,
limit: impl Into<Option<usize>>
) -> FlattenUnordered<Self> where
Self::Item: Stream,
Self::Item: Unpin,
Flattens a stream of streams into just one continuous stream. Polls inner streams concurrently. Read more
sourcefn flat_map<U, F>(self, f: F) -> FlatMap<Self, U, F> where
F: FnMut(Self::Item) -> U,
U: Stream,
fn flat_map<U, F>(self, f: F) -> FlatMap<Self, U, F> where
F: FnMut(Self::Item) -> U,
U: Stream,
Maps a stream like StreamExt::map but flattens nested Streams. Read more
sourcefn flat_map_unordered<U, F>(
self,
limit: impl Into<Option<usize>>,
f: F
) -> FlatMapUnordered<Self, U, F> where
U: Stream + Unpin,
F: FnMut(Self::Item) -> U,
fn flat_map_unordered<U, F>(
self,
limit: impl Into<Option<usize>>,
f: F
) -> FlatMapUnordered<Self, U, F> where
U: Stream + Unpin,
F: FnMut(Self::Item) -> U,
Maps a stream like StreamExt::map but flattens nested Streams
and polls them concurrently, yielding items in any order, as they made
available. Read more
sourcefn scan<S, B, Fut, F>(self, initial_state: S, f: F) -> Scan<Self, S, Fut, F> where
F: FnMut(&mut S, Self::Item) -> Fut,
Fut: Future<Output = Option<B>>,
fn scan<S, B, Fut, F>(self, initial_state: S, f: F) -> Scan<Self, S, Fut, F> where
F: FnMut(&mut S, Self::Item) -> Fut,
Fut: Future<Output = Option<B>>,
Combinator similar to StreamExt::fold that holds internal state
and produces a new stream. Read more
sourcefn skip_while<Fut, F>(self, f: F) -> SkipWhile<Self, Fut, F> where
F: FnMut(&Self::Item) -> Fut,
Fut: Future<Output = bool>,
fn skip_while<Fut, F>(self, f: F) -> SkipWhile<Self, Fut, F> where
F: FnMut(&Self::Item) -> Fut,
Fut: Future<Output = bool>,
Skip elements on this stream while the provided asynchronous predicate
resolves to true. Read more
sourcefn take_while<Fut, F>(self, f: F) -> TakeWhile<Self, Fut, F> where
F: FnMut(&Self::Item) -> Fut,
Fut: Future<Output = bool>,
fn take_while<Fut, F>(self, f: F) -> TakeWhile<Self, Fut, F> where
F: FnMut(&Self::Item) -> Fut,
Fut: Future<Output = bool>,
Take elements from this stream while the provided asynchronous predicate
resolves to true. Read more
sourcefn take_until<Fut>(self, fut: Fut) -> TakeUntil<Self, Fut> where
Fut: Future,
fn take_until<Fut>(self, fut: Fut) -> TakeUntil<Self, Fut> where
Fut: Future,
Take elements from this stream until the provided future resolves. Read more
sourcefn for_each<Fut, F>(self, f: F) -> ForEach<Self, Fut, F>ⓘNotable traits for ForEach<St, Fut, F>impl<St, Fut, F> Future for ForEach<St, Fut, F> where
St: Stream,
F: FnMut(<St as Stream>::Item) -> Fut,
Fut: Future<Output = ()>, type Output = (); where
F: FnMut(Self::Item) -> Fut,
Fut: Future<Output = ()>,
fn for_each<Fut, F>(self, f: F) -> ForEach<Self, Fut, F>ⓘNotable traits for ForEach<St, Fut, F>impl<St, Fut, F> Future for ForEach<St, Fut, F> where
St: Stream,
F: FnMut(<St as Stream>::Item) -> Fut,
Fut: Future<Output = ()>, type Output = (); where
F: FnMut(Self::Item) -> Fut,
Fut: Future<Output = ()>,
St: Stream,
F: FnMut(<St as Stream>::Item) -> Fut,
Fut: Future<Output = ()>, type Output = ();
Runs this stream to completion, executing the provided asynchronous closure for each element on the stream. Read more
sourcefn for_each_concurrent<Fut, F>(
self,
limit: impl Into<Option<usize>>,
f: F
) -> ForEachConcurrent<Self, Fut, F>ⓘNotable traits for ForEachConcurrent<St, Fut, F>impl<St, Fut, F> Future for ForEachConcurrent<St, Fut, F> where
St: Stream,
F: FnMut(<St as Stream>::Item) -> Fut,
Fut: Future<Output = ()>, type Output = (); where
F: FnMut(Self::Item) -> Fut,
Fut: Future<Output = ()>,
fn for_each_concurrent<Fut, F>(
self,
limit: impl Into<Option<usize>>,
f: F
) -> ForEachConcurrent<Self, Fut, F>ⓘNotable traits for ForEachConcurrent<St, Fut, F>impl<St, Fut, F> Future for ForEachConcurrent<St, Fut, F> where
St: Stream,
F: FnMut(<St as Stream>::Item) -> Fut,
Fut: Future<Output = ()>, type Output = (); where
F: FnMut(Self::Item) -> Fut,
Fut: Future<Output = ()>,
St: Stream,
F: FnMut(<St as Stream>::Item) -> Fut,
Fut: Future<Output = ()>, type Output = ();
Runs this stream to completion, executing the provided asynchronous closure for each element on the stream concurrently as elements become available. Read more
sourcefn take(self, n: usize) -> Take<Self>
fn take(self, n: usize) -> Take<Self>
Creates a new stream of at most n items of the underlying stream. Read more
sourcefn skip(self, n: usize) -> Skip<Self>
fn skip(self, n: usize) -> Skip<Self>
Creates a new stream which skips n items of the underlying stream. Read more
sourcefn catch_unwind(self) -> CatchUnwind<Self> where
Self: UnwindSafe,
fn catch_unwind(self) -> CatchUnwind<Self> where
Self: UnwindSafe,
Catches unwinding panics while polling the stream. Read more
sourcefn boxed<'a>(
self
) -> Pin<Box<dyn Stream<Item = Self::Item> + Send + 'a, Global>>ⓘNotable traits for Pin<P>impl<P> Future for Pin<P> where
P: DerefMut,
<P as Deref>::Target: Future, type Output = <<P as Deref>::Target as Future>::Output; where
Self: 'a + Send,
fn boxed<'a>(
self
) -> Pin<Box<dyn Stream<Item = Self::Item> + Send + 'a, Global>>ⓘNotable traits for Pin<P>impl<P> Future for Pin<P> where
P: DerefMut,
<P as Deref>::Target: Future, type Output = <<P as Deref>::Target as Future>::Output; where
Self: 'a + Send,
P: DerefMut,
<P as Deref>::Target: Future, type Output = <<P as Deref>::Target as Future>::Output;
Wrap the stream in a Box, pinning it. Read more
sourcefn boxed_local<'a>(self) -> Pin<Box<dyn Stream<Item = Self::Item> + 'a, Global>>ⓘNotable traits for Pin<P>impl<P> Future for Pin<P> where
P: DerefMut,
<P as Deref>::Target: Future, type Output = <<P as Deref>::Target as Future>::Output; where
Self: 'a,
fn boxed_local<'a>(self) -> Pin<Box<dyn Stream<Item = Self::Item> + 'a, Global>>ⓘNotable traits for Pin<P>impl<P> Future for Pin<P> where
P: DerefMut,
<P as Deref>::Target: Future, type Output = <<P as Deref>::Target as Future>::Output; where
Self: 'a,
P: DerefMut,
<P as Deref>::Target: Future, type Output = <<P as Deref>::Target as Future>::Output;
Wrap the stream in a Box, pinning it. Read more
sourcefn buffered(self, n: usize) -> Buffered<Self> where
Self::Item: Future,
fn buffered(self, n: usize) -> Buffered<Self> where
Self::Item: Future,
An adaptor for creating a buffered list of pending futures. Read more
sourcefn buffer_unordered(self, n: usize) -> BufferUnordered<Self> where
Self::Item: Future,
fn buffer_unordered(self, n: usize) -> BufferUnordered<Self> where
Self::Item: Future,
An adaptor for creating a buffered list of pending futures (unordered). Read more
sourcefn zip<St>(self, other: St) -> Zip<Self, St> where
St: Stream,
fn zip<St>(self, other: St) -> Zip<Self, St> where
St: Stream,
An adapter for zipping two streams together. Read more
sourcefn chain<St>(self, other: St) -> Chain<Self, St> where
St: Stream<Item = Self::Item>,
fn chain<St>(self, other: St) -> Chain<Self, St> where
St: Stream<Item = Self::Item>,
Adapter for chaining two streams. Read more
sourcefn peekable(self) -> Peekable<Self>
fn peekable(self) -> Peekable<Self>
Creates a new stream which exposes a peek method. Read more
sourcefn chunks(self, capacity: usize) -> Chunks<Self>
fn chunks(self, capacity: usize) -> Chunks<Self>
An adaptor for chunking up items of the stream inside a vector. Read more
sourcefn ready_chunks(self, capacity: usize) -> ReadyChunks<Self>
fn ready_chunks(self, capacity: usize) -> ReadyChunks<Self>
An adaptor for chunking up ready items of the stream inside a vector. Read more
sourcefn forward<S>(self, sink: S) -> Forward<Self, S>ⓘNotable traits for Forward<St, Si>impl<St, Si> Future for Forward<St, Si> where
St: TryStream,
Forward<St, Si, <St as TryStream>::Ok>: Future, type Output = <Forward<St, Si, <St as TryStream>::Ok> as Future>::Output; where
S: Sink<Self::Ok, Error = Self::Error>,
Self: TryStream,
fn forward<S>(self, sink: S) -> Forward<Self, S>ⓘNotable traits for Forward<St, Si>impl<St, Si> Future for Forward<St, Si> where
St: TryStream,
Forward<St, Si, <St as TryStream>::Ok>: Future, type Output = <Forward<St, Si, <St as TryStream>::Ok> as Future>::Output; where
S: Sink<Self::Ok, Error = Self::Error>,
Self: TryStream,
St: TryStream,
Forward<St, Si, <St as TryStream>::Ok>: Future, type Output = <Forward<St, Si, <St as TryStream>::Ok> as Future>::Output;
A future that completes after the given stream has been fully processed into the sink and the sink has been flushed and closed. Read more
sourcefn split<Item>(self) -> (SplitSink<Self, Item>, SplitStream<Self>) where
Self: Sink<Item>,
fn split<Item>(self) -> (SplitSink<Self, Item>, SplitStream<Self>) where
Self: Sink<Item>,
Splits this Stream + Sink object into separate Sink and Stream
objects. Read more
sourcefn inspect<F>(self, f: F) -> Inspect<Self, F> where
F: FnMut(&Self::Item),
fn inspect<F>(self, f: F) -> Inspect<Self, F> where
F: FnMut(&Self::Item),
Do something with each item of this stream, afterwards passing it on. Read more
sourcefn left_stream<B>(self) -> Either<Self, B>ⓘNotable traits for Either<A, B>impl<A, B> Future for Either<A, B> where
A: Future,
B: Future<Output = <A as Future>::Output>, type Output = <A as Future>::Output; where
B: Stream<Item = Self::Item>,
fn left_stream<B>(self) -> Either<Self, B>ⓘNotable traits for Either<A, B>impl<A, B> Future for Either<A, B> where
A: Future,
B: Future<Output = <A as Future>::Output>, type Output = <A as Future>::Output; where
B: Stream<Item = Self::Item>,
A: Future,
B: Future<Output = <A as Future>::Output>, type Output = <A as Future>::Output;
Wrap this stream in an Either stream, making it the left-hand variant
of that Either. Read more
sourcefn right_stream<B>(self) -> Either<B, Self>ⓘNotable traits for Either<A, B>impl<A, B> Future for Either<A, B> where
A: Future,
B: Future<Output = <A as Future>::Output>, type Output = <A as Future>::Output; where
B: Stream<Item = Self::Item>,
fn right_stream<B>(self) -> Either<B, Self>ⓘNotable traits for Either<A, B>impl<A, B> Future for Either<A, B> where
A: Future,
B: Future<Output = <A as Future>::Output>, type Output = <A as Future>::Output; where
B: Stream<Item = Self::Item>,
A: Future,
B: Future<Output = <A as Future>::Output>, type Output = <A as Future>::Output;
Wrap this stream in an Either stream, making it the right-hand variant
of that Either. Read more
sourcefn poll_next_unpin(&mut self, cx: &mut Context<'_>) -> Poll<Option<Self::Item>> where
Self: Unpin,
fn poll_next_unpin(&mut self, cx: &mut Context<'_>) -> Poll<Option<Self::Item>> where
Self: Unpin,
A convenience method for calling Stream::poll_next on Unpin
stream types. Read more
sourcefn select_next_some(&mut self) -> SelectNextSome<'_, Self>ⓘNotable traits for SelectNextSome<'_, St>impl<'_, St> Future for SelectNextSome<'_, St> where
St: FusedStream + Unpin + ?Sized, type Output = <St as Stream>::Item; where
Self: Unpin + FusedStream,
fn select_next_some(&mut self) -> SelectNextSome<'_, Self>ⓘNotable traits for SelectNextSome<'_, St>impl<'_, St> Future for SelectNextSome<'_, St> where
St: FusedStream + Unpin + ?Sized, type Output = <St as Stream>::Item; where
Self: Unpin + FusedStream,
St: FusedStream + Unpin + ?Sized, type Output = <St as Stream>::Item;
sourceimpl<S, T, E> TryStream for S where
S: Stream<Item = Result<T, E>> + ?Sized,
impl<S, T, E> TryStream for S where
S: Stream<Item = Result<T, E>> + ?Sized,
sourceimpl<S> TryStreamExt for S where
S: TryStream + ?Sized,
impl<S> TryStreamExt for S where
S: TryStream + ?Sized,
sourcefn err_into<E>(self) -> ErrInto<Self, E> where
Self::Error: Into<E>,
fn err_into<E>(self) -> ErrInto<Self, E> where
Self::Error: Into<E>,
Wraps the current stream in a new stream which converts the error type into the one provided. Read more
sourcefn map_ok<T, F>(self, f: F) -> MapOk<Self, F> where
F: FnMut(Self::Ok) -> T,
fn map_ok<T, F>(self, f: F) -> MapOk<Self, F> where
F: FnMut(Self::Ok) -> T,
Wraps the current stream in a new stream which maps the success value using the provided closure. Read more
sourcefn map_err<E, F>(self, f: F) -> MapErr<Self, F> where
F: FnMut(Self::Error) -> E,
fn map_err<E, F>(self, f: F) -> MapErr<Self, F> where
F: FnMut(Self::Error) -> E,
Wraps the current stream in a new stream which maps the error value using the provided closure. Read more
sourcefn and_then<Fut, F>(self, f: F) -> AndThen<Self, Fut, F> where
F: FnMut(Self::Ok) -> Fut,
Fut: TryFuture<Error = Self::Error>,
fn and_then<Fut, F>(self, f: F) -> AndThen<Self, Fut, F> where
F: FnMut(Self::Ok) -> Fut,
Fut: TryFuture<Error = Self::Error>,
Chain on a computation for when a value is ready, passing the successful
results to the provided closure f. Read more
sourcefn or_else<Fut, F>(self, f: F) -> OrElse<Self, Fut, F> where
F: FnMut(Self::Error) -> Fut,
Fut: TryFuture<Ok = Self::Ok>,
fn or_else<Fut, F>(self, f: F) -> OrElse<Self, Fut, F> where
F: FnMut(Self::Error) -> Fut,
Fut: TryFuture<Ok = Self::Ok>,
Chain on a computation for when an error happens, passing the
erroneous result to the provided closure f. Read more
sourcefn inspect_ok<F>(self, f: F) -> InspectOk<Self, F> where
F: FnMut(&Self::Ok),
fn inspect_ok<F>(self, f: F) -> InspectOk<Self, F> where
F: FnMut(&Self::Ok),
Do something with the success value of this stream, afterwards passing it on. Read more
sourcefn inspect_err<F>(self, f: F) -> InspectErr<Self, F> where
F: FnMut(&Self::Error),
fn inspect_err<F>(self, f: F) -> InspectErr<Self, F> where
F: FnMut(&Self::Error),
Do something with the error value of this stream, afterwards passing it on. Read more
sourcefn into_stream(self) -> IntoStream<Self>
fn into_stream(self) -> IntoStream<Self>
sourcefn try_next(&mut self) -> TryNext<'_, Self>ⓘNotable traits for TryNext<'_, St>impl<'_, St> Future for TryNext<'_, St> where
St: TryStream + Unpin + ?Sized, type Output = Result<Option<<St as TryStream>::Ok>, <St as TryStream>::Error>; where
Self: Unpin,
fn try_next(&mut self) -> TryNext<'_, Self>ⓘNotable traits for TryNext<'_, St>impl<'_, St> Future for TryNext<'_, St> where
St: TryStream + Unpin + ?Sized, type Output = Result<Option<<St as TryStream>::Ok>, <St as TryStream>::Error>; where
Self: Unpin,
St: TryStream + Unpin + ?Sized, type Output = Result<Option<<St as TryStream>::Ok>, <St as TryStream>::Error>;
Creates a future that attempts to resolve the next item in the stream. If an error is encountered before the next item, the error is returned instead. Read more
sourcefn try_for_each<Fut, F>(self, f: F) -> TryForEach<Self, Fut, F>ⓘNotable traits for TryForEach<St, Fut, F>impl<St, Fut, F> Future for TryForEach<St, Fut, F> where
St: TryStream,
F: FnMut(<St as TryStream>::Ok) -> Fut,
Fut: TryFuture<Ok = (), Error = <St as TryStream>::Error>, type Output = Result<(), <St as TryStream>::Error>; where
F: FnMut(Self::Ok) -> Fut,
Fut: TryFuture<Ok = (), Error = Self::Error>,
fn try_for_each<Fut, F>(self, f: F) -> TryForEach<Self, Fut, F>ⓘNotable traits for TryForEach<St, Fut, F>impl<St, Fut, F> Future for TryForEach<St, Fut, F> where
St: TryStream,
F: FnMut(<St as TryStream>::Ok) -> Fut,
Fut: TryFuture<Ok = (), Error = <St as TryStream>::Error>, type Output = Result<(), <St as TryStream>::Error>; where
F: FnMut(Self::Ok) -> Fut,
Fut: TryFuture<Ok = (), Error = Self::Error>,
St: TryStream,
F: FnMut(<St as TryStream>::Ok) -> Fut,
Fut: TryFuture<Ok = (), Error = <St as TryStream>::Error>, type Output = Result<(), <St as TryStream>::Error>;
Attempts to run this stream to completion, executing the provided asynchronous closure for each element on the stream. Read more
sourcefn try_skip_while<Fut, F>(self, f: F) -> TrySkipWhile<Self, Fut, F> where
F: FnMut(&Self::Ok) -> Fut,
Fut: TryFuture<Ok = bool, Error = Self::Error>,
fn try_skip_while<Fut, F>(self, f: F) -> TrySkipWhile<Self, Fut, F> where
F: FnMut(&Self::Ok) -> Fut,
Fut: TryFuture<Ok = bool, Error = Self::Error>,
Skip elements on this stream while the provided asynchronous predicate
resolves to true. Read more
sourcefn try_take_while<Fut, F>(self, f: F) -> TryTakeWhile<Self, Fut, F> where
F: FnMut(&Self::Ok) -> Fut,
Fut: TryFuture<Ok = bool, Error = Self::Error>,
fn try_take_while<Fut, F>(self, f: F) -> TryTakeWhile<Self, Fut, F> where
F: FnMut(&Self::Ok) -> Fut,
Fut: TryFuture<Ok = bool, Error = Self::Error>,
Take elements on this stream while the provided asynchronous predicate
resolves to true. Read more
sourcefn try_for_each_concurrent<Fut, F>(
self,
limit: impl Into<Option<usize>>,
f: F
) -> TryForEachConcurrent<Self, Fut, F>ⓘNotable traits for TryForEachConcurrent<St, Fut, F>impl<St, Fut, F> Future for TryForEachConcurrent<St, Fut, F> where
St: TryStream,
F: FnMut(<St as TryStream>::Ok) -> Fut,
Fut: Future<Output = Result<(), <St as TryStream>::Error>>, type Output = Result<(), <St as TryStream>::Error>; where
F: FnMut(Self::Ok) -> Fut,
Fut: Future<Output = Result<(), Self::Error>>,
fn try_for_each_concurrent<Fut, F>(
self,
limit: impl Into<Option<usize>>,
f: F
) -> TryForEachConcurrent<Self, Fut, F>ⓘNotable traits for TryForEachConcurrent<St, Fut, F>impl<St, Fut, F> Future for TryForEachConcurrent<St, Fut, F> where
St: TryStream,
F: FnMut(<St as TryStream>::Ok) -> Fut,
Fut: Future<Output = Result<(), <St as TryStream>::Error>>, type Output = Result<(), <St as TryStream>::Error>; where
F: FnMut(Self::Ok) -> Fut,
Fut: Future<Output = Result<(), Self::Error>>,
St: TryStream,
F: FnMut(<St as TryStream>::Ok) -> Fut,
Fut: Future<Output = Result<(), <St as TryStream>::Error>>, type Output = Result<(), <St as TryStream>::Error>;
Attempts to run this stream to completion, executing the provided asynchronous closure for each element on the stream concurrently as elements become available, exiting as soon as an error occurs. Read more
sourcefn try_collect<C>(self) -> TryCollect<Self, C>ⓘNotable traits for TryCollect<St, C>impl<St, C> Future for TryCollect<St, C> where
St: TryStream,
C: Default + Extend<<St as TryStream>::Ok>, type Output = Result<C, <St as TryStream>::Error>; where
C: Default + Extend<Self::Ok>,
fn try_collect<C>(self) -> TryCollect<Self, C>ⓘNotable traits for TryCollect<St, C>impl<St, C> Future for TryCollect<St, C> where
St: TryStream,
C: Default + Extend<<St as TryStream>::Ok>, type Output = Result<C, <St as TryStream>::Error>; where
C: Default + Extend<Self::Ok>,
St: TryStream,
C: Default + Extend<<St as TryStream>::Ok>, type Output = Result<C, <St as TryStream>::Error>;
Attempt to transform a stream into a collection, returning a future representing the result of that computation. Read more
sourcefn try_chunks(self, capacity: usize) -> TryChunks<Self>
fn try_chunks(self, capacity: usize) -> TryChunks<Self>
An adaptor for chunking up successful items of the stream inside a vector. Read more
sourcefn try_filter<Fut, F>(self, f: F) -> TryFilter<Self, Fut, F> where
Fut: Future<Output = bool>,
F: FnMut(&Self::Ok) -> Fut,
fn try_filter<Fut, F>(self, f: F) -> TryFilter<Self, Fut, F> where
Fut: Future<Output = bool>,
F: FnMut(&Self::Ok) -> Fut,
Attempt to filter the values produced by this stream according to the provided asynchronous closure. Read more
sourcefn try_filter_map<Fut, F, T>(self, f: F) -> TryFilterMap<Self, Fut, F> where
Fut: TryFuture<Ok = Option<T>, Error = Self::Error>,
F: FnMut(Self::Ok) -> Fut,
fn try_filter_map<Fut, F, T>(self, f: F) -> TryFilterMap<Self, Fut, F> where
Fut: TryFuture<Ok = Option<T>, Error = Self::Error>,
F: FnMut(Self::Ok) -> Fut,
Attempt to filter the values produced by this stream while simultaneously mapping them to a different type according to the provided asynchronous closure. Read more
sourcefn try_flatten(self) -> TryFlatten<Self> where
Self::Ok: TryStream,
<Self::Ok as TryStream>::Error: From<Self::Error>,
fn try_flatten(self) -> TryFlatten<Self> where
Self::Ok: TryStream,
<Self::Ok as TryStream>::Error: From<Self::Error>,
Flattens a stream of streams into just one continuous stream. Read more
sourcefn try_fold<T, Fut, F>(self, init: T, f: F) -> TryFold<Self, Fut, T, F>ⓘNotable traits for TryFold<St, Fut, T, F>impl<St, Fut, T, F> Future for TryFold<St, Fut, T, F> where
St: TryStream,
F: FnMut(T, <St as TryStream>::Ok) -> Fut,
Fut: TryFuture<Ok = T, Error = <St as TryStream>::Error>, type Output = Result<T, <St as TryStream>::Error>; where
F: FnMut(T, Self::Ok) -> Fut,
Fut: TryFuture<Ok = T, Error = Self::Error>,
fn try_fold<T, Fut, F>(self, init: T, f: F) -> TryFold<Self, Fut, T, F>ⓘNotable traits for TryFold<St, Fut, T, F>impl<St, Fut, T, F> Future for TryFold<St, Fut, T, F> where
St: TryStream,
F: FnMut(T, <St as TryStream>::Ok) -> Fut,
Fut: TryFuture<Ok = T, Error = <St as TryStream>::Error>, type Output = Result<T, <St as TryStream>::Error>; where
F: FnMut(T, Self::Ok) -> Fut,
Fut: TryFuture<Ok = T, Error = Self::Error>,
St: TryStream,
F: FnMut(T, <St as TryStream>::Ok) -> Fut,
Fut: TryFuture<Ok = T, Error = <St as TryStream>::Error>, type Output = Result<T, <St as TryStream>::Error>;
Attempt to execute an accumulating asynchronous computation over a stream, collecting all the values into one final result. Read more
sourcefn try_concat(self) -> TryConcat<Self>ⓘNotable traits for TryConcat<St>impl<St> Future for TryConcat<St> where
St: TryStream,
<St as TryStream>::Ok: Extend<<<St as TryStream>::Ok as IntoIterator>::Item>,
<St as TryStream>::Ok: IntoIterator,
<St as TryStream>::Ok: Default, type Output = Result<<St as TryStream>::Ok, <St as TryStream>::Error>; where
Self::Ok: Extend<<Self::Ok as IntoIterator>::Item>,
Self::Ok: IntoIterator,
Self::Ok: Default,
fn try_concat(self) -> TryConcat<Self>ⓘNotable traits for TryConcat<St>impl<St> Future for TryConcat<St> where
St: TryStream,
<St as TryStream>::Ok: Extend<<<St as TryStream>::Ok as IntoIterator>::Item>,
<St as TryStream>::Ok: IntoIterator,
<St as TryStream>::Ok: Default, type Output = Result<<St as TryStream>::Ok, <St as TryStream>::Error>; where
Self::Ok: Extend<<Self::Ok as IntoIterator>::Item>,
Self::Ok: IntoIterator,
Self::Ok: Default,
St: TryStream,
<St as TryStream>::Ok: Extend<<<St as TryStream>::Ok as IntoIterator>::Item>,
<St as TryStream>::Ok: IntoIterator,
<St as TryStream>::Ok: Default, type Output = Result<<St as TryStream>::Ok, <St as TryStream>::Error>;
Attempt to concatenate all items of a stream into a single extendable destination, returning a future representing the end result. Read more
sourcefn try_buffer_unordered(self, n: usize) -> TryBufferUnordered<Self> where
Self::Ok: TryFuture,
<Self::Ok as TryFuture>::Error == Self::Error,
fn try_buffer_unordered(self, n: usize) -> TryBufferUnordered<Self> where
Self::Ok: TryFuture,
<Self::Ok as TryFuture>::Error == Self::Error,
Attempt to execute several futures from a stream concurrently (unordered). Read more
sourcefn try_buffered(self, n: usize) -> TryBuffered<Self> where
Self::Ok: TryFuture,
<Self::Ok as TryFuture>::Error == Self::Error,
fn try_buffered(self, n: usize) -> TryBuffered<Self> where
Self::Ok: TryFuture,
<Self::Ok as TryFuture>::Error == Self::Error,
Attempt to execute several futures from a stream concurrently. Read more
sourcefn try_poll_next_unpin(
&mut self,
cx: &mut Context<'_>
) -> Poll<Option<Result<Self::Ok, Self::Error>>> where
Self: Unpin,
fn try_poll_next_unpin(
&mut self,
cx: &mut Context<'_>
) -> Poll<Option<Result<Self::Ok, Self::Error>>> where
Self: Unpin,
A convenience method for calling TryStream::try_poll_next on Unpin
stream types. Read more