Struct Zip

impl<St1: Stream, St2: Stream> Zip<St1, St2>

fn get_ref(self: &Self) -> (&St1, &St2)

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

fn get_mut(self: &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.

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.

fn into_inner(self: 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.

impl<'__pin, St1: Stream, St2: Stream> Unpin for Zip<St1, St2>

impl<St1, St2> Freeze for Zip<St1, St2>

impl<St1, St2> FusedStream for Zip<St1, St2>

fn is_terminated(self: &Self) -> bool

impl<St1, St2> RefUnwindSafe for Zip<St1, St2>

impl<St1, St2> Send for Zip<St1, St2>

impl<St1, St2> Stream for Zip<St1, St2>

fn poll_next(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Option<<Self as >::Item>>

fn size_hint(self: &Self) -> (usize, Option<usize>)

impl<St1, St2> Sync for Zip<St1, St2>

impl<St1, St2> UnsafeUnpin for Zip<St1, St2>

impl<St1, St2> UnwindSafe for Zip<St1, St2>

impl<St1: $crate::fmt::Debug + Stream, St2: $crate::fmt::Debug + Stream> Debug for Zip<St1, St2>

fn fmt(self: &Self, f: &mut Formatter<'_>) -> Result

impl<T> Any for Zip<St1, St2>

fn type_id(self: &Self) -> TypeId

impl<T> Borrow for Zip<St1, St2>

fn borrow(self: &Self) -> &T

impl<T> BorrowMut for Zip<St1, St2>

fn borrow_mut(self: &mut Self) -> &mut T

impl<T> From for Zip<St1, St2>

fn from(t: T) -> T

Returns the argument unchanged.

impl<T> StreamExt for Zip<St1, St2>

impl<T, U> Into for Zip<St1, St2>

fn into(self: Self) -> U

Calls U::from(self).

That is, this conversion is whatever the implementation of [From]<T> for U chooses to do.

impl<T, U> TryFrom for Zip<St1, St2>

fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

impl<T, U> TryInto for Zip<St1, St2>

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