[−][src]Struct futures::sink::WithFlatMap

[+] Show declaration

[+] Expand attributes
#[must_use = "sinks do nothing unless polled"]pub struct WithFlatMap<Si, Item, U, St, F> { /* fields omitted */ }

[−]

Sink for the with_flat_map method.

Implementations

`impl<Si, Item, U, St, F> WithFlatMap<Si, Item, U, St, F> where F: FnMut(U) -> St, Si: Sink<Item>, St: Stream<Item = Result<Item, <Si as Sink<Item>>::Error>>,` [src][−]

`pub fn get_ref(&self) -> &Si`[src][−]

Get a shared reference to the inner sink.

`pub fn get_mut(&mut self) -> &mut Si`[src][−]

Get a mutable reference to the inner sink.

`pub fn get_pin_mut( self: Pin<&mut WithFlatMap<Si, Item, U, St, F>> ) -> Pin<&mut Si>`[src][−]

Get a pinned mutable reference to the inner sink.

`pub fn into_inner(self) -> Si`[src][−]

Consumes this combinator, returning the underlying sink.

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<Si, Item, U, St, F> Debug for WithFlatMap<Si, Item, U, St, F> where Item: Debug, Si: Debug, St: Debug,` [src][+]

[+] Show hidden undocumented items

`fn fmt(&self, f: &mut Formatter) -> Result<(), Error>`[src][−]

`impl<S, Item, U, St, F> FusedStream for WithFlatMap<S, Item, U, St, F> where F: FnMut(U) -> St, S: FusedStream + Sink<Item>, St: Stream<Item = Result<Item, <S as Sink<Item>>::Error>>,` [src][+]

[+] Show hidden undocumented items

`fn is_terminated(&self) -> bool`[src][−]

`impl<Si, Item, U, St, F> Sink for WithFlatMap<Si, Item, U, St, F> where F: FnMut(U) -> St, Si: Sink<Item>, St: Stream<Item = Result<Item, <Si as Sink<Item>>::Error>>,` [src][+]

[+] Show hidden undocumented items

`type Error = <Si as Sink<Item>>::Error`

The type of value produced by the sink when an error occurs.

`fn poll_ready( self: Pin<&mut WithFlatMap<Si, Item, U, St, F>>, cx: &mut Context ) -> Poll<Result<(), <WithFlatMap<Si, Item, U, St, F> as Sink>::Error>>`[src][−]

`fn start_send( self: Pin<&mut WithFlatMap<Si, Item, U, St, F>>, item: U ) -> Result<(), <WithFlatMap<Si, Item, U, St, F> as Sink>::Error>`[src][−]

`fn poll_flush( self: Pin<&mut WithFlatMap<Si, Item, U, St, F>>, cx: &mut Context ) -> Poll<Result<(), <WithFlatMap<Si, Item, U, St, F> as Sink>::Error>>`[src][−]

`fn poll_close( self: Pin<&mut WithFlatMap<Si, Item, U, St, F>>, cx: &mut Context ) -> Poll<Result<(), <WithFlatMap<Si, Item, U, St, F> as Sink>::Error>>`[src][−]

`impl<S, Item, U, St, F> Stream for WithFlatMap<S, Item, U, St, F> where F: FnMut(U) -> St, S: Stream + Sink<Item>, St: Stream<Item = Result<Item, <S as Sink<Item>>::Error>>,` [src][+]

[+] Show hidden undocumented items

`type Item = <S as Stream>::Item`

Values yielded by the stream.

`fn poll_next( self: Pin<&mut WithFlatMap<S, Item, U, St, F>>, cx: &mut Context ) -> Poll<Option<<S as Stream>::Item>>`[src][−]

`fn size_hint(&self) -> (usize, Option<usize>)`[src][−]

`impl<Si, Item, U, St, F> Unpin for WithFlatMap<Si, Item, U, St, F> where Si: Unpin, St: Unpin,` [src]

Auto Trait Implementations

`impl<Si, Item, U, St, F> RefUnwindSafe for WithFlatMap<Si, Item, U, St, F> where F: RefUnwindSafe, Item: RefUnwindSafe, Si: RefUnwindSafe, St: RefUnwindSafe,`

`impl<Si, Item, U, St, F> Send for WithFlatMap<Si, Item, U, St, F> where F: Send, Item: Send, Si: Send, St: Send,`

`impl<Si, Item, U, St, F> Sync for WithFlatMap<Si, Item, U, St, F> where F: Sync, Item: Sync, Si: Sync, St: Sync,`

`impl<Si, Item, U, St, F> UnwindSafe for WithFlatMap<Si, Item, U, St, F> where F: UnwindSafe, Item: UnwindSafe, Si: UnwindSafe, St: UnwindSafe,`

Blanket Implementations

`impl<T> Any for T where T: 'static + ?Sized,` [src][+]

