Struct futures_util::stream::SelectWithStrategy  
source · pub struct SelectWithStrategy<St1, St2, Clos, State> { /* private fields */ }Expand description
Stream for the select_with_strategy() function. See function docs for details.
Implementations§
source§impl<St1, St2, Clos, State> SelectWithStrategy<St1, St2, Clos, State>
 
impl<St1, St2, Clos, State> SelectWithStrategy<St1, St2, Clos, State>
sourcepub fn get_ref(&self) -> (&St1, &St2)
 
pub fn get_ref(&self) -> (&St1, &St2)
Acquires a reference to the underlying streams that this combinator is pulling from.
sourcepub fn get_mut(&mut self) -> (&mut St1, &mut St2)
 
pub fn get_mut(&mut self) -> (&mut St1, &mut St2)
Acquires a mutable reference to the underlying streams that this combinator is pulling from.
Note that care must be taken to avoid tampering with the state of the stream which may otherwise confuse this combinator.
sourcepub fn get_pin_mut(self: Pin<&mut Self>) -> (Pin<&mut St1>, Pin<&mut St2>)
 
pub fn get_pin_mut(self: Pin<&mut Self>) -> (Pin<&mut St1>, Pin<&mut St2>)
Acquires a pinned mutable reference to the underlying streams that this combinator is pulling from.
Note that care must be taken to avoid tampering with the state of the stream which may otherwise confuse this combinator.
sourcepub fn into_inner(self) -> (St1, St2)
 
pub fn into_inner(self) -> (St1, St2)
Consumes this combinator, returning the underlying streams.
Note that this may discard intermediate state of this combinator, so care should be taken to avoid losing resources when this is called.
Trait Implementations§
source§impl<St1, St2, Clos, State> Debug for SelectWithStrategy<St1, St2, Clos, State>where
    St1: Debug,
    St2: Debug,
    State: Debug,
 
impl<St1, St2, Clos, State> Debug for SelectWithStrategy<St1, St2, Clos, State>where St1: Debug, St2: Debug, State: Debug,
source§impl<St1, St2, Clos, State> FusedStream for SelectWithStrategy<St1, St2, Clos, State>where
    St1: Stream,
    St2: Stream<Item = St1::Item>,
    Clos: FnMut(&mut State) -> PollNext,
 
impl<St1, St2, Clos, State> FusedStream for SelectWithStrategy<St1, St2, Clos, State>where St1: Stream, St2: Stream<Item = St1::Item>, Clos: FnMut(&mut State) -> PollNext,
source§fn is_terminated(&self) -> bool
 
fn is_terminated(&self) -> bool
true if the stream should no longer be polled.source§impl<St1, St2, Clos, State> Stream for SelectWithStrategy<St1, St2, Clos, State>where
    St1: Stream,
    St2: Stream<Item = St1::Item>,
    Clos: FnMut(&mut State) -> PollNext,
 
impl<St1, St2, Clos, State> Stream for SelectWithStrategy<St1, St2, Clos, State>where St1: Stream, St2: Stream<Item = St1::Item>, Clos: FnMut(&mut State) -> PollNext,
impl<'__pin, St1, St2, Clos, State> Unpin for SelectWithStrategy<St1, St2, Clos, State>where __Origin<'__pin, St1, St2, Clos, State>: Unpin,
Auto Trait Implementations§
impl<St1, St2, Clos, State> RefUnwindSafe for SelectWithStrategy<St1, St2, Clos, State>where Clos: RefUnwindSafe, St1: RefUnwindSafe, St2: RefUnwindSafe, State: RefUnwindSafe,
impl<St1, St2, Clos, State> Send for SelectWithStrategy<St1, St2, Clos, State>where Clos: Send, St1: Send, St2: Send, State: Send,
impl<St1, St2, Clos, State> Sync for SelectWithStrategy<St1, St2, Clos, State>where Clos: Sync, St1: Sync, St2: Sync, State: Sync,
impl<St1, St2, Clos, State> UnwindSafe for SelectWithStrategy<St1, St2, Clos, State>where Clos: UnwindSafe, St1: UnwindSafe, St2: UnwindSafe, State: UnwindSafe,
Blanket Implementations§
source§impl<T> BorrowMut<T> for Twhere
    T: ?Sized,
 
