Struct `MultiPeek`

struct MultiPeek<I> { ... }
where
    I: Iterator

See [multipeek()] for more information.

Implementations

`impl<I> MultiPeek<I>`

fn reset_peek(self: &mut Self): Reset the peeking “cursor”

`impl<I: Iterator> MultiPeek<I>`

fn peek(self: &mut Self) -> Option<&<I as >::Item>: Works exactly like .next() with the only difference that it doesn't advance itself. .peek() can be called multiple times, to peek further ahead. When .next() is called, reset the peeking “cursor”.

`impl<I> Clone for MultiPeek<I>`

fn clone(self: &Self) -> MultiPeek<I>

`impl<I> Debug for MultiPeek<I>`

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

`impl<I> ExactSizeIterator for MultiPeek<I>`

`impl<I> Freeze for MultiPeek<I>`

`impl<I> IntoIterator for MultiPeek<I>`

fn into_iter(self: Self) -> I

`impl<I> Iterator for MultiPeek<I>`

fn next(self: &mut Self) -> Option<<Self as >::Item>
fn size_hint(self: &Self) -> (usize, Option<usize>)
fn fold<B, F>(self: Self, init: B, f: F) -> B where F: FnMut(B, <Self as >::Item) -> B

`impl<I> PeekingNext for MultiPeek<I>`

fn peeking_next<F>(self: &mut Self, accept: F) -> Option<<Self as >::Item> where F: FnOnce(&<Self as >::Item) -> bool

`impl<I> RefUnwindSafe for MultiPeek<I>`

`impl<I> Send for MultiPeek<I>`

`impl<I> Sync for MultiPeek<I>`

`impl<I> Unpin for MultiPeek<I>`

`impl<I> UnsafeUnpin for MultiPeek<I>`

`impl<I> UnwindSafe for MultiPeek<I>`

`impl<IT> MultiUnzip for MultiPeek<I>`

fn multiunzip(self: Self)

`impl<IT, A, FromA> MultiUnzip for MultiPeek<I>`

fn multiunzip(self: Self) -> (FromA)

`impl<IT, A, FromA, B, FromB> MultiUnzip for MultiPeek<I>`

fn multiunzip(self: Self) -> (FromA, FromB)

`impl<IT, A, FromA, B, FromB, C, FromC> MultiUnzip for MultiPeek<I>`

fn multiunzip(self: Self) -> (FromA, FromB, FromC)

`impl<IT, A, FromA, B, FromB, C, FromC, D, FromD> MultiUnzip for MultiPeek<I>`

fn multiunzip(self: Self) -> (FromA, FromB, FromC, FromD)

`impl<IT, A, FromA, B, FromB, C, FromC, D, FromD, E, FromE> MultiUnzip for MultiPeek<I>`

fn multiunzip(self: Self) -> (FromA, FromB, FromC, FromD, FromE)

`impl<IT, A, FromA, B, FromB, C, FromC, D, FromD, E, FromE, F, FromF> MultiUnzip for MultiPeek<I>`

fn multiunzip(self: Self) -> (FromA, FromB, FromC, FromD, FromE, FromF)

`impl<IT, A, FromA, B, FromB, C, FromC, D, FromD, E, FromE, F, FromF, G, FromG> MultiUnzip for MultiPeek<I>`

fn multiunzip(self: Self) -> (FromA, FromB, FromC, FromD, FromE, FromF, FromG)

`impl<IT, A, FromA, B, FromB, C, FromC, D, FromD, E, FromE, F, FromF, G, FromG, H, FromH> MultiUnzip for MultiPeek<I>`

fn multiunzip(self: Self) -> (FromA, FromB, FromC, FromD, FromE, FromF, FromG, FromH)

`impl<IT, A, FromA, B, FromB, C, FromC, D, FromD, E, FromE, F, FromF, G, FromG, H, FromH, I, FromI> MultiUnzip for MultiPeek<I>`

fn multiunzip(self: Self) -> (FromA, FromB, FromC, FromD, FromE, FromF, FromG, FromH, FromI)

`impl<IT, A, FromA, B, FromB, C, FromC, D, FromD, E, FromE, F, FromF, G, FromG, H, FromH, I, FromI, J, FromJ> MultiUnzip for MultiPeek<I>`

fn multiunzip(self: Self) -> (FromA, FromB, FromC, FromD, FromE, FromF, FromG, FromH, FromI, FromJ)

`impl<IT, A, FromA, B, FromB, C, FromC, D, FromD, E, FromE, F, FromF, G, FromG, H, FromH, I, FromI, J, FromJ, K, FromK> MultiUnzip for MultiPeek<I>`

fn multiunzip(self: Self) -> (FromA, FromB, FromC, FromD, FromE, FromF, FromG, FromH, FromI, FromJ, FromK)

`impl<IT, A, FromA, B, FromB, C, FromC, D, FromD, E, FromE, F, FromF, G, FromG, H, FromH, I, FromI, J, FromJ, K, FromK, L, FromL> MultiUnzip for MultiPeek<I>`

fn multiunzip(self: Self) -> (FromA, FromB, FromC, FromD, FromE, FromF, FromG, FromH, FromI, FromJ, FromK, FromL)

`impl<T> Any for MultiPeek<I>`

fn type_id(self: &Self) -> TypeId

`impl<T> Borrow for MultiPeek<I>`

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

`impl<T> BorrowMut for MultiPeek<I>`

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

`impl<T> CloneToUninit for MultiPeek<I>`

unsafe fn clone_to_uninit(self: &Self, dest: *mut u8)

`impl<T> From for MultiPeek<I>`

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

`impl<T> Itertools for MultiPeek<I>`

`impl<T> ToOwned for MultiPeek<I>`

fn to_owned(self: &Self) -> T
fn clone_into(self: &Self, target: &mut T)

`impl<T, U> Into for MultiPeek<I>`

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 MultiPeek<I>`

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

`impl<T, U> TryInto for MultiPeek<I>`

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