[+] Show hidden undocumented items

`fn type_id(&self) -> TypeId`[src][−]

`impl<T> Borrow<T> for T where T: ?Sized,` [src][+]

[+] Show hidden undocumented items

`fn borrow(&self) -> &T`[src][−]

`impl<T> BorrowMut<T> for T where T: ?Sized,` [src][+]

[+] Show hidden undocumented items

`fn borrow_mut(&mut self) -> &mut T`[src][−]

`impl<T> From<T> for T`[src][+]

[+] Show hidden undocumented items

`fn from(t: T) -> T`[src][−]

`impl<T, U> Into for T where U: From<T>,` [src][+]

[+] Show hidden undocumented items

`fn into(self) -> U`[src][−]

`impl<T, Item> SinkExt<Item> for T where T: Sink<Item> + ?Sized,` [src][+]

[+] Show hidden undocumented items

`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][−]

`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][−]

`fn sink_map_err<E, F>(self, f: F) -> SinkMapErr<Self, F> where F: FnOnce(Self::Error) -> E,` [src][−]

`fn sink_err_into<E>(self) -> SinkErrInto<Self, Item, E> where Self::Error: Into<E>,` [src][−]

`fn buffer(self, capacity: usize) -> Buffer<Self, Item>`[src][−]

`fn close(&mut self) -> Close<Self, Item> where Self: Unpin,` [src][−]

`fn fanout<Si>(self, other: Si) -> Fanout<Self, Si> where Item: Clone, Si: Sink<Item, Error = Self::Error>,` [src][−]

`fn flush(&mut self) -> Flush<Self, Item> where Self: Unpin,` [src][−]

`fn send(&mut self, item: Item) -> Send<Self, Item> where Self: Unpin,` [src][−]

`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][−]

`fn left_sink<Si2>(self) -> Either<Self, Si2> where Si2: Sink<Item, Error = Self::Error>,` [src][−]

`fn right_sink<Si1>(self) -> Either<Si1, Self> where Si1: Sink<Item, Error = Self::Error>,` [src][−]

`impl<T> StreamExt for T where T: Stream + ?Sized,` [src][+]

[+] Show hidden undocumented items

`fn next(&mut self) -> Next<Self> where Self: Unpin,` [src][−]

`fn into_future(self) -> StreamFuture<Self> where Self: Unpin,` [src][−]

`fn map<T, F>(self, f: F) -> Map<Self, F> where F: FnMut(Self::Item) -> T,` [src][−]

`fn enumerate(self) -> Enumerate<Self>`[src][−]

`fn filter<Fut, F>(self, f: F) -> Filter<Self, Fut, F> where F: FnMut(&Self::Item) -> Fut, Fut: Future<Output = bool>,` [src][−]

`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][−]

`fn then<Fut, F>(self, f: F) -> Then<Self, Fut, F> where F: FnMut(Self::Item) -> Fut, Fut: Future,` [src][−]

`fn collect<C>(self) -> Collect<Self, C> where C: Default + Extend<Self::Item>,` [src][−]

`fn concat(self) -> Concat<Self> where Self::Item: Extend<<Self::Item as IntoIterator>::Item>, Self::Item: IntoIterator, Self::Item: Default,` [src][−]