impl<T> BorrowMut<T> for Twhere T: ?Sized,
source§fn borrow_mut(&mut self) -> &mut T
 
fn borrow_mut(&mut self) -> &mut T
source§impl<T> StreamExt for Twhere
    T: Stream + ?Sized,
 
impl<T> StreamExt for Twhere T: Stream + ?Sized,
source§fn next(&mut self) -> Next<'_, Self> ⓘwhere
    Self: Unpin,
 
fn next(&mut self) -> Next<'_, Self> ⓘwhere Self: Unpin,
source§fn into_future(self) -> StreamFuture<Self> ⓘwhere
    Self: Sized + Unpin,
 
fn into_future(self) -> StreamFuture<Self> ⓘwhere Self: Sized + Unpin,
source§fn map<T, F>(self, f: F) -> Map<Self, F>where
    F: FnMut(Self::Item) -> T,
    Self: Sized,
 
fn map<T, F>(self, f: F) -> Map<Self, F>where F: FnMut(Self::Item) -> T, Self: Sized,
source§fn enumerate(self) -> Enumerate<Self>where
    Self: Sized,
 
fn enumerate(self) -> Enumerate<Self>where Self: Sized,
source§fn filter<Fut, F>(self, f: F) -> Filter<Self, Fut, F>where
    F: FnMut(&Self::Item) -> Fut,
    Fut: Future<Output = bool>,
    Self: Sized,
 
fn filter<Fut, F>(self, f: F) -> Filter<Self, Fut, F>where F: FnMut(&Self::Item) -> Fut, Fut: Future<Output = bool>, Self: Sized,
source§fn filter_map<Fut, T, F>(self, f: F) -> FilterMap<Self, Fut, F>where
    F: FnMut(Self::Item) -> Fut,
    Fut: Future<Output = Option<T>>,
    Self: Sized,
 
fn filter_map<Fut, T, F>(self, f: F) -> FilterMap<Self, Fut, F>where F: FnMut(Self::Item) -> Fut, Fut: Future<Output = Option<T>>, Self: Sized,
source§fn then<Fut, F>(self, f: F) -> Then<Self, Fut, F>where
    F: FnMut(Self::Item) -> Fut,
    Fut: Future,
    Self: Sized,
 
fn then<Fut, F>(self, f: F) -> Then<Self, Fut, F>where F: FnMut(Self::Item) -> Fut, Fut: Future, Self: Sized,
source§fn collect<C: Default + Extend<Self::Item>>(self) -> Collect<Self, C> ⓘwhere
    Self: Sized,
 
fn collect<C: Default + Extend<Self::Item>>(self) -> Collect<Self, C> ⓘwhere Self: Sized,
source§fn unzip<A, B, FromA, FromB>(self) -> Unzip<Self, FromA, FromB> ⓘwhere
    FromA: Default + Extend<A>,
    FromB: Default + Extend<B>,
    Self: Sized + Stream<Item = (A, B)>,
 
fn unzip<A, B, FromA, FromB>(self) -> Unzip<Self, FromA, FromB> ⓘwhere FromA: Default + Extend<A>, FromB: Default + Extend<B>, Self: Sized + Stream<Item = (A, B)>,
source§fn concat(self) -> Concat<Self> ⓘwhere
    Self: Sized,
    Self::Item: Extend<<<Self as Stream>::Item as IntoIterator>::Item> + IntoIterator + Default,
 
fn concat(self) -> Concat<Self> ⓘwhere Self: Sized, Self::Item: Extend<<<Self as Stream>::Item as IntoIterator>::Item> + IntoIterator + Default,
source§fn count(self) -> Count<Self> ⓘwhere
    Self: Sized,
 
fn count(self) -> Count<Self> ⓘwhere Self: Sized,
source§fn fold<T, Fut, F>(self, init: T, f: F) -> Fold<Self, Fut, T, F> ⓘwhere
    F: FnMut(T, Self::Item) -> Fut,
    Fut: Future<Output = T>,
    Self: Sized,
 
