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

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

Stream for the zip method.

Methods

`impl<St1: Stream, St2: Stream> Zip<St1, St2>`[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 Self>) -> (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, Fuse<St1>: Unpin, St2: Stream, Fuse<St2>: Unpin,` [src]

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

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

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

`type Item = (St1::Item, St2::Item)`

Values yielded by the stream.

`fn poll_next(self: Pin<&mut Self>, cx: &mut Context) -> Poll<Option<Self::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> StreamExt for T where T: Stream + ?Sized,` [src]

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

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

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

`fn enumerate(self) -> Enumerate<Self> where Self: Sized,` [src]

`fn filter<Fut, F>(self, f: F) -> Filter<Self, Fut, F> where F: FnMut(&Self::Item) -> Fut, Fut: Future<Output = bool>, Self: Sized,` [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>>, Self: Sized,` [src]

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

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

ⓘImportant traits for Concat<St>
Important traits for Concat<St>
`impl<St> Future for Concat<St> where St: Stream, St::Item: Extend<<St::Item as IntoIterator>::Item> + IntoIterator + Default, type Output = St::Item;`
`fn concat(self) -> Concat<Self> where Self: Sized, Self::Item: Extend<<Self::Item as IntoIterator>::Item> + IntoIterator + 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 St: Stream, F: FnMut(T, St::Item) -> Fut, Fut: Future<Output = T>, 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>, Self: Sized,` [src]

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

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

`fn take_while<Fut, F>(self, f: F) -> TakeWhile<Self, Fut, F> where F: FnMut(&Self::Item) -> Fut, Fut: Future<Output = bool>, Self: Sized,` [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 St: Stream, F: FnMut(St::Item) -> Fut, Fut: Future<Output = ()>, type Output = ();`
`fn for_each<Fut, F>(self, f: F) -> ForEach<Self, Fut, F> where F: FnMut(Self::Item) -> Fut, Fut: Future<Output = ()>, Self: Sized,` [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 St: Stream, F: FnMut(St::Item) -> Fut, Fut: Future<Output = ()>, 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 = ()>, Self: Sized,` [src]

`fn take(self, n: u64) -> Take<Self> where Self: Sized,` [src]

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

`fn fuse(self) -> Fuse<Self> where Self: 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 by_ref(&mut self) -> &mut Self`[src]

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

`fn boxed<'a>(self) -> BoxStream<'a, Self::Item> where Self: Sized + Send + 'a,` [src]

`fn boxed_local<'a>(self) -> LocalBoxStream<'a, Self::Item> where Self: Sized + 'a,` [src]

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

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

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

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

`fn peekable(self) -> Peekable<Self> where Self: Sized,` [src]

`fn chunks(self, capacity: usize) -> Chunks<Self> where Self: Sized,` [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::Error> + Sized,` [src]

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

`fn inspect<F>(self, f: F) -> Inspect<Self, F> where F: FnMut(&Self::Item), Self: Sized,` [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::Output>, type Output = A::Output;`
`fn left_stream(self) -> Either<Self, B> where B: Stream<Item = Self::Item>, Self: Sized,` [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::Output>, type Output = A::Output;`
`fn right_stream(self) -> Either<B, Self> where B: Stream<Item = Self::Item>, Self: Sized,` [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: ?Sized + FusedStream + Unpin> Future for SelectNextSome<'_, St> type Output = St::Item;`
`fn select_next_some(&mut self) -> SelectNextSome<Self> where Self: Unpin + FusedStream,` [src]

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

`type Error = >::Error`

The type returned in the event of a conversion error.

`fn try_into(self) -> Result<U, >::Error>`[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> 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> Any for T where T: 'static + ?Sized,` [src]

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

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

Methods

impl<St1: Stream, St2: Stream> Zip<St1, St2>[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 Self>) -> (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, Fuse<St1>: Unpin, St2: Stream, Fuse<St2>: Unpin, [src]

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

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

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

type Item = (St1::Item, St2::Item)

fn poll_next(self: Pin<&mut Self>, cx: &mut Context) -> Poll<Option<Self::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> StreamExt for T where T: Stream + ?Sized, [src]

ⓘImportant traits for Next<'_, St>Important traits for Next<'_, St>impl<'_, St: ?Sized + Stream + Unpin> Future for Next<'_, St> type Output = Option<St::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: Stream + Unpin> Future for StreamFuture<St> type Output = (Option<St::Item>, St);fn into_future(self) -> StreamFuture<Self> where Self: Sized + Unpin, [src]

Important traits for StreamFuture<St>

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

fn enumerate(self) -> Enumerate<Self> where Self: Sized, [src]

fn filter<Fut, F>(self, f: F) -> Filter<Self, Fut, F> where F: FnMut(&Self::Item) -> Fut, Fut: Future<Output = bool>, Self: Sized, [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>>, Self: Sized, [src]

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

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

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

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

Important traits for ForEach<St, Fut, F>

Important traits for ForEachConcurrent<St, Fut, F>

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

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

fn fuse(self) -> Fuse<Self> where Self: 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 by_ref(&mut self) -> &mut Self[src]

Important traits for &'_ mut F

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

fn boxed<'a>(self) -> BoxStream<'a, Self::Item> where Self: Sized + Send + 'a, [src]

fn boxed_local<'a>(self) -> LocalBoxStream<'a, Self::Item> where Self: Sized + 'a, [src]

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

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

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

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

fn peekable(self) -> Peekable<Self> where Self: Sized, [src]

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

Important traits for Forward<St, Si>

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

fn inspect<F>(self, f: F) -> Inspect<Self, F> where F: FnMut(&Self::Item), Self: Sized, [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::Output>, type Output = A::Output;fn left_stream<B>(self) -> Either<Self, B> where B: Stream<Item = Self::Item>, Self: Sized, [src]

Important traits for Either<A, B>

ⓘ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::Output>, type Output = A::Output;fn right_stream<B>(self) -> Either<B, Self> where B: Stream<Item = Self::Item>, Self: Sized, [src]