`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][−]

`fn flatten(self) -> Flatten<Self> where Self::Item: Stream,` [src][−]

`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>,` [src][−]

`fn skip_while<Fut, F>(self, f: F) -> SkipWhile<Self, Fut, F> where F: FnMut(&Self::Item) -> Fut, Fut: Future<Output = bool>,` [src][−]

`fn take_while<Fut, F>(self, f: F) -> TakeWhile<Self, Fut, F> where F: FnMut(&Self::Item) -> Fut, Fut: Future<Output = bool>,` [src][−]

`fn for_each<Fut, F>(self, f: F) -> ForEach<Self, Fut, F> where F: FnMut(Self::Item) -> Fut, Fut: Future<Output = ()>,` [src][−]

`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][−]

`fn take(self, n: usize) -> Take<Self>`[src][−]

`fn skip(self, n: usize) -> Skip<Self>`[src][−]

`fn fuse(self) -> Fuse<Self>`[src][−]

`fn by_ref(&mut self) -> &mut Self`[src][−]

`fn catch_unwind(self) -> CatchUnwind<Self> where Self: UnwindSafe,` [src][−]

`fn boxed<'a>(self) -> Pin<Box<dyn Stream<Item = Self::Item> + 'a + Send>> where Self: Send + 'a,` [src][−]

`fn boxed_local<'a>(self) -> Pin<Box<dyn Stream<Item = Self::Item> + 'a>> where Self: 'a,` [src][−]

`fn buffered(self, n: usize) -> Buffered<Self> where Self::Item: Future,` [src][−]

`fn buffer_unordered(self, n: usize) -> BufferUnordered<Self> where Self::Item: Future,` [src][−]

`fn zip<St>(self, other: St) -> Zip<Self, St> where St: Stream,` [src][−]

`fn chain<St>(self, other: St) -> Chain<Self, St> where St: Stream<Item = Self::Item>,` [src][−]

`fn peekable(self) -> Peekable<Self>`[src][−]

`fn chunks(self, capacity: usize) -> Chunks<Self>`[src][−]

`fn forward<S>(self, sink: S) -> Forward<Self, S> where S: Sink<Self::Ok>, Self: TryStream<Error = <S as Sink<Self::Ok>>::Error>,` [src][−]

`fn split<Item>(self) -> (SplitSink<Self, Item>, SplitStream<Self>) where Self: Sink<Item>,` [src][−]

`fn inspect<F>(self, f: F) -> Inspect<Self, F> where F: FnMut(&Self::Item),` [src][−]

`fn left_stream(self) -> Either<Self, B> where B: Stream<Item = Self::Item>,` [src][−]

`fn right_stream(self) -> Either<B, Self> where B: Stream<Item = Self::Item>,` [src][−]

`fn poll_next_unpin(&mut self, cx: &mut Context) -> Poll<Option<Self::Item>> where Self: Unpin,` [src][−]

`fn select_next_some(&mut self) -> SelectNextSome<Self> where Self: Unpin + FusedStream,` [src][−]

`impl<T, U> TryFrom for T where U: Into<T>,` [src][+]

[+] Show hidden undocumented items

`type Error = Infallible`

The type returned in the event of a conversion error.

`fn try_from(value: U) -> Result<T, <T as TryFrom>::Error>`[src][−]

`impl<T, U> TryInto for T where U: TryFrom<T>,` [src][+]

[+] Show hidden undocumented items

`type Error = >::Error`

The type returned in the event of a conversion error.

`fn try_into(self) -> Result<U, >::Error>`[src][−]

`impl<S, T, E> TryStream for S where S: Stream<Item = Result<T, E>> + ?Sized,` [src][+]

[+] Show hidden undocumented items

`type Ok = T`

The type of successful values yielded by this future

`type Error = E`

The type of failures yielded by this future

`fn try_poll_next( self: Pin<&mut S>, cx: &mut Context ) -> Poll<Option<Result<<S as TryStream>::Ok, <S as TryStream>::Error>>>`[src][−]

`impl<S> TryStreamExt for S where S: TryStream + ?Sized,` [src][+]

[+] Show hidden undocumented items

`fn err_into<E>(self) -> ErrInto<Self, E> where Self::Error: Into<E>,` [src][−]

`fn map_ok<T, F>(self, f: F) -> MapOk<Self, F> where F: FnMut(Self::Ok) -> T,` [src][−]