fn fold<T, Fut, F>(self, init: T, f: F) -> Fold<Self, Fut, T, F> ⓘwhere F: FnMut(T, Self::Item) -> Fut, Fut: Future<Output = T>, Self: Sized,
source§fn any<Fut, F>(self, f: F) -> Any<Self, Fut, F> ⓘwhere
    F: FnMut(Self::Item) -> Fut,
    Fut: Future<Output = bool>,
    Self: Sized,
 
fn any<Fut, F>(self, f: F) -> Any<Self, Fut, F> ⓘwhere F: FnMut(Self::Item) -> Fut, Fut: Future<Output = bool>, Self: Sized,
true if any element in stream satisfied a predicate. Read moresource§fn all<Fut, F>(self, f: F) -> All<Self, Fut, F> ⓘwhere
    F: FnMut(Self::Item) -> Fut,
    Fut: Future<Output = bool>,
    Self: Sized,
 
fn all<Fut, F>(self, f: F) -> All<Self, Fut, F> ⓘwhere F: FnMut(Self::Item) -> Fut, Fut: Future<Output = bool>, Self: Sized,
true if all element in stream satisfied a predicate. Read moresource§fn flatten(self) -> Flatten<Self>where
    Self::Item: Stream,
    Self: Sized,
 
fn flatten(self) -> Flatten<Self>where Self::Item: Stream, Self: Sized,
source§fn flatten_unordered(
    self,
    limit: impl Into<Option<usize>>
) -> FlattenUnordered<Self>where
    Self::Item: Stream + Unpin,
    Self: Sized,
 
fn flatten_unordered( self, limit: impl Into<Option<usize>> ) -> FlattenUnordered<Self>where Self::Item: Stream + Unpin, Self: Sized,
source§fn flat_map<U, F>(self, f: F) -> FlatMap<Self, U, F>where
    F: FnMut(Self::Item) -> U,
    U: Stream,
    Self: Sized,
 
fn flat_map<U, F>(self, f: F) -> FlatMap<Self, U, F>where F: FnMut(Self::Item) -> U, U: Stream, Self: Sized,
source§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,
    Self: Sized,
 
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, Self: Sized,
StreamExt::map but flattens nested Streams
and polls them concurrently, yielding items in any order, as they made
available. Read moresource§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>>,
    Self: Sized,
 
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>>, Self: Sized,
StreamExt::fold that holds internal state
and produces a new stream. Read moresource§fn skip_while<Fut, F>(self, f: F) -> SkipWhile<Self, Fut, F>where
    F: FnMut(&Self::Item) -> Fut,
    Fut: Future<Output = bool>,
    Self: Sized,
 
fn skip_while<Fut, F>(self, f: F) -> SkipWhile<Self, Fut, F>where F: FnMut(&Self::Item) -> Fut, Fut: Future<Output = bool>, Self: Sized,
true. Read moresource§fn take_while<Fut, F>(self, f: F) -> TakeWhile<Self, Fut, F>where
    F: FnMut(&Self::Item) -> Fut,
    Fut: Future<Output = bool>,
    Self: Sized,
 
fn take_while<Fut, F>(self, f: F) -> TakeWhile<Self, Fut, F>where F: FnMut(&Self::Item) -> Fut, Fut: Future<Output = bool>, Self: Sized,
true. Read moresource§fn take_until<Fut>(self, fut: Fut) -> TakeUntil<Self, Fut>where
    Fut: Future,
    Self: Sized,
 
fn take_until<Fut>(self, fut: Fut) -> TakeUntil<Self, Fut>where Fut: Future, Self: Sized,
source§fn for_each<Fut, F>(self, f: F) -> ForEach<Self, Fut, F> ⓘwhere
    F: FnMut(Self::Item) -> Fut,
    Fut: Future<Output = ()>,
    Self: Sized,
 
fn for_each<Fut, F>(self, f: F) -> ForEach<Self, Fut, F> ⓘwhere F: FnMut(Self::Item) -> Fut, Fut: Future<Output = ()>, Self: Sized,
source§fn for_each_concurrent<Fut, F>(
    self,
    limit: impl Into<Option<usize>>,
    f: F
) -> ForEachConcurrent<Self, Fut, F> ⓘwhere
    F: FnMut(Self::Item) -> Fut,
    Fut: Future<Output = ()>,
    Self: Sized,
 
