Enum Diff

pub enum Diff<I, J>
where
    I: Iterator,
    J: Iterator,

A type returned by the diff_with function.

Diff represents the way in which the elements yielded by the iterator I differ to some iterator J.

Variants

FirstMismatch(usize, PutBack<I>, PutBack<J>)

The index of the first non-matching element along with both iterator's remaining elements starting with the first mis-match.

Shorter(usize, PutBack<I>)

The total number of elements that were in J along with the remaining elements of I.

Longer(usize, PutBack<J>)

The total number of elements that were in I along with the remaining elements of J.

Trait Implementations

impl<I, J> Clone for Diff<I, J> where I: Iterator, J: Iterator, PutBack<I>: Clone, PutBack<J>: Clone,

fn clone(&self) -> Self

impl<I, J> Debug for Diff<I, J> where I: Iterator, J: Iterator, PutBack<I>: Debug, PutBack<J>: Debug,

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

Auto Trait Implementations

impl<I, J> Freeze for Diff<I, J> where PutBack<I>: Freeze + Freeze, PutBack<J>: Freeze + Freeze,

impl<I, J> RefUnwindSafe for Diff<I, J> where PutBack<I>: RefUnwindSafe + RefUnwindSafe, PutBack<J>: RefUnwindSafe + RefUnwindSafe,

impl<I, J> Send for Diff<I, J> where PutBack<I>: Send + Send, PutBack<J>: Send + Send,

impl<I, J> Sync for Diff<I, J> where PutBack<I>: Sync + Sync, PutBack<J>: Sync + Sync,

impl<I, J> Unpin for Diff<I, J> where PutBack<I>: Unpin + Unpin, PutBack<J>: Unpin + Unpin,

impl<I, J> UnsafeUnpin for Diff<I, J> where PutBack<I>: UnsafeUnpin + UnsafeUnpin, PutBack<J>: UnsafeUnpin + UnsafeUnpin,

impl<I, J> UnwindSafe for Diff<I, J> where PutBack<I>: UnwindSafe + UnwindSafe, PutBack<J>: UnwindSafe + UnwindSafe,

Blanket Implementations

impl<T> Any for Diff<I, J> where T: 'static + ?Sized,

fn type_id(&self) -> TypeId

impl<T> Borrow<T> for Diff<I, J> where T: ?Sized,

fn borrow(&self) -> &T

impl<T> BorrowMut<T> for Diff<I, J> where T: ?Sized,

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

impl<T> CloneToUninit for Diff<I, J> where T: Clone,

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

impl<T> From<T> for Diff<I, J>

fn from(t: T) -> T

Returns the argument unchanged.

impl<T> IntoEither for Diff<I, J>

impl<T> ToOwned for Diff<I, J> where T: Clone,

type Owned = T;
fn to_owned(&self) -> T
fn clone_into(&self, target: &mut T)

impl<T, U> Into<U> for Diff<I, J> where U: From<T>,

fn into(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<U> for Diff<I, J> where U: Into<T>,

type Error = never;
fn try_from(value: U) -> Result<T, never>

impl<T, U> TryInto<U> for Diff<I, J> where U: TryFrom<T>,

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