`fn map_err<E, F>(self, f: F) -> MapErr<Self, F> where F: FnMut(Self::Error) -> E,` [src][−]

`fn and_then<Fut, F>(self, f: F) -> AndThen<Self, Fut, F> where F: FnMut(Self::Ok) -> Fut, Fut: TryFuture<Error = Self::Error>,` [src][−]

`fn or_else<Fut, F>(self, f: F) -> OrElse<Self, Fut, F> where F: FnMut(Self::Error) -> Fut, Fut: TryFuture<Ok = Self::Ok>,` [src][−]

`fn inspect_ok<F>(self, f: F) -> InspectOk<Self, F> where F: FnMut(&Self::Ok),` [src][−]

`fn inspect_err<F>(self, f: F) -> InspectErr<Self, F> where F: FnMut(&Self::Error),` [src][−]

`fn into_stream(self) -> IntoStream<Self>`[src][−]

`fn try_next(&mut self) -> TryNext<Self> where Self: Unpin,` [src][−]

`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][−]

`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][−]

`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][−]

`fn try_collect<C>(self) -> TryCollect<Self, C> where C: Default + Extend<Self::Ok>,` [src][−]

`fn try_filter<Fut, F>(self, f: F) -> TryFilter<Self, Fut, F> where F: FnMut(&Self::Ok) -> Fut, Fut: Future<Output = bool>,` [src][−]

`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][−]

`fn try_flatten(self) -> TryFlatten<Self> where Self::Ok: TryStream, <Self::Ok as TryStream>::Error: From<Self::Error>,` [src][−]