fn for_each_concurrent<Fut, F>( self, limit: impl Into<Option<usize>>, f: F ) -> ForEachConcurrent<Self, Fut, F> ⓘwhere F: FnMut(Self::Item) -> Fut, Fut: Future<Output = ()>, Self: Sized,
source§fn take(self, n: usize) -> Take<Self>where
    Self: Sized,
 
fn take(self, n: usize) -> Take<Self>where Self: Sized,
n items of the underlying stream. Read moresource§fn skip(self, n: usize) -> Skip<Self>where
    Self: Sized,
 
fn skip(self, n: usize) -> Skip<Self>where Self: Sized,
n items of the underlying stream. Read moresource§fn catch_unwind(self) -> CatchUnwind<Self>where
    Self: Sized + UnwindSafe,
 
fn catch_unwind(self) -> CatchUnwind<Self>where Self: Sized + UnwindSafe,
source§fn boxed<'a>(self) -> BoxStream<'a, Self::Item>where
    Self: Sized + Send + 'a,
 
fn boxed<'a>(self) -> BoxStream<'a, Self::Item>where Self: Sized + Send + 'a,
source§fn boxed_local<'a>(self) -> LocalBoxStream<'a, Self::Item>where
    Self: Sized + 'a,
 
fn boxed_local<'a>(self) -> LocalBoxStream<'a, Self::Item>where Self: Sized + 'a,
source§fn buffered(self, n: usize) -> Buffered<Self>where
    Self::Item: Future,
    Self: Sized,
 
fn buffered(self, n: usize) -> Buffered<Self>where Self::Item: Future, Self: Sized,
source§fn buffer_unordered(self, n: usize) -> BufferUnordered<Self>where
    Self::Item: Future,
    Self: Sized,
 
fn buffer_unordered(self, n: usize) -> BufferUnordered<Self>where Self::Item: Future, Self: Sized,
source§fn zip<St>(self, other: St) -> Zip<Self, St>where
    St: Stream,
    Self: Sized,
 
fn zip<St>(self, other: St) -> Zip<Self, St>where St: Stream, Self: Sized,
source§fn chain<St>(self, other: St) -> Chain<Self, St>where
    St: Stream<Item = Self::Item>,
    Self: Sized,
 
fn chain<St>(self, other: St) -> Chain<Self, St>where St: Stream<Item = Self::Item>, Self: Sized,
source§fn peekable(self) -> Peekable<Self>where
    Self: Sized,
 
fn peekable(self) -> Peekable<Self>where Self: Sized,
peek method. Read moresource§fn chunks(self, capacity: usize) -> Chunks<Self>where
    Self: Sized,
 
fn chunks(self, capacity: usize) -> Chunks<Self>where Self: Sized,
source§fn ready_chunks(self, capacity: usize) -> ReadyChunks<Self>where
    Self: Sized,
 
fn ready_chunks(self, capacity: usize) -> ReadyChunks<Self>where Self: Sized,
source§fn forward<S>(self, sink: S) -> Forward<Self, S> ⓘwhere
    S: Sink<Self::Ok, Error = Self::Error>,
    Self: TryStream + Sized,
 
fn forward<S>(self, sink: S) -> Forward<Self, S> ⓘwhere S: Sink<Self::Ok, Error = Self::Error>, Self: TryStream + Sized,
source§fn split<Item>(self) -> (SplitSink<Self, Item>, SplitStream<Self>)where
    Self: Sink<Item> + Sized,
 
fn split<Item>(self) -> (SplitSink<Self, Item>, SplitStream<Self>)where Self: Sink<Item> + Sized,
source§fn inspect<F>(self, f: F) -> Inspect<Self, F>where
    F: FnMut(&Self::Item),
    Self: Sized,
 
fn inspect<F>(self, f: F) -> Inspect<Self, F>where F: FnMut(&Self::Item), Self: Sized,
source§fn right_stream<B>(self) -> Either<B, Self> ⓘwhere
    B: Stream<Item = Self::Item>,
    Self: Sized,
 
fn right_stream<B>(self) -> Either<B, Self> ⓘwhere B: Stream<Item = Self::Item>, Self: Sized,
source§fn 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,
Stream::poll_next on Unpin
stream types.source§fn select_next_some(&mut self) -> SelectNextSome<'_, Self> ⓘwhere
    Self: Unpin + FusedStream,
 
