[−][src]Struct futures::stream::Zip

#[must_use = "streams do nothing unless polled"]
pub struct Zip<St1, St2> where
    St1: Stream,
    St2: Stream,  { /* fields omitted */ }

Stream for the zip method.

Methods

`impl<St1, St2> Zip<St1, St2> where St1: Stream, St2: Stream,` [src]

`pub fn get_ref(&self) -> (&St1, &St2)`[src]

Acquires a reference to the underlying streams that this combinator is pulling from.

`pub fn get_mut(&mut self) -> (&mut St1, &mut St2)`[src]

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.

`pub fn get_pin_mut( self: Pin<&mut Zip<St1, St2>> ) -> (Pin<&mut St1>, Pin<&mut St2>)`[src]

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.

`pub fn into_inner(self) -> (St1, St2)`[src]

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

`impl<St1, St2> Unpin for Zip<St1, St2> where St1: Stream, St2: Stream, Fuse<St1>: Unpin, Fuse<St2>: Unpin,` [src]

`impl<St1, St2> Debug for Zip<St1, St2> where St1: Debug + Stream, St2: Debug + Stream, <St1 as Stream>::Item: Debug, <St2 as Stream>::Item: Debug,` [src]

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

`impl<St1, St2> Stream for Zip<St1, St2> where St1: Stream, St2: Stream,` [src]

`type Item = (<St1 as Stream>::Item, <St2 as Stream>::Item)`

Values yielded by the stream.

`fn poll_next( self: Pin<&mut Zip<St1, St2>>, cx: &mut Context ) -> Poll<Option<<Zip<St1, St2> as Stream>::Item>>`[src]

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

`impl<St1, St2> FusedStream for Zip<St1, St2> where St1: Stream, St2: Stream,` [src]

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

Auto Trait Implementations

`impl<St1, St2> Send for Zip<St1, St2> where St1: Send, St2: Send, <St1 as Stream>::Item: Send, <St2 as Stream>::Item: Send,`

`impl<St1, St2> Sync for Zip<St1, St2> where St1: Sync, St2: Sync, <St1 as Stream>::Item: Sync, <St2 as Stream>::Item: Sync,`

`impl<St1, St2> UnwindSafe for Zip<St1, St2> where St1: UnwindSafe, St2: UnwindSafe, <St1 as Stream>::Item: UnwindSafe, <St2 as Stream>::Item: UnwindSafe,`

`impl<St1, St2> RefUnwindSafe for Zip<St1, St2> where St1: RefUnwindSafe, St2: RefUnwindSafe, <St1 as Stream>::Item: RefUnwindSafe, <St2 as Stream>::Item: RefUnwindSafe,`

Blanket Implementations

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

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

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

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

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

`type Error = !`

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]

`type Error = >::Error`

The type returned in the event of a conversion error.

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

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

ⓘImportant traits for &'_ mut F
Important traits for &'_ mut F
`impl<'_, F> Future for &'_ mut F where F: Unpin + Future + ?Sized, type Output = <F as Future>::Output;`
`fn borrow(&self) -> &T`[src]

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

ⓘImportant traits for &'_ mut F
Important traits for &'_ mut F
`impl<'_, F> Future for &'_ mut F where F: Unpin + Future + ?Sized, type Output = <F as Future>::Output;`
`fn borrow_mut(&mut self) -> &mut T`[src]

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

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

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

ⓘImportant traits for Next<'_, St>
Important traits for Next<'_, St>
`impl<'_, St> Future for Next<'_, St> where St: Unpin + Stream + ?Sized, type Output = Option<<St as Stream>::Item>;`
`fn next(&mut self) -> Next<Self> where Self: Unpin,` [src]

ⓘImportant traits for StreamFuture<St>
Important traits for StreamFuture<St>
`impl<St> Future for StreamFuture<St> where St: Unpin + Stream, type Output = (Option<<St as Stream>::Item>, St);`
`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]

ⓘImportant traits for Collect<St, C>
Important traits for Collect<St, C>
`impl<St, C> Future for Collect<St, C> where C: Default + Extend<<St as Stream>::Item>, St: Stream, type Output = C;`
`fn collect<C>(self) -> Collect<Self, C> where C: Default + Extend<Self::Item>,` [src]

ⓘImportant traits for Concat<St>
Important 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;`
`fn concat(self) -> Concat<Self> where Self::Item: Extend<<Self::Item as IntoIterator>::Item>, Self::Item: IntoIterator, Self::Item: Default,` [src]

