Struct LazyCopied 

pub struct LazyCopied<I> { /* private fields */ }

Trait Implementations

impl<I: Clone> Clone for LazyCopied<I>

fn clone(&self) -> LazyCopied<I>

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<'a, I, T> Consumer for LazyCopied<I>

where T: 'a + Copy, I: Consumer<Item = &'a T>,

type Item = T

type IntoIter = Copied<<I as Consumer>::IntoIter>

fn consume(self) -> Self::IntoIter

impl<I: Debug> Debug for LazyCopied<I>

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

Formats the value using the given formatter.

impl<'a, I, T> Iterable for LazyCopied<I>

where T: 'a + Copy, I: Iterable<Item = &'a T>,

type C = <I as Iterable>::CC<T>

type CC<U> = <I as Iterable>::CC<U>

type F = <I as Iterable>::CF<T>

type CF<U> = <I as Iterable>::CF<U>

fn count(self) -> usize

where Self: Sized,

fn last(self) -> Option<Self::Item>

where Self: Sized,

fn nth(self, n: usize) -> Option<Self::Item>

where Self: Sized,

fn step_by(self, step: usize) -> Self::C

where Self: Sized, Self::C: Producer<Self::Item>,

fn chain(self, other: impl Consumer<Item = Self::Item>) -> Self::C

where Self: Sized, Self::C: Producer<Self::Item>,

fn zip<E>(self, other: impl Consumer<Item = E>) -> Self::CC<(Self::Item, E)>

where Self: Sized, Self::CC<(Self::Item, E)>: Producer<(Self::Item, E)>,

fn map<U>(self, f: impl Fn(Self::Item) -> U) -> Self::CF<U>

where Self: Sized, Self::CF<U>: Producer<U>,

fn foreach(self, f: impl Fn(Self::Item))

where Self: Sized,

fn filter(self, f: impl Fn(&Self::Item) -> bool) -> Self::C

where Self: Sized, Self::C: Producer<Self::Item>,

fn filter_map<U>(self, f: impl Fn(Self::Item) -> Option<U>) -> Self::CC<U>

where Self: Sized, Self::CC<U>: Producer<U>,

fn enumerate(self) -> Self::CF<(usize, Self::Item)>

where Self: Sized, Self::CF<(usize, Self::Item)>: Producer<(usize, Self::Item)>,

fn skip_while(self, f: impl Fn(&Self::Item) -> bool) -> Self::C

where Self: Sized, Self::C: Producer<Self::Item>,

fn take_while(self, f: impl Fn(&Self::Item) -> bool) -> Self::C

where Self: Sized, Self::C: Producer<Self::Item>,

fn map_while<U>(self, f: impl Fn(Self::Item) -> Option<U>) -> Self::CC<U>

where Self: Sized, Self::CC<U>: Producer<U>,

fn skip(self, n: usize) -> Self::C

where Self: Sized, Self::C: Producer<Self::Item>,

fn take(self, n: usize) -> Self::C

where Self: Sized, Self::C: Producer<Self::Item>,

fn scan<S>(self, state: S, f: impl Fn(S, Self::Item) -> S) -> Self::CC<S>

where S: Clone, Self: Sized, Self::CC<S>: Producer<S>,

fn flat_map<U>(self, f: impl Fn(Self::Item) -> U) -> Self::CC<U::Item>

where U: Consumer, Self: Sized, Self::CC<U::Item>: Producer<U::Item>,

fn flatten(self) -> Self::CC<<Self::Item as Consumer>::Item>

where Self: Sized, Self::Item: Consumer, Self::CC<<Self::Item as Consumer>::Item>: Producer<<Self::Item as Consumer>::Item>,

fn by_ref(&self) -> &Self

fn partition(self, f: impl Fn(&Self::Item) -> bool) -> (Self::C, Self::C)

where Self: Sized, Self::C: GrowableProducer<Self::Item>,

fn try_fold<S, R>(self, init: S, f: impl Fn(S, Self::Item) -> R) -> R::Map<S>

where Self: Sized, R: TryExt<Output = S>,

fn try_for_each<R>(self, f: impl Fn(Self::Item) -> R) -> R::Map<()>