fn select_next_some(&mut self) -> SelectNextSome<'_, Self> ⓘwhere Self: Unpin + FusedStream,
source§impl<S> TryStreamExt for Swhere
    S: TryStream + ?Sized,
 
impl<S> TryStreamExt for Swhere S: TryStream + ?Sized,
source§fn err_into<E>(self) -> ErrInto<Self, E>where
    Self: Sized,
    Self::Error: Into<E>,
 
fn err_into<E>(self) -> ErrInto<Self, E>where Self: Sized, Self::Error: Into<E>,
source§fn map_ok<T, F>(self, f: F) -> MapOk<Self, F>where
    Self: Sized,
    F: FnMut(Self::Ok) -> T,
 
fn map_ok<T, F>(self, f: F) -> MapOk<Self, F>where Self: Sized, F: FnMut(Self::Ok) -> T,
source§fn map_err<E, F>(self, f: F) -> MapErr<Self, F>where
    Self: Sized,
    F: FnMut(Self::Error) -> E,
 
fn map_err<E, F>(self, f: F) -> MapErr<Self, F>where Self: Sized, F: FnMut(Self::Error) -> E,
source§fn and_then<Fut, F>(self, f: F) -> AndThen<Self, Fut, F>where
    F: FnMut(Self::Ok) -> Fut,
    Fut: TryFuture<Error = Self::Error>,
    Self: Sized,
 
fn and_then<Fut, F>(self, f: F) -> AndThen<Self, Fut, F>where F: FnMut(Self::Ok) -> Fut, Fut: TryFuture<Error = Self::Error>, Self: Sized,
f. Read moresource§fn or_else<Fut, F>(self, f: F) -> OrElse<Self, Fut, F>where
    F: FnMut(Self::Error) -> Fut,
    Fut: TryFuture<Ok = Self::Ok>,
    Self: Sized,
 
fn or_else<Fut, F>(self, f: F) -> OrElse<Self, Fut, F>where F: FnMut(Self::Error) -> Fut, Fut: TryFuture<Ok = Self::Ok>, Self: Sized,
f. Read moresource§fn inspect_ok<F>(self, f: F) -> InspectOk<Self, F>where
    F: FnMut(&Self::Ok),
    Self: Sized,
 
fn inspect_ok<F>(self, f: F) -> InspectOk<Self, F>where F: FnMut(&Self::Ok), Self: Sized,
source§fn inspect_err<F>(self, f: F) -> InspectErr<Self, F>where
    F: FnMut(&Self::Error),
    Self: Sized,
 
fn inspect_err<F>(self, f: F) -> InspectErr<Self, F>where F: FnMut(&Self::Error), Self: Sized,
source§fn into_stream(self) -> IntoStream<Self>where
    Self: Sized,
 
fn into_stream(self) -> IntoStream<Self>where Self: Sized,
source§fn try_next(&mut self) -> TryNext<'_, Self> ⓘwhere
    Self: Unpin,
 
fn try_next(&mut self) -> TryNext<'_, Self> ⓘwhere Self: Unpin,
source§fn try_for_each<Fut, F>(self, f: F) -> TryForEach<Self, Fut, F> ⓘwhere
    F: FnMut(Self::Ok) -> Fut,
    Fut: TryFuture<Ok = (), Error = Self::Error>,
    Self: Sized,
 
fn try_for_each<Fut, F>(self, f: F) -> TryForEach<Self, Fut, F> ⓘwhere F: FnMut(Self::Ok) -> Fut, Fut: TryFuture<Ok = (), Error = Self::Error>, Self: Sized,
source§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>,
    Self: Sized,
 
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>, Self: Sized,
true. Read moresource§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>,
    Self: Sized,
 
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>, Self: Sized,
true. Read moresource§fn try_for_each_concurrent<Fut, F>(
    self,
    limit: impl Into<Option<usize>>,
    f: F
) -> TryForEachConcurrent<Self, Fut, F> ⓘwhere
    F: FnMut(Self::Ok) -> Fut,
    Fut: Future<Output = Result<(), Self::Error>>,
    Self: Sized,
 