`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][−]

`fn try_concat(self) -> TryConcat<Self> where Self::Ok: Extend<<Self::Ok as IntoIterator>::Item>, Self::Ok: IntoIterator, Self::Ok: Default,` [src][−]

`fn try_buffer_unordered(self, n: usize) -> TryBufferUnordered<Self> where Self::Ok: TryFuture, <Self::Ok as TryFuture>::Error == Self::Error,` [src][−]

`fn try_poll_next_unpin( &mut self, cx: &mut Context ) -> Poll<Option<Result<Self::Ok, Self::Error>>> where Self: Unpin,` [src][−]

`fn into_async_read(self) -> IntoAsyncRead<Self> where Self: TryStreamExt<Error = Error> + Unpin, Self::Ok: AsRef<[u8]>,` [src][−]

[−][src]Struct futures::sink::WithFlatMap

Implementations

impl<Si, Item, U, St, F> WithFlatMap<Si, Item, U, St, F> where F: FnMut(U) -> St, Si: Sink<Item>, St: Stream<Item = Result<Item, <Si as Sink<Item>>::Error>>, [src][−]

pub fn get_ref(&self) -> &Si[src][−]

pub fn get_mut(&mut self) -> &mut Si[src][−]

pub fn get_pin_mut( self: Pin<&mut WithFlatMap<Si, Item, U, St, F>>) -> Pin<&mut Si>[src][−]

pub fn into_inner(self) -> Si[src][−]

Trait Implementations

impl<Si, Item, U, St, F> Debug for WithFlatMap<Si, Item, U, St, F> where Item: Debug, Si: Debug, St: Debug, [src][+]

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>[src][−]

impl<S, Item, U, St, F> FusedStream for WithFlatMap<S, Item, U, St, F> where F: FnMut(U) -> St, S: FusedStream + Sink<Item>, St: Stream<Item = Result<Item, <S as Sink<Item>>::Error>>, [src][+]

fn is_terminated(&self) -> bool[src][−]

impl<Si, Item, U, St, F> Sink<U> for WithFlatMap<Si, Item, U, St, F> where F: FnMut(U) -> St, Si: Sink<Item>, St: Stream<Item = Result<Item, <Si as Sink<Item>>::Error>>, [src][+]

type Error = <Si as Sink<Item>>::Error

fn poll_ready( self: Pin<&mut WithFlatMap<Si, Item, U, St, F>>, cx: &mut Context) -> Poll<Result<(), <WithFlatMap<Si, Item, U, St, F> as Sink<U>>::Error>>[src][−]

fn start_send( self: Pin<&mut WithFlatMap<Si, Item, U, St, F>>, item: U) -> Result<(), <WithFlatMap<Si, Item, U, St, F> as Sink<U>>::Error>[src][−]

fn poll_flush( self: Pin<&mut WithFlatMap<Si, Item, U, St, F>>, cx: &mut Context) -> Poll<Result<(), <WithFlatMap<Si, Item, U, St, F> as Sink<U>>::Error>>[src][−]

fn poll_close( self: Pin<&mut WithFlatMap<Si, Item, U, St, F>>, cx: &mut Context) -> Poll<Result<(), <WithFlatMap<Si, Item, U, St, F> as Sink<U>>::Error>>[src][−]

impl<S, Item, U, St, F> Stream for WithFlatMap<S, Item, U, St, F> where F: FnMut(U) -> St, S: Stream + Sink<Item>, St: Stream<Item = Result<Item, <S as Sink<Item>>::Error>>, [src][+]

type Item = <S as Stream>::Item

fn poll_next( self: Pin<&mut WithFlatMap<S, Item, U, St, F>>, cx: &mut Context) -> Poll<Option<<S as Stream>::Item>>[src][−]

fn size_hint(&self) -> (usize, Option<usize>)[src][−]

impl<Si, Item, U, St, F> Unpin for WithFlatMap<Si, Item, U, St, F> where Si: Unpin, St: Unpin, [src]

Auto Trait Implementations

impl<Si, Item, U, St, F> RefUnwindSafe for WithFlatMap<Si, Item, U, St, F> where F: RefUnwindSafe, Item: RefUnwindSafe, Si: RefUnwindSafe, St: RefUnwindSafe,

impl<Si, Item, U, St, F> Send for WithFlatMap<Si, Item, U, St, F> where F: Send, Item: Send, Si: Send, St: Send,

impl<Si, Item, U, St, F> Sync for WithFlatMap<Si, Item, U, St, F> where F: Sync, Item: Sync, Si: Sync, St: Sync,

impl<Si, Item, U, St, F> UnwindSafe for WithFlatMap<Si, Item, U, St, F> where F: UnwindSafe, Item: UnwindSafe, Si: UnwindSafe, St: UnwindSafe,

Blanket Implementations

impl<T> Any for T where T: 'static + ?Sized, [src][+]

fn type_id(&self) -> TypeId[src][−]

impl<T> Borrow<T> for T where T: ?Sized, [src][+]

fn borrow(&self) -> &T[src][−]

impl<T> BorrowMut<T> for T where T: ?Sized, [src][+]

fn borrow_mut(&mut self) -> &mut T[src][−]

impl<T> From<T> for T[src][+]

fn from(t: T) -> T[src][−]

impl<T, U> Into<U> for T where U: From<T>, [src][+]

fn into(self) -> U[src][−]

impl<T, Item> SinkExt<Item> for T where T: Sink<Item> + ?Sized, [src][+]

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][−]

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][−]

fn sink_map_err<E, F>(self, f: F) -> SinkMapErr<Self, F> where F: FnOnce(Self::Error) -> E, [src][−]

fn sink_err_into<E>(self) -> SinkErrInto<Self, Item, E> where Self::Error: Into<E>, [src][−]

fn buffer(self, capacity: usize) -> Buffer<Self, Item>[src][−]

fn close(&mut self) -> Close<Self, Item> where Self: Unpin, [src][−]

fn fanout<Si>(self, other: Si) -> Fanout<Self, Si> where Item: Clone, Si: Sink<Item, Error = Self::Error>, [src][−]

fn flush(&mut self) -> Flush<Self, Item> where Self: Unpin, [src][−]

fn send(&mut self, item: Item) -> Send<Self, Item> where Self: Unpin, [src][−]

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][−]

fn left_sink<Si2>(self) -> Either<Self, Si2> where Si2: Sink<Item, Error = Self::Error>, [src][−]

fn right_sink<Si1>(self) -> Either<Si1, Self> where Si1: Sink<Item, Error = Self::Error>, [src][−]

impl<T> StreamExt for T where T: Stream + ?Sized, [src][+]

fn next(&mut self) -> Next<Self> where Self: Unpin, [src][−]

fn into_future(self) -> StreamFuture<Self> where Self: Unpin, [src][−]

fn map<T, F>(self, f: F) -> Map<Self, F> where F: FnMut(Self::Item) -> T, [src][−]

fn enumerate(self) -> Enumerate<Self>[src][−]

fn filter<Fut, F>(self, f: F) -> Filter<Self, Fut, F> where F: FnMut(&Self::Item) -> Fut, Fut: Future<Output = bool>, [src][−]

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][−]

fn then<Fut, F>(self, f: F) -> Then<Self, Fut, F> where F: FnMut(Self::Item) -> Fut, Fut: Future, [src][−]

fn collect<C>(self) -> Collect<Self, C> where C: Default + Extend<Self::Item>, [src][−]

fn concat(self) -> Concat<Self> where Self::Item: Extend<<Self::Item as IntoIterator>::Item>, Self::Item: IntoIterator, Self::Item: Default, [src][−]

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][−]

fn flatten(self) -> Flatten<Self> where Self::Item: Stream, [src][−]

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][−]

fn skip_while<Fut, F>(self, f: F) -> SkipWhile<Self, Fut, F> where F: FnMut(&Self::Item) -> Fut, Fut: Future<Output = bool>, [src][−]

fn take_while<Fut, F>(self, f: F) -> TakeWhile<Self, Fut, F> where F: FnMut(&Self::Item) -> Fut, Fut: Future<Output = bool>, [src][−]

fn for_each<Fut, F>(self, f: F) -> ForEach<Self, Fut, F> where F: FnMut(Self::Item) -> Fut, Fut: Future<Output = ()>, [src][−]

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][−]

fn take(self, n: usize) -> Take<Self>[src][−]

fn skip(self, n: usize) -> Skip<Self>[src][−]

fn fuse(self) -> Fuse<Self>[src][−]

fn by_ref(&mut self) -> &mut Self[src][−]

fn catch_unwind(self) -> CatchUnwind<Self> where Self: UnwindSafe, [src][−]

fn boxed<'a>(self) -> Pin<Box<dyn Stream<Item = Self::Item> + 'a + Send>> where Self: Send + 'a, [src][−]

fn boxed_local<'a>(self) -> Pin<Box<dyn Stream<Item = Self::Item> + 'a>> where Self: 'a, [src][−]

fn buffered(self, n: usize) -> Buffered<Self> where Self::Item: Future, [src][−]

fn buffer_unordered(self, n: usize) -> BufferUnordered<Self> where Self::Item: Future, [src][−]

fn zip<St>(self, other: St) -> Zip<Self, St> where St: Stream, [src][−]

fn chain<St>(self, other: St) -> Chain<Self, St> where St: Stream<Item = Self::Item>, [src][−]

`impl<Si, Item, U, St, F> WithFlatMap<Si, Item, U, St, F> where F: FnMut(U) -> St, Si: Sink<Item>, St: Stream<Item = Result<Item, <Si as Sink<Item>>::Error>>,` [src][−]

`pub fn get_ref(&self) -> &Si`[src][−]

`pub fn get_mut(&mut self) -> &mut Si`[src][−]

`pub fn get_pin_mut( self: Pin<&mut WithFlatMap<Si, Item, U, St, F>> ) -> Pin<&mut Si>`[src][−]

`pub fn into_inner(self) -> Si`[src][−]

`impl<Si, Item, U, St, F> Debug for WithFlatMap<Si, Item, U, St, F> where Item: Debug, Si: Debug, St: Debug,` [src][+]

`fn fmt(&self, f: &mut Formatter) -> Result<(), Error>`[src][−]

`impl<S, Item, U, St, F> FusedStream for WithFlatMap<S, Item, U, St, F> where F: FnMut(U) -> St, S: FusedStream + Sink<Item>, St: Stream<Item = Result<Item, <S as Sink<Item>>::Error>>,` [src][+]

`fn is_terminated(&self) -> bool`[src][−]

`impl<Si, Item, U, St, F> Sink<U> for WithFlatMap<Si, Item, U, St, F> where F: FnMut(U) -> St, Si: Sink<Item>, St: Stream<Item = Result<Item, <Si as Sink<Item>>::Error>>,` [src][+]

`type Error = <Si as Sink<Item>>::Error`

`fn poll_ready( self: Pin<&mut WithFlatMap<Si, Item, U, St, F>>, cx: &mut Context ) -> Poll<Result<(), <WithFlatMap<Si, Item, U, St, F> as Sink<U>>::Error>>`[src][−]

`fn start_send( self: Pin<&mut WithFlatMap<Si, Item, U, St, F>>, item: U ) -> Result<(), <WithFlatMap<Si, Item, U, St, F> as Sink<U>>::Error>`[src][−]

`fn poll_flush( self: Pin<&mut WithFlatMap<Si, Item, U, St, F>>, cx: &mut Context ) -> Poll<Result<(), <WithFlatMap<Si, Item, U, St, F> as Sink<U>>::Error>>`[src][−]

`fn poll_close( self: Pin<&mut WithFlatMap<Si, Item, U, St, F>>, cx: &mut Context ) -> Poll<Result<(), <WithFlatMap<Si, Item, U, St, F> as Sink<U>>::Error>>`[src][−]

`impl<S, Item, U, St, F> Stream for WithFlatMap<S, Item, U, St, F> where F: FnMut(U) -> St, S: Stream + Sink<Item>, St: Stream<Item = Result<Item, <S as Sink<Item>>::Error>>,` [src][+]

`type Item = <S as Stream>::Item`

`fn poll_next( self: Pin<&mut WithFlatMap<S, Item, U, St, F>>, cx: &mut Context ) -> Poll<Option<<S as Stream>::Item>>`[src][−]

`fn size_hint(&self) -> (usize, Option<usize>)`[src][−]

`impl<Si, Item, U, St, F> Unpin for WithFlatMap<Si, Item, U, St, F> where Si: Unpin, St: Unpin,` [src]

`impl<Si, Item, U, St, F> RefUnwindSafe for WithFlatMap<Si, Item, U, St, F> where F: RefUnwindSafe, Item: RefUnwindSafe, Si: RefUnwindSafe, St: RefUnwindSafe,`

`impl<Si, Item, U, St, F> Send for WithFlatMap<Si, Item, U, St, F> where F: Send, Item: Send, Si: Send, St: Send,`

`impl<Si, Item, U, St, F> Sync for WithFlatMap<Si, Item, U, St, F> where F: Sync, Item: Sync, Si: Sync, St: Sync,`

`impl<Si, Item, U, St, F> UnwindSafe for WithFlatMap<Si, Item, U, St, F> where F: UnwindSafe, Item: UnwindSafe, Si: UnwindSafe, St: UnwindSafe,`

`impl<T> Any for T where T: 'static + ?Sized,` [src][+]