ⓘImportant traits for Fold<St, Fut, T, F>
Important traits for Fold<St, Fut, T, F>
`impl<St, Fut, T, F> Future for Fold<St, Fut, T, F> where F: FnMut(T, <St as Stream>::Item) -> Fut, Fut: Future<Output = T>, St: Stream, type Output = T;`
`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 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]

ⓘImportant traits for ForEach<St, Fut, F>
Important traits for ForEach<St, Fut, F>
`impl<St, Fut, F> Future for ForEach<St, Fut, F> where F: FnMut(<St as Stream>::Item) -> Fut, Fut: Future<Output = ()>, St: Stream, type Output = ();`
`fn for_each<Fut, F>(self, f: F) -> ForEach<Self, Fut, F> where F: FnMut(Self::Item) -> Fut, Fut: Future<Output = ()>,` [src]

ⓘImportant traits for ForEachConcurrent<St, Fut, F>
Important traits for ForEachConcurrent<St, Fut, F>
`impl<St, Fut, F> Future for ForEachConcurrent<St, Fut, F> where F: FnMut(<St as Stream>::Item) -> Fut, Fut: Future<Output = ()>, St: Stream, type Output = ();`
`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]

ⓘImportant traits for &'_ mut F
Important traits for &'_ mut F
`impl<'_, F> Future for &'_ mut F where F: Unpin + Future + ?Sized, type Output = <F as Future>::Output;`
`fn by_ref(&mut self) -> &mut Self`[src]

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

ⓘImportant traits for Pin
Important traits for Pin
`impl Future for Pin where P: Unpin + DerefMut, ::Target: Future, type Output = <::Target as Future>::Output;`
`fn boxed<'a>(self) -> Pin<Box<dyn Stream<Item = Self::Item> + 'a + Send>> where Self: Send + 'a,` [src]

ⓘImportant traits for Pin
Important traits for Pin
`impl Future for Pin where P: Unpin + DerefMut, ::Target: Future, type Output = <::Target as Future>::Output;`
`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]

ⓘImportant traits for Forward<St, Si>
Important traits for Forward<St, Si>
`impl<St, Si, Item, E> Future for Forward<St, Si> where Si: Sink<Item, Error = E>, St: Stream<Item = Result<Item, E>>, type Output = Result<(), E>;`
`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]