fn try_for_each_concurrent<Fut, F>( self, limit: impl Into<Option<usize>>, f: F ) -> TryForEachConcurrent<Self, Fut, F> ⓘwhere F: FnMut(Self::Ok) -> Fut, Fut: Future<Output = Result<(), Self::Error>>, Self: Sized,
source§fn try_collect<C: Default + Extend<Self::Ok>>(self) -> TryCollect<Self, C> ⓘwhere
    Self: Sized,
 
fn try_collect<C: Default + Extend<Self::Ok>>(self) -> TryCollect<Self, C> ⓘwhere Self: Sized,
source§fn try_chunks(self, capacity: usize) -> TryChunks<Self>where
    Self: Sized,
 
fn try_chunks(self, capacity: usize) -> TryChunks<Self>where Self: Sized,
source§fn try_filter<Fut, F>(self, f: F) -> TryFilter<Self, Fut, F>where
    Fut: Future<Output = bool>,
    F: FnMut(&Self::Ok) -> Fut,
    Self: Sized,
 
fn try_filter<Fut, F>(self, f: F) -> TryFilter<Self, Fut, F>where Fut: Future<Output = bool>, F: FnMut(&Self::Ok) -> Fut, Self: Sized,
source§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,
    Self: Sized,
 
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, Self: Sized,
source§fn try_flatten_unordered(
    self,
    limit: impl Into<Option<usize>>
) -> TryFlattenUnordered<Self>where
    Self::Ok: TryStream + Unpin,
    <Self::Ok as TryStream>::Error: From<Self::Error>,
    Self: Sized,
 
fn try_flatten_unordered( self, limit: impl Into<Option<usize>> ) -> TryFlattenUnordered<Self>where Self::Ok: TryStream + Unpin, <Self::Ok as TryStream>::Error: From<Self::Error>, Self: Sized,
source§fn try_flatten(self) -> TryFlatten<Self>where
    Self::Ok: TryStream,
    <Self::Ok as TryStream>::Error: From<Self::Error>,
    Self: Sized,
 
fn try_flatten(self) -> TryFlatten<Self>where Self::Ok: TryStream, <Self::Ok as TryStream>::Error: From<Self::Error>, Self: Sized,
source§fn try_fold<T, Fut, F>(self, init: T, f: F) -> TryFold<Self, Fut, T, F> ⓘwhere
    F: FnMut(T, Self::Ok) -> Fut,
    Fut: TryFuture<Ok = T, Error = Self::Error>,
    Self: Sized,
 
fn try_fold<T, Fut, F>(self, init: T, f: F) -> TryFold<Self, Fut, T, F> ⓘwhere F: FnMut(T, Self::Ok) -> Fut, Fut: TryFuture<Ok = T, Error = Self::Error>, Self: Sized,
source§fn try_concat(self) -> TryConcat<Self> ⓘwhere
    Self: Sized,
    Self::Ok: Extend<<<Self as TryStream>::Ok as IntoIterator>::Item> + IntoIterator + Default,
 
fn try_concat(self) -> TryConcat<Self> ⓘwhere Self: Sized, Self::Ok: Extend<<<Self as TryStream>::Ok as IntoIterator>::Item> + IntoIterator + Default,
source§fn try_buffer_unordered(self, n: usize) -> TryBufferUnordered<Self>where
    Self::Ok: TryFuture<Error = Self::Error>,
    Self: Sized,
 
fn try_buffer_unordered(self, n: usize) -> TryBufferUnordered<Self>where Self::Ok: TryFuture<Error = Self::Error>, Self: Sized,
source§fn try_buffered(self, n: usize) -> TryBuffered<Self>where
    Self::Ok: TryFuture<Error = Self::Error>,
    Self: Sized,
 
fn try_buffered(self, n: usize) -> TryBuffered<Self>where Self::Ok: TryFuture<Error = Self::Error>, Self: Sized,
source§fn 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,
TryStream::try_poll_next on Unpin
stream types.source§fn into_async_read(self) -> IntoAsyncRead<Self>where
    Self: Sized + TryStreamExt<Error = Error>,
    Self::Ok: AsRef<[u8]>,
 
fn into_async_read(self) -> IntoAsyncRead<Self>where Self: Sized + TryStreamExt<Error = Error>, Self::Ok: AsRef<[u8]>,
AsyncBufRead. Read more