`fn type_id(&self) -> TypeId`[src][−]

`impl<T> Borrow<T> for T where T: ?Sized,` [src][+]

`fn borrow(&self) -> &T`[src][−]

`impl<T> BorrowMut<T> for T where T: ?Sized,` [src][+]

`fn borrow_mut(&mut self) -> &mut T`[src][−]

`impl<T> From<T> for T`[src][+]

`fn from(t: T) -> T`[src][−]

`impl<T, U> Into<U> for T where U: From<T>,` [src][+]

`fn into(self) -> U`[src][−]

`impl<T, Item> SinkExt<Item> for T where T: Sink<Item> + ?Sized,` [src][+]

`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][−]

`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][−]

`fn sink_map_err<E, F>(self, f: F) -> SinkMapErr<Self, F> where F: FnOnce(Self::Error) -> E,` [src][−]

`fn sink_err_into<E>(self) -> SinkErrInto<Self, Item, E> where Self::Error: Into<E>,` [src][−]

`fn buffer(self, capacity: usize) -> Buffer<Self, Item>`[src][−]

`fn close(&mut self) -> Close<Self, Item> where Self: Unpin,` [src][−]

`fn fanout<Si>(self, other: Si) -> Fanout<Self, Si> where Item: Clone, Si: Sink<Item, Error = Self::Error>,` [src][−]