ⓘImportant traits for Either<A, B>
Important 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;`
`fn left_stream(self) -> Either<Self, B> where B: Stream<Item = Self::Item>,` [src]

ⓘImportant traits for Either<A, B>
Important 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;`
`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]

ⓘImportant traits for SelectNextSome<'_, St>
Important traits for SelectNextSome<'_, St>
`impl<'_, St> Future for SelectNextSome<'_, St> where St: Unpin + FusedStream + ?Sized, type Output = <St as Stream>::Item;`
`fn select_next_some(&mut self) -> SelectNextSome<Self> where Self: Unpin + FusedStream,` [src]

[−][src]Struct futures::stream::Zip

Methods

impl<St1, St2> Zip<St1, St2> where St1: Stream, St2: Stream, [src]

pub fn get_ref(&self) -> (&St1, &St2)[src]

pub fn get_mut(&mut self) -> (&mut St1, &mut St2)[src]

pub fn get_pin_mut( self: Pin<&mut Zip<St1, St2>>) -> (Pin<&mut St1>, Pin<&mut St2>)[src]

pub fn into_inner(self) -> (St1, St2)[src]

Trait Implementations

impl<St1, St2> Unpin for Zip<St1, St2> where St1: Stream, St2: Stream, Fuse<St1>: Unpin, Fuse<St2>: Unpin, [src]

impl<St1, St2> Debug for Zip<St1, St2> where St1: Debug + Stream, St2: Debug + Stream, <St1 as Stream>::Item: Debug, <St2 as Stream>::Item: Debug, [src]

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

impl<St1, St2> Stream for Zip<St1, St2> where St1: Stream, St2: Stream, [src]

type Item = (<St1 as Stream>::Item, <St2 as Stream>::Item)

fn poll_next( self: Pin<&mut Zip<St1, St2>>, cx: &mut Context) -> Poll<Option<<Zip<St1, St2> as Stream>::Item>>[src]

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

impl<St1, St2> FusedStream for Zip<St1, St2> where St1: Stream, St2: Stream, [src]

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

Auto Trait Implementations

impl<St1, St2> Send for Zip<St1, St2> where St1: Send, St2: Send, <St1 as Stream>::Item: Send, <St2 as Stream>::Item: Send,

impl<St1, St2> Sync for Zip<St1, St2> where St1: Sync, St2: Sync, <St1 as Stream>::Item: Sync, <St2 as Stream>::Item: Sync,

impl<St1, St2> UnwindSafe for Zip<St1, St2> where St1: UnwindSafe, St2: UnwindSafe, <St1 as Stream>::Item: UnwindSafe, <St2 as Stream>::Item: UnwindSafe,

impl<St1, St2> RefUnwindSafe for Zip<St1, St2> where St1: RefUnwindSafe, St2: RefUnwindSafe, <St1 as Stream>::Item: RefUnwindSafe, <St2 as Stream>::Item: RefUnwindSafe,

Blanket Implementations

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

fn into(self) -> U[src]

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

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

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

type Error = !

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]

type Error = <U as TryFrom<T>>::Error

fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>[src]

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

ⓘImportant traits for &'_ mut FImportant traits for &'_ mut Fimpl<'_, F> Future for &'_ mut F where F: Unpin + Future + ?Sized, type Output = <F as Future>::Output;fn borrow(&self) -> &T[src]

Important traits for &'_ mut F

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

ⓘImportant traits for &'_ mut FImportant traits for &'_ mut Fimpl<'_, F> Future for &'_ mut F where F: Unpin + Future + ?Sized, type Output = <F as Future>::Output;fn borrow_mut(&mut self) -> &mut T[src]

Important traits for &'_ mut F

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

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

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

ⓘImportant traits for Next<'_, St>Important traits for Next<'_, St>impl<'_, St> Future for Next<'_, St> where St: Unpin + Stream + ?Sized, type Output = Option<<St as Stream>::Item>;fn next(&mut self) -> Next<Self> where Self: Unpin, [src]

Important traits for Next<'_, St>

ⓘImportant traits for StreamFuture<St>Important traits for StreamFuture<St>impl<St> Future for StreamFuture<St> where St: Unpin + Stream, type Output = (Option<<St as Stream>::Item>, St);fn into_future(self) -> StreamFuture<Self> where Self: Unpin, [src]

Important traits for StreamFuture<St>

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]

ⓘImportant traits for Collect<St, C>Important traits for Collect<St, C>impl<St, C> Future for Collect<St, C> where C: Default + Extend<<St as Stream>::Item>, St: Stream, type Output = C;fn collect<C>(self) -> Collect<Self, C> where C: Default + Extend<Self::Item>, [src]

Important traits for Collect<St, C>

Important traits for Concat<St>

Important traits for Fold<St, Fut, T, F>

fn flatten(self) -> Flatten<Self> where Self::Item: Stream, [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]

Important traits for ForEach<St, Fut, F>

Important traits for ForEachConcurrent<St, Fut, F>

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

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

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

ⓘImportant traits for &'_ mut FImportant traits for &'_ mut Fimpl<'_, F> Future for &'_ mut F where F: Unpin + Future + ?Sized, type Output = <F as Future>::Output;fn by_ref(&mut self) -> &mut Self[src]

Important traits for &'_ mut F

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

ⓘImportant traits for Pin<P>Important traits for Pin<P>impl<P> Future for Pin<P> where P: Unpin + DerefMut, <P as Deref>::Target: Future, type Output = <<P as Deref>::Target as Future>::Output;fn boxed<'a>(self) -> Pin<Box<dyn Stream<Item = Self::Item> + 'a + Send>> where Self: Send + 'a, [src]

Important traits for Pin<P>

ⓘImportant traits for Pin<P>Important traits for Pin<P>impl<P> Future for Pin<P> where P: Unpin + DerefMut, <P as Deref>::Target: Future, type Output = <<P as Deref>::Target as Future>::Output;fn boxed_local<'a>(self) -> Pin<Box<dyn Stream<Item = Self::Item> + 'a>> where Self: 'a, [src]

Important traits for Pin<P>

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]

Important traits for Forward<St, Si>

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]

ⓘImportant traits for Either<A, B>Important 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;fn left_stream<B>(self) -> Either<Self, B> where B: Stream<Item = Self::Item>, [src]

`impl<St1, St2> Zip<St1, St2> where St1: Stream, St2: Stream,` [src]

`pub fn get_ref(&self) -> (&St1, &St2)`[src]

`pub fn get_mut(&mut self) -> (&mut St1, &mut St2)`[src]

`pub fn get_pin_mut( self: Pin<&mut Zip<St1, St2>> ) -> (Pin<&mut St1>, Pin<&mut St2>)`[src]

`pub fn into_inner(self) -> (St1, St2)`[src]

`impl<St1, St2> Unpin for Zip<St1, St2> where St1: Stream, St2: Stream, Fuse<St1>: Unpin, Fuse<St2>: Unpin,` [src]

`impl<St1, St2> Debug for Zip<St1, St2> where St1: Debug + Stream, St2: Debug + Stream, <St1 as Stream>::Item: Debug, <St2 as Stream>::Item: Debug,` [src]

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

`impl<St1, St2> Stream for Zip<St1, St2> where St1: Stream, St2: Stream,` [src]

`type Item = (<St1 as Stream>::Item, <St2 as Stream>::Item)`

`fn poll_next( self: Pin<&mut Zip<St1, St2>>, cx: &mut Context ) -> Poll<Option<<Zip<St1, St2> as Stream>::Item>>`[src]

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

`impl<St1, St2> FusedStream for Zip<St1, St2> where St1: Stream, St2: Stream,` [src]

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

`impl<St1, St2> Send for Zip<St1, St2> where St1: Send, St2: Send, <St1 as Stream>::Item: Send, <St2 as Stream>::Item: Send,`

`impl<St1, St2> Sync for Zip<St1, St2> where St1: Sync, St2: Sync, <St1 as Stream>::Item: Sync, <St2 as Stream>::Item: Sync,`

`impl<St1, St2> UnwindSafe for Zip<St1, St2> where St1: UnwindSafe, St2: UnwindSafe, <St1 as Stream>::Item: UnwindSafe, <St2 as Stream>::Item: UnwindSafe,`

`impl<St1, St2> RefUnwindSafe for Zip<St1, St2> where St1: RefUnwindSafe, St2: RefUnwindSafe, <St1 as Stream>::Item: RefUnwindSafe, <St2 as Stream>::Item: RefUnwindSafe,`

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

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

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

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

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

`type Error = !`

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

`type Error = <U as TryFrom<T>>::Error`

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

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

ⓘImportant traits for &'_ mut F
Important traits for &'_ mut F
`impl<'_, F> Future for &'_ mut F where F: Unpin + Future + ?Sized, type Output = <F as Future>::Output;`
`fn borrow(&self) -> &T`[src]

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

ⓘImportant traits for &'_ mut F
Important traits for &'_ mut F
`impl<'_, F> Future for &'_ mut F where F: Unpin + Future + ?Sized, type Output = <F as Future>::Output;`
`fn borrow_mut(&mut self) -> &mut T`[src]

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

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

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

ⓘImportant traits for Next<'_, St>
Important traits for Next<'_, St>
`impl<'_, St> Future for Next<'_, St> where St: Unpin + Stream + ?Sized, type Output = Option<<St as Stream>::Item>;`
`fn next(&mut self) -> Next<Self> where Self: Unpin,` [src]

ⓘImportant traits for StreamFuture<St>
Important traits for StreamFuture<St>
`impl<St> Future for StreamFuture<St> where St: Unpin + Stream, type Output = (Option<<St as Stream>::Item>, St);`
`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]

