Struct ExactlyOneError

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

Iterator returned for the error case of Itertools::exactly_one() This iterator yields exactly the same elements as the input iterator.

During the execution of exactly_one the iterator must be mutated. This wrapper effectively "restores" the state of the input iterator when it's handed back.

This is very similar to PutBackN except this iterator only supports 0-2 elements and does not use a Vec.

Implementations

impl<I> Clone for ExactlyOneError<I>

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

impl<I> Debug for ExactlyOneError<I>

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

impl<I> Display for ExactlyOneError<I>

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

impl<I> Error for ExactlyOneError<I>

impl<I> ExactSizeIterator for ExactlyOneError<I>

impl<I> Freeze for ExactlyOneError<I>

impl<I> IntoIterator for ExactlyOneError<I>

fn into_iter(self: Self) -> I

impl<I> Iterator for ExactlyOneError<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> RefUnwindSafe for ExactlyOneError<I>

impl<I> Send for ExactlyOneError<I>

impl<I> Sync for ExactlyOneError<I>

impl<I> Unpin for ExactlyOneError<I>

impl<I> UnsafeUnpin for ExactlyOneError<I>

impl<I> UnwindSafe for ExactlyOneError<I>

impl<IT> MultiUnzip for ExactlyOneError<I>

fn multiunzip(self: Self)

impl<IT, A, FromA> MultiUnzip for ExactlyOneError<I>

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

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

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

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

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

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

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

impl<IT, A, FromA, B, FromB, C, FromC, D, FromD, E, FromE> MultiUnzip for ExactlyOneError<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 ExactlyOneError<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 ExactlyOneError<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 ExactlyOneError<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 ExactlyOneError<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 ExactlyOneError<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 ExactlyOneError<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 ExactlyOneError<I>

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

impl<T> Any for ExactlyOneError<I>

fn type_id(self: &Self) -> TypeId

impl<T> Borrow for ExactlyOneError<I>

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

impl<T> BorrowMut for ExactlyOneError<I>

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

impl<T> CloneToUninit for ExactlyOneError<I>

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

impl<T> From for ExactlyOneError<I>

fn from(t: T) -> T

Returns the argument unchanged.

impl<T> Itertools for ExactlyOneError<I>

impl<T> ToOwned for ExactlyOneError<I>

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

impl<T> ToString for ExactlyOneError<I>

fn to_string(self: &Self) -> String

impl<T, U> Into for ExactlyOneError<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 ExactlyOneError<I>

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

impl<T, U> TryInto for ExactlyOneError<I>

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