`fn flush(&mut self) -> Flush<Self, Item> where Self: Unpin,` [src][−]

`fn send(&mut self, item: Item) -> Send<Self, Item> where Self: Unpin,` [src][−]

`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][−]

`fn left_sink<Si2>(self) -> Either<Self, Si2> where Si2: Sink<Item, Error = Self::Error>,` [src][−]

`fn right_sink<Si1>(self) -> Either<Si1, Self> where Si1: Sink<Item, Error = Self::Error>,` [src][−]

`impl<T> StreamExt for T where T: Stream + ?Sized,` [src][+]

`fn next(&mut self) -> Next<Self> where Self: Unpin,` [src][−]

`fn into_future(self) -> StreamFuture<Self> where Self: Unpin,` [src][−]

`fn map<T, F>(self, f: F) -> Map<Self, F> where F: FnMut(Self::Item) -> T,` [src][−]

`fn enumerate(self) -> Enumerate<Self>`[src][−]

`fn filter<Fut, F>(self, f: F) -> Filter<Self, Fut, F> where F: FnMut(&Self::Item) -> Fut, Fut: Future<Output = bool>,` [src][−]

`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][−]

`fn then<Fut, F>(self, f: F) -> Then<Self, Fut, F> where F: FnMut(Self::Item) -> Fut, Fut: Future,` [src][−]

