Struct futures::stream::TryFilterMap [−][src]
Stream for the try_filter_map
method.
Implementations
impl<St, Fut, F> TryFilterMap<St, Fut, F>[src]
pub fn get_ref(&self) -> &Stⓘ[src]
Acquires a reference to the underlying sink or stream that this combinator is pulling from.
pub fn get_mut(&mut self) -> &mut Stⓘ[src]
Acquires a mutable reference to the underlying sink or stream that this combinator is pulling from.
Note that care must be taken to avoid tampering with the state of the sink or stream which may otherwise confuse this combinator.
pub fn get_pin_mut(self: Pin<&mut TryFilterMap<St, Fut, F>>) -> Pin<&mut St>ⓘ[src]
Acquires a pinned mutable reference to the underlying sink or stream that this combinator is pulling from.
Note that care must be taken to avoid tampering with the state of the sink or stream which may otherwise confuse this combinator.
pub fn into_inner(self) -> St[src]
Consumes this combinator, returning the underlying sink or stream.
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
impl<St, Fut, F> Debug for TryFilterMap<St, Fut, F> where
Fut: Debug,
St: Debug, [src]
Fut: Debug,
St: Debug,
impl<St, Fut, F, T> FusedStream for TryFilterMap<St, Fut, F> where
F: FnMut(<St as TryStream>::Ok) -> Fut,
Fut: TryFuture<Ok = Option<T>, Error = <St as TryStream>::Error>,
St: TryStream + FusedStream, [src]
F: FnMut(<St as TryStream>::Ok) -> Fut,
Fut: TryFuture<Ok = Option<T>, Error = <St as TryStream>::Error>,
St: TryStream + FusedStream,
pub fn is_terminated(&self) -> bool[src]
impl<S, Fut, F, Item> Sink<Item> for TryFilterMap<S, Fut, F> where
S: Sink<Item>, [src]
S: Sink<Item>,
type Error = <S as Sink<Item>>::Error
The type of value produced by the sink when an error occurs.
pub fn poll_ready(
self: Pin<&mut TryFilterMap<S, Fut, F>>,
cx: &mut Context<'_>
) -> Poll<Result<(), <TryFilterMap<S, Fut, F> as Sink<Item>>::Error>>[src]
self: Pin<&mut TryFilterMap<S, Fut, F>>,
cx: &mut Context<'_>
) -> Poll<Result<(), <TryFilterMap<S, Fut, F> as Sink<Item>>::Error>>
pub fn start_send(
self: Pin<&mut TryFilterMap<S, Fut, F>>,
item: Item
) -> Result<(), <TryFilterMap<S, Fut, F> as Sink<Item>>::Error>[src]
self: Pin<&mut TryFilterMap<S, Fut, F>>,
item: Item
) -> Result<(), <TryFilterMap<S, Fut, F> as Sink<Item>>::Error>
pub fn poll_flush(
self: Pin<&mut TryFilterMap<S, Fut, F>>,
cx: &mut Context<'_>
) -> Poll<Result<(), <TryFilterMap<S, Fut, F> as Sink<Item>>::Error>>[src]
self: Pin<&mut TryFilterMap<S, Fut, F>>,
cx: &mut Context<'_>
) -> Poll<Result<(), <TryFilterMap<S, Fut, F> as Sink<Item>>::Error>>
pub fn poll_close(
self: Pin<&mut TryFilterMap<S, Fut, F>>,
cx: &mut Context<'_>
) -> Poll<Result<(), <TryFilterMap<S, Fut, F> as Sink<Item>>::Error>>[src]
self: Pin<&mut TryFilterMap<S, Fut, F>>,
cx: &mut Context<'_>
) -> Poll<Result<(), <TryFilterMap<S, Fut, F> as Sink<Item>>::Error>>
impl<St, Fut, F, T> Stream for TryFilterMap<St, Fut, F> where
F: FnMut(<St as TryStream>::Ok) -> Fut,
Fut: TryFuture<Ok = Option<T>, Error = <St as TryStream>::Error>,
St: TryStream, [src]
F: FnMut(<St as TryStream>::Ok) -> Fut,
Fut: TryFuture<Ok = Option<T>, Error = <St as TryStream>::Error>,
St: TryStream,
type Item = Result<T, <St as TryStream>::Error>
Values yielded by the stream.
pub fn poll_next(
self: Pin<&mut TryFilterMap<St, Fut, F>>,
cx: &mut Context<'_>
) -> Poll<Option<<TryFilterMap<St, Fut, F> as Stream>::Item>>[src]
self: Pin<&mut TryFilterMap<St, Fut, F>>,
cx: &mut Context<'_>
) -> Poll<Option<<TryFilterMap<St, Fut, F> as Stream>::Item>>
pub fn size_hint(&self) -> (usize, Option<usize>)[src]
impl<'__pin, St, Fut, F> Unpin for TryFilterMap<St, Fut, F> where
__Origin<'__pin, St, Fut, F>: Unpin, [src]
__Origin<'__pin, St, Fut, F>: Unpin,
Auto Trait Implementations
impl<St, Fut, F> RefUnwindSafe for TryFilterMap<St, Fut, F> where
F: RefUnwindSafe,
Fut: RefUnwindSafe,
St: RefUnwindSafe,
F: RefUnwindSafe,
Fut: RefUnwindSafe,
St: RefUnwindSafe,
impl<St, Fut, F> Send for TryFilterMap<St, Fut, F> where
F: Send,
Fut: Send,
St: Send,
F: Send,
Fut: Send,
St: Send,
impl<St, Fut, F> Sync for TryFilterMap<St, Fut, F> where
F: Sync,
Fut: Sync,
St: Sync,
F: Sync,
Fut: Sync,
St: Sync,
impl<St, Fut, F> UnwindSafe for TryFilterMap<St, Fut, F> where
F: UnwindSafe,
Fut: UnwindSafe,
St: UnwindSafe,
F: UnwindSafe,
Fut: UnwindSafe,
St: UnwindSafe,
Blanket Implementations
impl<T> Any for T where
T: 'static + ?Sized, [src]
T: 'static + ?Sized,
impl<T> Borrow<T> for T where
T: ?Sized, [src]
T: ?Sized,
impl<T> BorrowMut<T> for T where
T: ?Sized, [src]
T: ?Sized,
pub fn borrow_mut(&mut self) -> &mut Tⓘ[src]
impl<T> From<T> for T[src]
impl<T, U> Into<U> for T where
U: From<T>, [src]
U: From<T>,
impl<T, Item> SinkExt<Item> for T where
T: Sink<Item> + ?Sized, [src]
T: Sink<Item> + ?Sized,
pub fn with<U, Fut, F, E>(self, f: F) -> With<Self, Item, U, Fut, F> where
E: From<Self::Error>,
F: FnMut(U) -> Fut,
Fut: Future<Output = Result<Item, E>>, [src]
E: From<Self::Error>,
F: FnMut(U) -> Fut,
Fut: Future<Output = Result<Item, E>>,
pub fn with_flat_map<U, St, F>(self, f: F) -> WithFlatMap<Self, Item, U, St, F> where
F: FnMut(U) -> St,
St: Stream<Item = Result<Item, Self::Error>>, [src]
F: FnMut(U) -> St,
St: Stream<Item = Result<Item, Self::Error>>,
pub fn sink_map_err<E, F>(self, f: F) -> SinkMapErr<Self, F> where
F: FnOnce(Self::Error) -> E, [src]
F: FnOnce(Self::Error) -> E,
pub fn sink_err_into<E>(self) -> SinkErrInto<Self, Item, E> where
Self::Error: Into<E>, [src]
Self::Error: Into<E>,
pub fn buffer(self, capacity: usize) -> Buffer<Self, Item>[src]
pub fn close(&mut self) -> Close<'_, Self, Item>ⓘ where
Self: Unpin, [src]
Self: Unpin,
pub fn fanout<Si>(self, other: Si) -> Fanout<Self, Si> where
Item: Clone,
Si: Sink<Item, Error = Self::Error>, [src]
Item: Clone,
Si: Sink<Item, Error = Self::Error>,
pub fn flush(&mut self) -> Flush<'_, Self, Item>ⓘ where
Self: Unpin, [src]
Self: Unpin,
pub fn send(&mut self, item: Item) -> Send<'_, Self, Item>ⓘ where
Self: Unpin, [src]
Self: Unpin,
pub fn feed(&mut self, item: Item) -> Feed<'_, Self, Item>ⓘ where
Self: Unpin, [src]
Self: Unpin,
pub fn send_all<St>(&'a mut self, stream: &'a mut St) -> SendAll<'a, Self, St>ⓘ where
Self: Unpin,
St: TryStream<Ok = Item, Error = Self::Error> + Stream + Unpin + ?Sized, [src]
Self: Unpin,
St: TryStream<Ok = Item, Error = Self::Error> + Stream + Unpin + ?Sized,
pub fn left_sink<Si2>(self) -> Either<Self, Si2>ⓘ where
Si2: Sink<Item, Error = Self::Error>, [src]
Si2: Sink<Item, Error = Self::Error>,
pub fn right_sink<Si1>(self) -> Either<Si1, Self>ⓘ where
Si1: Sink<Item, Error = Self::Error>, [src]
Si1: Sink<Item, Error = Self::Error>,
pub fn poll_ready_unpin(
&mut self,
cx: &mut Context<'_>
) -> Poll<Result<(), Self::Error>> where
Self: Unpin, [src]
&mut self,
cx: &mut Context<'_>
) -> Poll<Result<(), Self::Error>> where
Self: Unpin,
pub fn start_send_unpin(&mut self, item: Item) -> Result<(), Self::Error> where
Self: Unpin, [src]
Self: Unpin,
pub fn poll_flush_unpin(
&mut self,
cx: &mut Context<'_>
) -> Poll<Result<(), Self::Error>> where
Self: Unpin, [src]
&mut self,
cx: &mut Context<'_>
) -> Poll<Result<(), Self::Error>> where
Self: Unpin,
pub fn poll_close_unpin(
&mut self,
cx: &mut Context<'_>
) -> Poll<Result<(), Self::Error>> where
Self: Unpin, [src]
&mut self,
cx: &mut Context<'_>
) -> Poll<Result<(), Self::Error>> where
Self: Unpin,
impl<T> StreamExt for T where
T: Stream + ?Sized, [src]
T: Stream + ?Sized,
pub fn next(&mut self) -> Next<'_, Self>ⓘ where
Self: Unpin, [src]
Self: Unpin,
pub fn into_future(self) -> StreamFuture<Self>ⓘ where
Self: Unpin, [src]
Self: Unpin,
pub fn map<T, F>(self, f: F) -> Map<Self, F> where
F: FnMut(Self::Item) -> T, [src]
F: FnMut(Self::Item) -> T,
pub fn enumerate(self) -> Enumerate<Self>[src]
pub fn filter<Fut, F>(self, f: F) -> Filter<Self, Fut, F> where
F: FnMut(&Self::Item) -> Fut,
Fut: Future<Output = bool>, [src]
F: FnMut(&Self::Item) -> Fut,
Fut: Future<Output = bool>,
pub fn filter_map<Fut, T, F>(self, f: F) -> FilterMap<Self, Fut, F> where
F: FnMut(Self::Item) -> Fut,
Fut: Future<Output = Option<T>>, [src]
F: FnMut(Self::Item) -> Fut,
Fut: Future<Output = Option<T>>,
pub fn then<Fut, F>(self, f: F) -> Then<Self, Fut, F> where
F: FnMut(Self::Item) -> Fut,
Fut: Future, [src]
F: FnMut(Self::Item) -> Fut,
Fut: Future,
pub fn collect<C>(self) -> Collect<Self, C>ⓘ where
C: Default + Extend<Self::Item>, [src]
C: Default + Extend<Self::Item>,
pub fn unzip<A, B, FromA, FromB>(self) -> Unzip<Self, FromA, FromB>ⓘ where
Self: Stream<Item = (A, B)>,
FromA: Default + Extend<A>,
FromB: Default + Extend<B>, [src]
Self: Stream<Item = (A, B)>,
FromA: Default + Extend<A>,
FromB: Default + Extend<B>,
pub fn concat(self) -> Concat<Self>ⓘ where
Self::Item: Extend<<Self::Item as IntoIterator>::Item>,
Self::Item: IntoIterator,
Self::Item: Default, [src]
Self::Item: Extend<<Self::Item as IntoIterator>::Item>,
Self::Item: IntoIterator,
Self::Item: Default,
pub fn cycle(self) -> Cycle<Self> where
Self: Clone, [src]
Self: Clone,
pub 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>, [src]
F: FnMut(T, Self::Item) -> Fut,
Fut: Future<Output = T>,
pub fn flatten(self) -> Flatten<Self> where
Self::Item: Stream, [src]
Self::Item: Stream,
pub fn flat_map<U, F>(self, f: F) -> FlatMap<Self, U, F> where
F: FnMut(Self::Item) -> U,
U: Stream, [src]
F: FnMut(Self::Item) -> U,
U: Stream,
pub 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>>, [src]
F: FnMut(&mut S, Self::Item) -> Fut,
Fut: Future<Output = Option<B>>,
pub fn skip_while<Fut, F>(self, f: F) -> SkipWhile<Self, Fut, F> where
F: FnMut(&Self::Item) -> Fut,
Fut: Future<Output = bool>, [src]
F: FnMut(&Self::Item) -> Fut,
Fut: Future<Output = bool>,
pub fn take_while<Fut, F>(self, f: F) -> TakeWhile<Self, Fut, F> where
F: FnMut(&Self::Item) -> Fut,
Fut: Future<Output = bool>, [src]
F: FnMut(&Self::Item) -> Fut,
Fut: Future<Output = bool>,
pub fn take_until<Fut>(self, fut: Fut) -> TakeUntil<Self, Fut> where
Fut: Future, [src]
Fut: Future,
pub fn for_each<Fut, F>(self, f: F) -> ForEach<Self, Fut, F>ⓘ where
F: FnMut(Self::Item) -> Fut,
Fut: Future<Output = ()>, [src]
F: FnMut(Self::Item) -> Fut,
Fut: Future<Output = ()>,
pub 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 = ()>, [src]
self,
limit: impl Into<Option<usize>>,
f: F
) -> ForEachConcurrent<Self, Fut, F>ⓘ where
F: FnMut(Self::Item) -> Fut,
Fut: Future<Output = ()>,
pub fn take(self, n: usize) -> Take<Self>[src]
pub fn skip(self, n: usize) -> Skip<Self>[src]
pub fn fuse(self) -> Fuse<Self>[src]
pub fn by_ref(&mut self) -> &mut Selfⓘ[src]
pub fn catch_unwind(self) -> CatchUnwind<Self> where
Self: UnwindSafe, [src]
Self: UnwindSafe,
pub fn boxed<'a>(
self
) -> Pin<Box<dyn Stream<Item = Self::Item> + 'a + Send, Global>>ⓘ where
Self: Send + 'a, [src]
self
) -> Pin<Box<dyn Stream<Item = Self::Item> + 'a + Send, Global>>ⓘ where
Self: Send + 'a,
pub fn boxed_local<'a>(
self
) -> Pin<Box<dyn Stream<Item = Self::Item> + 'a, Global>>ⓘ where
Self: 'a, [src]
self
) -> Pin<Box<dyn Stream<Item = Self::Item> + 'a, Global>>ⓘ where
Self: 'a,
pub fn buffered(self, n: usize) -> Buffered<Self> where
Self::Item: Future, [src]
Self::Item: Future,
pub fn buffer_unordered(self, n: usize) -> BufferUnordered<Self> where
Self::Item: Future, [src]
Self::Item: Future,
pub fn zip<St>(self, other: St) -> Zip<Self, St> where
St: Stream, [src]
St: Stream,
pub fn chain<St>(self, other: St) -> Chain<Self, St> where
St: Stream<Item = Self::Item>, [src]
St: Stream<Item = Self::Item>,
pub fn peekable(self) -> Peekable<Self>[src]
pub fn chunks(self, capacity: usize) -> Chunks<Self>[src]
pub fn ready_chunks(self, capacity: usize) -> ReadyChunks<Self>[src]
pub fn forward<S>(self, sink: S) -> Forward<Self, S>ⓘ where
Self: TryStream,
S: Sink<Self::Ok, Error = Self::Error>, [src]
Self: TryStream,
S: Sink<Self::Ok, Error = Self::Error>,
pub fn split<Item>(self) -> (SplitSink<Self, Item>, SplitStream<Self>) where
Self: Sink<Item>, [src]
Self: Sink<Item>,
pub fn inspect<F>(self, f: F) -> Inspect<Self, F> where
F: FnMut(&Self::Item), [src]
F: FnMut(&Self::Item),
pub fn left_stream<B>(self) -> Either<Self, B>ⓘ where
B: Stream<Item = Self::Item>, [src]
B: Stream<Item = Self::Item>,
pub fn right_stream<B>(self) -> Either<B, Self>ⓘ where
B: Stream<Item = Self::Item>, [src]
B: Stream<Item = Self::Item>,
pub fn poll_next_unpin(
&mut self,
cx: &mut Context<'_>
) -> Poll<Option<Self::Item>> where
Self: Unpin, [src]
&mut self,
cx: &mut Context<'_>
) -> Poll<Option<Self::Item>> where
Self: Unpin,
pub 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, [src]
Notable traits for SelectNextSome<'_, St>
impl<'_, St> Future for SelectNextSome<'_, St> where
St: FusedStream + Unpin + ?Sized, type Output = <St as Stream>::Item;Self: Unpin + FusedStream,
impl<T, U> TryFrom<U> for T where
U: Into<T>, [src]
U: Into<T>,
type Error = Infallible
The type returned in the event of a conversion error.
pub fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>[src]
impl<T, U> TryInto<U> for T where
U: TryFrom<T>, [src]
U: TryFrom<T>,
type Error = <U as TryFrom<T>>::Error
The type returned in the event of a conversion error.
pub fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>[src]
impl<S, T, E> TryStream for S where
S: Stream<Item = Result<T, E>> + ?Sized, [src]
S: Stream<Item = Result<T, E>> + ?Sized,
type Ok = T
The type of successful values yielded by this future
type Error = E
The type of failures yielded by this future
pub fn try_poll_next(
self: Pin<&mut S>,
cx: &mut Context<'_>
) -> Poll<Option<Result<<S as TryStream>::Ok, <S as TryStream>::Error>>>[src]
self: Pin<&mut S>,
cx: &mut Context<'_>
) -> Poll<Option<Result<<S as TryStream>::Ok, <S as TryStream>::Error>>>
impl<S> TryStreamExt for S where
S: TryStream + ?Sized, [src]
S: TryStream + ?Sized,
pub fn err_into<E>(self) -> ErrInto<Self, E> where
Self::Error: Into<E>, [src]
Self::Error: Into<E>,
pub fn map_ok<T, F>(self, f: F) -> MapOk<Self, F> where
F: FnMut(Self::Ok) -> T, [src]
F: FnMut(Self::Ok) -> T,
pub fn map_err<E, F>(self, f: F) -> MapErr<Self, F> where
F: FnMut(Self::Error) -> E, [src]
F: FnMut(Self::Error) -> E,
pub fn and_then<Fut, F>(self, f: F) -> AndThen<Self, Fut, F> where
F: FnMut(Self::Ok) -> Fut,
Fut: TryFuture<Error = Self::Error>, [src]
F: FnMut(Self::Ok) -> Fut,
Fut: TryFuture<Error = Self::Error>,
pub fn or_else<Fut, F>(self, f: F) -> OrElse<Self, Fut, F> where
F: FnMut(Self::Error) -> Fut,
Fut: TryFuture<Ok = Self::Ok>, [src]
F: FnMut(Self::Error) -> Fut,
Fut: TryFuture<Ok = Self::Ok>,
pub fn inspect_ok<F>(self, f: F) -> InspectOk<Self, F> where
F: FnMut(&Self::Ok), [src]
F: FnMut(&Self::Ok),
pub fn inspect_err<F>(self, f: F) -> InspectErr<Self, F> where
F: FnMut(&Self::Error), [src]
F: FnMut(&Self::Error),
pub fn into_stream(self) -> IntoStream<Self>[src]
pub fn try_next(&mut self) -> TryNext<'_, Self>ⓘ where
Self: Unpin, [src]
Self: Unpin,
pub 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>, [src]
F: FnMut(Self::Ok) -> Fut,
Fut: TryFuture<Ok = (), Error = Self::Error>,
pub 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>, [src]
F: FnMut(&Self::Ok) -> Fut,
Fut: TryFuture<Ok = bool, Error = Self::Error>,
pub 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>, [src]
F: FnMut(&Self::Ok) -> Fut,
Fut: TryFuture<Ok = bool, Error = Self::Error>,
pub 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>>, [src]
self,
limit: impl Into<Option<usize>>,
f: F
) -> TryForEachConcurrent<Self, Fut, F>ⓘ where
F: FnMut(Self::Ok) -> Fut,
Fut: Future<Output = Result<(), Self::Error>>,
pub fn try_collect<C>(self) -> TryCollect<Self, C>ⓘ where
C: Default + Extend<Self::Ok>, [src]
C: Default + Extend<Self::Ok>,
pub fn try_filter<Fut, F>(self, f: F) -> TryFilter<Self, Fut, F> where
F: FnMut(&Self::Ok) -> Fut,
Fut: Future<Output = bool>, [src]
F: FnMut(&Self::Ok) -> Fut,
Fut: Future<Output = bool>,
pub fn try_filter_map<Fut, F, T>(self, f: F) -> TryFilterMap<Self, Fut, F> where
F: FnMut(Self::Ok) -> Fut,
Fut: TryFuture<Ok = Option<T>, Error = Self::Error>, [src]
F: FnMut(Self::Ok) -> Fut,
Fut: TryFuture<Ok = Option<T>, Error = Self::Error>,
pub fn try_flatten(self) -> TryFlatten<Self> where
Self::Ok: TryStream,
<Self::Ok as TryStream>::Error: From<Self::Error>, [src]
Self::Ok: TryStream,
<Self::Ok as TryStream>::Error: From<Self::Error>,
pub 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>, [src]
F: FnMut(T, Self::Ok) -> Fut,
Fut: TryFuture<Ok = T, Error = Self::Error>,
pub 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, [src]
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>;Self::Ok: Extend<<Self::Ok as IntoIterator>::Item>,
Self::Ok: IntoIterator,
Self::Ok: Default,
pub fn try_buffer_unordered(self, n: usize) -> TryBufferUnordered<Self> where
Self::Ok: TryFuture,
<Self::Ok as TryFuture>::Error == Self::Error, [src]
Self::Ok: TryFuture,
<Self::Ok as TryFuture>::Error == Self::Error,
pub fn try_buffered(self, n: usize) -> TryBuffered<Self> where
Self::Ok: TryFuture,
<Self::Ok as TryFuture>::Error == Self::Error, [src]
Self::Ok: TryFuture,
<Self::Ok as TryFuture>::Error == Self::Error,
pub fn try_poll_next_unpin(
&mut self,
cx: &mut Context<'_>
) -> Poll<Option<Result<Self::Ok, Self::Error>>> where
Self: Unpin, [src]
&mut self,
cx: &mut Context<'_>
) -> Poll<Option<Result<Self::Ok, Self::Error>>> where
Self: Unpin,
pub fn into_async_read(self) -> IntoAsyncRead<Self> where
Self: TryStreamExt<Error = Error> + Unpin,
Self::Ok: AsRef<[u8]>, [src]
Self: TryStreamExt<Error = Error> + Unpin,
Self::Ok: AsRef<[u8]>,