where Self: Sized, R: TryExt<Output = ()>,

fn fold<S>(self, init: S, f: impl Fn(S, Self::Item) -> S) -> S

where Self: Sized,

fn all(self, f: impl Fn(Self::Item) -> bool) -> bool

where Self: Sized,

fn any(self, f: impl Fn(Self::Item) -> bool) -> bool

where Self: Sized,

fn find(self, f: impl Fn(&Self::Item) -> bool) -> Option<Self::Item>

where Self: Sized,

fn find_map<B>(self, f: impl Fn(Self::Item) -> Option<B>) -> Option<B>

where Self: Sized,

fn position(self, f: impl Fn(Self::Item) -> bool) -> Option<usize>

where Self: Sized,

fn rposition(self, f: impl Fn(Self::Item) -> bool) -> Option<usize>

where Self: Sized, Self::IntoIter: ExactSizeIterator + DoubleEndedIterator,

fn max(self) -> Option<Self::Item>

where Self: Sized, Self::Item: Ord,

fn min(self) -> Option<Self::Item>

where Self: Sized, Self::Item: Ord,

fn max_by_key<B>(self, f: impl Fn(&Self::Item) -> B) -> Option<Self::Item>

where Self: Sized, B: Ord,

fn max_by( self, f: impl Fn(&Self::Item, &Self::Item) -> Ordering, ) -> Option<Self::Item>

where Self: Sized,

fn min_by_key<B>(self, f: impl Fn(&Self::Item) -> B) -> Option<Self::Item>

where Self: Sized, B: Ord,

fn min_by( self, f: impl Fn(&Self::Item, &Self::Item) -> Ordering, ) -> Option<Self::Item>

where Self: Sized,

fn unzip<A, B>(self) -> (Self::CF<A>, Self::CF<B>)

where Self: Sized + Consumer<Item = (A, B)>, Self::CF<A>: GrowableProducer<A>, Self::CF<B>: GrowableProducer<B>,

fn copied<'a, T>(self) -> Self::CF<T>

where T: 'a + Copy, Self: Sized + Consumer<Item = &'a T>, Self::CF<T>: Producer<T>,

fn cloned<'a, T>(self) -> Self::CF<T>

where T: 'a + Clone, Self: Sized + Consumer<Item = &'a T>, Self::CF<T>: Producer<T>,

fn sum<S>(self) -> S

where Self: Sized, S: Sum<Self::Item>,

fn product<S>(self) -> S

where Self: Sized, S: Product<Self::Item>,

fn cmp<I>(self, other: I) -> Ordering

where I: Consumer<Item = Self::Item>, Self: Sized, Self::Item: Ord,

fn partial_cmp<I>(self, other: I) -> Option<Ordering>

where I: Consumer, Self: Sized, Self::Item: PartialOrd<<I as Consumer>::Item>,

fn eq<I>(self, other: I) -> bool

where I: Consumer, Self: Sized, Self::Item: PartialEq<<I as Consumer>::Item>,

fn ne<I>(self, other: I) -> bool

where I: Consumer, Self: Sized, Self::Item: PartialEq<<I as Consumer>::Item>,

fn lt<I>(self, other: I) -> bool

where I: Consumer, Self: Sized, Self::Item: PartialOrd<<I as Consumer>::Item>,

fn le<I>(self, other: I) -> bool

where I: Consumer, Self: Sized, Self::Item: PartialOrd<<I as Consumer>::Item>,

fn gt<I>(self, other: I) -> bool

where I: Consumer, Self: Sized, Self::Item: PartialOrd<<I as Consumer>::Item>,

fn ge<I>(self, other: I) -> bool

where I: Consumer, Self: Sized, Self::Item: PartialOrd<<I as Consumer>::Item>,

fn join(self, sep: &str) -> String

where Self: Sized, Self::Item: Display,

fn add_one(self, a: Self::Item) -> Self::C

where Self: Sized, Self::C: GrowableProducer<Self::Item>,

fn try_add_one<R>(self, r: R) -> R::Map<Self::C>

where R: TryExt<Output = Self::Item>, Self: Sized, Self::C: GrowableProducer<Self::Item>,