`fn collect<C>(self) -> Collect<Self, C> where C: Default + Extend<Self::Item>,` [src][−]

`fn concat(self) -> Concat<Self> where Self::Item: Extend<<Self::Item as IntoIterator>::Item>, Self::Item: IntoIterator, Self::Item: Default,` [src][−]

`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][−]

`fn flatten(self) -> Flatten<Self> where Self::Item: Stream,` [src][−]

`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][−]

`fn skip_while<Fut, F>(self, f: F) -> SkipWhile<Self, Fut, F> where F: FnMut(&Self::Item) -> Fut, Fut: Future<Output = bool>,` [src][−]

`fn take_while<Fut, F>(self, f: F) -> TakeWhile<Self, Fut, F> where F: FnMut(&Self::Item) -> Fut, Fut: Future<Output = bool>,` [src][−]

`fn for_each<Fut, F>(self, f: F) -> ForEach<Self, Fut, F> where F: FnMut(Self::Item) -> Fut, Fut: Future<Output = ()>,` [src][−]

`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][−]

`fn take(self, n: usize) -> Take<Self>`[src][−]

`fn skip(self, n: usize) -> Skip<Self>`[src][−]

`fn fuse(self) -> Fuse<Self>`[src][−]

`fn by_ref(&mut self) -> &mut Self`[src][−]

`fn catch_unwind(self) -> CatchUnwind<Self> where Self: UnwindSafe,` [src][−]

`fn boxed<'a>(self) -> Pin<Box<dyn Stream<Item = Self::Item> + 'a + Send>> where Self: Send + 'a,` [src][−]

`fn boxed_local<'a>(self) -> Pin<Box<dyn Stream<Item = Self::Item> + 'a>> where Self: 'a,` [src][−]

`fn buffered(self, n: usize) -> Buffered<Self> where Self::Item: Future,` [src][−]

`fn buffer_unordered(self, n: usize) -> BufferUnordered<Self> where Self::Item: Future,` [src][−]

`fn zip<St>(self, other: St) -> Zip<Self, St> where St: Stream,` [src][−]

`fn chain<St>(self, other: St) -> Chain<Self, St> where St: Stream<Item = Self::Item>,` [src][−]

`fn peekable(self) -> Peekable<Self>`[src][−]

`fn chunks(self, capacity: usize) -> Chunks<Self>`[src][−]

`fn forward<S>(self, sink: S) -> Forward<Self, S> where S: Sink<Self::Ok>, Self: TryStream<Error = <S as Sink<Self::Ok>>::Error>,` [src][−]

`fn split<Item>(self) -> (SplitSink<Self, Item>, SplitStream<Self>) where Self: Sink<Item>,` [src][−]

`fn inspect<F>(self, f: F) -> Inspect<Self, F> where F: FnMut(&Self::Item),` [src][−]