ⓘImportant traits for Collect<St, C>
Important traits for Collect<St, C>
`impl<St, C> Future for Collect<St, C> where C: Default + Extend<<St as Stream>::Item>, St: Stream, type Output = C;`
`fn collect<C>(self) -> Collect<Self, C> where C: Default + Extend<Self::Item>,` [src]

`fn flatten(self) -> Flatten<Self> where Self::Item: Stream,` [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 take(self, n: usize) -> Take<Self>`[src]

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

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

ⓘImportant traits for &'_ mut F
Important traits for &'_ mut F
`impl<'_, F> Future for &'_ mut F where F: Unpin + Future + ?Sized, type Output = <F as Future>::Output;`
`fn by_ref(&mut self) -> &mut Self`[src]

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

ⓘImportant traits for Pin<P>
Important traits for Pin<P>
`impl<P> Future for Pin<P> where P: Unpin + DerefMut, <P as Deref>::Target: Future, type Output = <<P as Deref>::Target as Future>::Output;`
`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 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]

ⓘImportant traits for Either<A, B>
Important 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;`
`fn left_stream<B>(self) -> Either<Self, B> where B: Stream<Item = Self::Item>,` [src]

ⓘImportant traits for Either<A, B>
Important 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;`
`fn right_stream<B>(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]