Select - futures

`impl<St1, St2> Select<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, St2> Unpin for Select<St1, St2>`

`impl<S> TryStreamExt for Select<St1, St2>`

`impl<S, T, E> TryStream for Select<St1, St2>`

fn try_poll_next(self: Pin<&mut S>, cx: &mut Context<'_>) -> Poll<Option<Result<<S as TryStream>::Ok, <S as TryStream>::Error>>>

`impl<St1, St2> Freeze for Select<St1, St2>`

`impl<St1, St2> FusedStream for Select<St1, St2>`

fn is_terminated(self: &Self) -> bool

`impl<St1, St2> RefUnwindSafe for Select<St1, St2>`

`impl<St1, St2> Send for Select<St1, St2>`

`impl<St1, St2> Stream for Select<St1, St2>`

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

`impl<St1, St2> Sync for Select<St1, St2>`

`impl<St1, St2> UnsafeUnpin for Select<St1, St2>`

`impl<St1, St2> UnwindSafe for Select<St1, St2>`

`impl<St1: $crate::fmt::Debug, St2: $crate::fmt::Debug> Debug for Select<St1, St2>`

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

`impl<T> Any for Select<St1, St2>`

fn type_id(self: &Self) -> TypeId

`impl<T> Borrow for Select<St1, St2>`

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

`impl<T> BorrowMut for Select<St1, St2>`

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

`impl<T> From for Select<St1, St2>`

fn from(t: T) -> T: Returns the argument unchanged.

`impl<T> StreamExt for Select<St1, St2>`

`impl<T, U> Into for Select<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 Select<St1, St2>`

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

`impl<T, U> TryInto for Select<St1, St2>`

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

Struct `Select`

Implementations