fn try_map<B, R, F>(self, f: F) -> R::Map<Self::CC<B>>

where F: Fn(Self::Item) -> R, R: TryExt<Output = B>, Self: Sized, Self::CC<B>: GrowableProducer<B>,

fn try_flat_map<B, R, F>(self, f: F) -> R::Map<Self::CC<B::Item>>

where F: Fn(Self::Item) -> R, R: TryExt<Output = B>, B: Consumer, Self: Sized, Self::CC<B::Item>: GrowableProducer<B::Item>,

fn try_flatten( self, ) -> <Self::Item as TryExt>::Map<Self::CC<<<Self::Item as TryExt>::Output as Consumer>::Item>>

where Self: Sized, Self::Item: TryExt, <Self::Item as TryExt>::Output: Consumer, Self::CC<<<Self::Item as TryExt>::Output as Consumer>::Item>: GrowableProducer<<<Self::Item as TryExt>::Output as Consumer>::Item>,

fn lazy_step_by(self, step: usize) -> LazyStepBy<Self>

where Self: Sized,

fn lazy_chain<C: Consumer>(self, c: C) -> LazyChain<Self, C>

where Self: Sized,

fn lazy_zip<C: Consumer>(self, c: C) -> LazyZip<Self, C>

where Self: Sized,

fn lazy_filter<F: Fn(&Self::Item) -> bool>(self, f: F) -> LazyFilter<Self, F>

where Self: Sized,

fn lazy_map<T, F: Fn(Self::Item) -> T>(self, f: F) -> LazyMap<Self, F>

where Self: Sized,

fn lazy_filter_map<T, F: Fn(Self::Item) -> Option<T>>( self, f: F, ) -> LazyFilterMap<Self, F>

where Self: Sized,

fn lazy_enumerate(self) -> LazyEnumerate<Self>

where Self: Sized,

fn lazy_skip_while<F: Fn(&Self::Item) -> bool>( self, f: F, ) -> LazySkipWhile<Self, F>

where Self: Sized,

fn lazy_map_while<T, F: Fn(Self::Item) -> Option<T>>( self, f: F, ) -> LazyMapWhile<Self, F>

where Self: Sized,

fn lazy_skip(self, n: usize) -> LazySkip<Self>

where Self: Sized,

fn lazy_take(self, n: usize) -> LazyTake<Self>

where Self: Sized,

fn lazy_scan<S, F: Fn(S, Self::Item) -> S>( self, state: S, f: F, ) -> LazyScan<S, Self, F>

where Self: Sized,

fn lazy_flat_map<T: Consumer, F: Fn(Self::Item) -> T>( self, f: F, ) -> LazyFlatMap<Self, F>

where Self: Sized,

fn lazy_flatten(self) -> LazyFlatten<Self>

where Self: Sized, Self::Item: Consumer,

fn lazy_copied<'a, T>(self) -> LazyCopied<Self>

where T: 'a + Copy, Self: Sized + Consumer<Item = &'a T>,

fn lazy_cloned<'a, T>(self) -> LazyCloned<Self>

where T: 'a + Clone, Self: Sized + Consumer<Item = &'a T>,

fn lazy_cycle(self) -> LazyCycle<Self>

where Self: Sized, Self::IntoIter: Clone,

impl<'a, I, T> IterableSeq for LazyCopied<I>

where T: 'a + Copy, I: IterableSeq<Item = &'a T>,

fn rev(self) -> Self::F

where Self: Sized, Self::F: Producer<Self::Item>, Self::IntoIter: DoubleEndedIterator,

fn sorted(self) -> Self::F

where Self: Sized, Self::Item: Ord, Self::F: Producer<Self::Item>,

fn sorted_by<F>(self, f: F) -> Self::F

where F: Fn(&Self::Item, &Self::Item) -> Ordering, Self: Sized, Self::F: Producer<Self::Item>,

fn sorted_by_key<K, F>(self, f: F) -> Self::F

where K: Ord, F: Fn(&Self::Item) -> K, Self: Sized, Self::F: Producer<Self::Item>,

fn lazy_rev(self) -> LazyRev<Self>

where Self: Sized, Self::IntoIter: DoubleEndedIterator,