Struct RepeatWith 

pub struct RepeatWith<'a, L: ?Sized, F> { /* private fields */ }

A lender that repeats an element endlessly by applying a closure.

This struct is created by the repeat_with() function.

Trait Implementations

impl<L: ?Sized, F: Clone> Clone for RepeatWith<'_, L, F>

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<L: ?Sized, F> Debug for RepeatWith<'_, L, F>

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

Formats the value using the given formatter.

impl<'a, L, F> DoubleEndedLender for RepeatWith<'a, L, F>

where L: ?Sized + CovariantLending + 'a, F: FnMut() -> Lend<'a, L>,

fn next_back(&mut self) -> Option<Lend<'_, Self>>

Removes and returns a lend from the end of the lender.

fn advance_back_by(&mut self, n: usize) -> Result<(), NonZeroUsize>

Advances the lender from the back by n elements.

fn nth_back(&mut self, n: usize) -> Option<Lend<'_, Self>>

Returns the nth element from the end of the lender.

fn try_rfold<B, F, R>(&mut self, init: B, f: F) -> R

where F: FnMut(B, Lend<'_, Self>) -> R, R: Try<Output = B>,

The reverse version of Lender::try_fold: it takes elements starting from the back of the lender.

fn rfold<B, F>(self, init: B, f: F) -> B

where Self: Sized, F: FnMut(B, Lend<'_, Self>) -> B,

The reverse version of Lender::fold: it takes elements starting from the back of the lender.

fn rfind<P>(&mut self, predicate: P) -> Option<Lend<'_, Self>>

where Self: Sized, P: FnMut(&Lend<'_, Self>) -> bool,

The reverse version of Lender::find: it searches for an element of the lender from the back that satisfies the predicate.

impl<'a, L, F> Lender for RepeatWith<'a, L, F>

where L: ?Sized + CovariantLending + 'a, F: FnMut() -> Lend<'a, L>,

fn advance_by(&mut self, n: usize) -> Result<(), NonZeroUsize>

Advances the lender by n elements.

Unlike Repeat::advance_by, which is a no-op, this method calls the closure n times (discarding the results) because the closure may have side effects.

fn __check_covariance<'long: 'short, 'short>( proof: CovariantProof<<Self as Lending<'long>>::Lend>, ) -> CovariantProof<<Self as Lending<'short>>::Lend>

Internal method for compile-time covariance checking.

fn next(&mut self) -> Option<Lend<'_, Self>>

Yields the next lend, if any, of the lender.

fn size_hint(&self) -> (usize, Option<usize>)

Gets the estimated minimum and maximum length of the lender. Use .len() for the exact length if the lender implements ExactSizeLender.

fn next_chunk(&mut self, chunk_size: usize) -> Chunk<'_, Self>

where Self: Sized,

Takes the next chunk_size lends of the lender with temporary lender Chunk. This is equivalent to cloning the lender and calling take(chunk_size) on it.

fn count(self) -> usize

where Self: Sized,

Counts the number of lends in the lender by consuming it.

fn last<'call>(&'call mut self) -> Option<Lend<'call, Self>>

where Self: Sized,

Gets the last lend of the lender, if any, by consuming it.

fn nth(&mut self, n: usize) -> Option<Lend<'_, Self>>

Yields the nth lend of the lender, if any, by consuming it. If the lender does not have enough lends, returns None.

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

where Self: Sized,

Skips step - 1 lends between each lend of the lender.

fn chain<U>(self, other: U) -> Chain<Self, <U as IntoLender>::Lender>

where Self: Sized, for<'all> U: IntoLender + Lending<'all, Lend = Lend<'all, Self>>,

Chains the lender with another lender of the same type.

fn zip<U: IntoLender>(self, other: U) -> Zip<Self, <U as IntoLender>::Lender>

where Self: Sized,

Zips the lender with another lender of the same or different type.

fn intersperse<'call>( self, separator: Lend<'call, Self>, ) -> Intersperse<'call, Self>

where Self: Sized, for<'all> Lend<'all, Self>: Clone,

Intersperses each lend of this lender with the given separator.

fn intersperse_with<'call, G>( self, separator: G, ) -> IntersperseWith<'call, Self, G>

where Self: Sized, G: FnMut() -> Lend<'call, Self>,

Intersperses each lend of this lender with the separator produced by the given function.

fn map<F>(self, f: Covar<F>) -> Map<Self, F>

where Self: Sized, F: for<'all> FnMutHKA<'all, Lend<'all, Self>>,

Maps each lend of this lender using the given function.

fn map_into_iter<O, F: FnMut(Lend<'_, Self>) -> O>( self, f: F, ) -> MapIntoIter<Self, O, F>

where Self: Sized,

Maps each lend of this lender into an owned value using the given function.

fn for_each<F>(self, f: F)

where Self: Sized, F: FnMut(Lend<'_, Self>),

Calls the given function with each lend of this lender.

fn filter<P>(self, predicate: P) -> Filter<Self, P>

where Self: Sized, P: FnMut(&Lend<'_, Self>) -> bool,

Filters this lender using the given predicate.

fn filter_map<F>(self, f: Covar<F>) -> FilterMap<Self, F>

where Self: Sized, F: for<'all> FnMutHKAOpt<'all, Lend<'all, Self>>,

Filters and maps this lender using the given function.

fn enumerate(self) -> Enumerate<Self>

where Self: Sized,

Enumerates this lender. Each lend is paired with its zero-based index.

fn peekable<'call>(self) -> Peekable<'call, Self>

where Self: Sized,

Makes this lender peekable, so that it is possible to peek at the next lend without consuming it.

fn skip_while<P>(self, predicate: P) -> SkipWhile<Self, P>

where Self: Sized, P: FnMut(&Lend<'_, Self>) -> bool,

Skips the first contiguous sequence of lends of this lender that satisfy the given predicate.

fn take_while<P>(self, predicate: P) -> TakeWhile<Self, P>

where Self: Sized, P: FnMut(&Lend<'_, Self>) -> bool,

Takes the first contiguous sequence of lends of this lender that satisfy the given predicate.

fn map_while<P>(self, predicate: Covar<P>) -> MapWhile<Self, P>

where Self: Sized, P: for<'all> FnMutHKAOpt<'all, Lend<'all, Self>>,

Maps this lender using the given function while it returns Some.

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

where Self: Sized,

Skips the first n lends of this lender.

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

where Self: Sized,

Takes the first n lends of this lender.

fn scan<St, F>(self, initial_state: St, f: Covar<F>) -> Scan<Self, St, F>

where Self: Sized, F: for<'all> FnMutHKAOpt<'all, (&'all mut St, Lend<'all, Self>)>,

The Lender version of Iterator::scan.

fn flat_map<'call, F>(self, f: Covar<F>) -> FlatMap<'call, Self, F>

where Self: Sized, F: for<'all> FnMutHKA<'all, Lend<'all, Self>>, for<'all> <F as FnMutHKA<'all, Lend<'all, Self>>>::B: IntoLender,

The Lender version of Iterator::flat_map.

fn flatten<'call>(self) -> Flatten<'call, Self>

where Self: Sized, for<'all> Lend<'all, Self>: IntoLender,

The Lender version of Iterator::flatten.

fn fuse(self) -> Fuse<Self>

where Self: Sized,

The Lender version of Iterator::fuse.

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

where Self: Sized, F: FnMut(&Lend<'_, Self>),

The Lender version of Iterator::inspect.

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

where Self: Sized, F: FnMut(&mut Lend<'_, Self>),

Mutates each lend with the given function.

fn by_ref(&mut self) -> &mut Self

where Self: Sized,

The Lender version of Iterator::by_ref.

fn collect<B>(self) -> B

where Self: Sized, B: FromLender<Self>,

The Lender version of Iterator::collect.

fn try_collect<'a, B>(&'a mut self) -> ChangeOutputType<Lend<'a, Self>, B>

where Self: Sized, for<'all> Lend<'all, Self>: Try, for<'all> <Lend<'all, Self> as Try>::Residual: Residual<B>, for<'all> B: FromLender<TryShunt<'all, &'a mut Self>>,

The Lender version of Iterator::try_collect.

fn collect_into<E>(self, collection: &mut E) -> &mut E

where Self: Sized, E: ExtendLender<Self>,

The Lender version of Iterator::collect_into.

fn partition<E, F>(self, f: F) -> (E, E)

where Self: Sized, E: Default + ExtendLender<Self>, F: FnMut(&Lend<'_, Self>) -> bool,

The Lender version of Iterator::partition.

fn is_partitioned<P>(self, predicate: P) -> bool

where Self: Sized, P: FnMut(Lend<'_, Self>) -> bool,

The Lender version of Iterator::is_partitioned.

fn try_fold<B, F, R>(&mut self, init: B, f: F) -> R

where F: FnMut(B, Lend<'_, Self>) -> R, R: Try<Output = B>,

The Lender version of Iterator::try_fold.

fn try_for_each<F, R>(&mut self, f: F) -> R

where F: FnMut(Lend<'_, Self>) -> R, R: Try<Output = ()>,

The Lender version of Iterator::try_for_each.

fn fold<B, F>(self, init: B, f: F) -> B

where Self: Sized, F: FnMut(B, Lend<'_, Self>) -> B,

The Lender version of Iterator::fold.

fn reduce<T, F>(self, f: F) -> Option<T>

where Self: Sized, for<'all> Lend<'all, Self>: ToOwned<Owned = T>, F: FnMut(T, Lend<'_, Self>) -> T,

The Lender version of Iterator::reduce.

fn try_reduce<T, F, R>(self, f: F) -> ChangeOutputType<R, Option<T>>

where Self: Sized, for<'all> Lend<'all, Self>: ToOwned<Owned = T>, F: FnMut(T, Lend<'_, Self>) -> R, R: Try<Output = T>, R::Residual: Residual<Option<T>>,

The Lender version of Iterator::try_reduce.

fn all<F>(&mut self, f: F) -> bool

where F: FnMut(Lend<'_, Self>) -> bool,

The Lender version of Iterator::all.

fn any<F>(&mut self, f: F) -> bool

where F: FnMut(Lend<'_, Self>) -> bool,

The Lender version of Iterator::any.

fn find<P>(&mut self, predicate: P) -> Option<Lend<'_, Self>>

where Self: Sized, P: FnMut(&Lend<'_, Self>) -> bool,

The Lender version of Iterator::find.

fn find_map<'a, F>( &'a mut self, f: F, ) -> Option<<F as FnMutHKAOpt<'a, Lend<'a, Self>>>::B>

where Self: Sized, F: for<'all> FnMutHKAOpt<'all, Lend<'all, Self>>,

The Lender version of Iterator::find_map.

fn try_find<F, R>( &mut self, f: F, ) -> ChangeOutputType<R, Option<Lend<'_, Self>>>

where Self: Sized, F: FnMut(&Lend<'_, Self>) -> R, R: Try<Output = bool>, for<'all> R::Residual: Residual<Option<Lend<'all, Self>>>,

The Lender version of Iterator::try_find.

fn position<P>(&mut self, predicate: P) -> Option<usize>

where Self: Sized, P: FnMut(Lend<'_, Self>) -> bool,

The Lender version of Iterator::position.

fn max<T: Ord>(self) -> Option<T>

where Self: Sized, for<'all> Lend<'all, Self>: ToOwned<Owned = T>,

The Lender version of Iterator::max.

fn min<T: Ord>(self) -> Option<T>

where Self: Sized, for<'all> Lend<'all, Self>: ToOwned<Owned = T>,

The Lender version of Iterator::min.

fn max_by_key<B: Ord, T, F>(self, f: F) -> Option<T>

where Self: Sized, for<'all> Lend<'all, Self>: ToOwned<Owned = T>, F: FnMut(&T) -> B,

The Lender version of Iterator::max_by_key.

fn max_by<T, F>(self, compare: F) -> Option<T>

where Self: Sized, for<'all> Lend<'all, Self>: ToOwned<Owned = T>, F: FnMut(&T, &Lend<'_, Self>) -> Ordering,

The Lender version of Iterator::max_by.

fn min_by_key<B: Ord, T, F>(self, f: F) -> Option<T>

where Self: Sized, for<'all> Lend<'all, Self>: ToOwned<Owned = T>, F: FnMut(&T) -> B,

The Lender version of Iterator::min_by_key.

fn min_by<T, F>(self, compare: F) -> Option<T>

where Self: Sized, for<'all> Lend<'all, Self>: ToOwned<Owned = T>, F: FnMut(&T, &Lend<'_, Self>) -> Ordering,

The Lender version of Iterator::min_by.

fn rev(self) -> Rev<Self>

where Self: Sized + DoubleEndedLender,

The Lender version of Iterator::rev.

fn unzip<ExtA, ExtB>(self) -> (ExtA, ExtB)

where Self: Sized, for<'all> Lend<'all, Self>: TupleLend<'all>, ExtA: Default + ExtendLender<FirstShunt<Self>>, ExtB: Default + ExtendLender<SecondShunt<Self>>,

The Lender version of Iterator::unzip.

fn copied<T>(self) -> Copied<Self>

where Self: Sized + for<'all> Lending<'all, Lend = &'all T>, T: Copy,

The Lender version of Iterator::copied.

fn cloned<T>(self) -> Cloned<Self>

where Self: Sized + for<'all> Lending<'all, Lend = &'all T>, T: Clone,

The Lender version of Iterator::cloned.

fn owned(self) -> Owned<Self>

where Self: Sized, for<'all> Lend<'all, Self>: ToOwned,

Turns this Lender into an Iterator.

fn cycle(self) -> Cycle<Self>

where Self: Sized + Clone,

The Lender version of Iterator::cycle.

fn sum<S>(self) -> S

where Self: Sized, S: SumLender<Self>,

The Lender version of Iterator::sum.

fn product<P>(self) -> P

where Self: Sized, P: ProductLender<Self>,

The Lender version of Iterator::product.

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

where L: IntoLender, L::Lender: for<'all> Lending<'all, Lend = Lend<'all, Self>>, for<'all> Lend<'all, Self>: Ord, Self: Sized,

The Lender version of Iterator::cmp.

fn cmp_by<L, F>(self, other: L, cmp: F) -> Ordering

where Self: Sized, L: IntoLender, F: for<'all> FnMut(Lend<'all, Self>, Lend<'all, L::Lender>) -> Ordering,

The Lender version of Iterator::cmp_by.

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

where L: IntoLender, for<'all> Lend<'all, Self>: PartialOrd<Lend<'all, L::Lender>>, Self: Sized,

The Lender version of Iterator::partial_cmp.

fn partial_cmp_by<L, F>(self, other: L, partial_cmp: F) -> Option<Ordering>

where Self: Sized, L: IntoLender, F: for<'all> FnMut(Lend<'all, Self>, Lend<'all, L::Lender>) -> Option<Ordering>,

The Lender version of Iterator::partial_cmp_by.

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

where L: IntoLender, for<'all> Lend<'all, Self>: PartialEq<Lend<'all, L::Lender>>, Self: Sized,

The Lender version of Iterator::eq.

fn eq_by<L, F>(self, other: L, eq: F) -> bool

where Self: Sized, L: IntoLender, F: for<'all> FnMut(Lend<'all, Self>, Lend<'all, L::Lender>) -> bool,

The Lender version of Iterator::eq_by.

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

where L: IntoLender, for<'all> Lend<'all, Self>: PartialEq<Lend<'all, L::Lender>>, Self: Sized,

The Lender version of Iterator::ne.

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

where L: IntoLender, for<'all> Lend<'all, Self>: PartialOrd<Lend<'all, L::Lender>>, Self: Sized,

The Lender version of Iterator::lt.

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

where L: IntoLender, for<'all> Lend<'all, Self>: PartialOrd<Lend<'all, L::Lender>>, Self: Sized,

The Lender version of Iterator::le.

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

where L: IntoLender, for<'all> Lend<'all, Self>: PartialOrd<Lend<'all, L::Lender>>, Self: Sized,

The Lender version of Iterator::gt.

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

where L: IntoLender, for<'all> Lend<'all, Self>: PartialOrd<Lend<'all, L::Lender>>, Self: Sized,

The Lender version of Iterator::ge.

fn is_sorted<T>(self) -> bool

where Self: Sized, for<'all> Lend<'all, Self>: ToOwned<Owned = T>, T: PartialOrd,

The Lender version of Iterator::is_sorted.

fn is_sorted_by<T, F>(self, compare: F) -> bool

where Self: Sized, for<'all> Lend<'all, Self>: ToOwned<Owned = T>, F: FnMut(&T, &T) -> Option<Ordering>,

The Lender version of Iterator::is_sorted_by.

fn is_sorted_by_key<F, K>(self, f: F) -> bool

where Self: Sized, F: FnMut(Lend<'_, Self>) -> K, K: PartialOrd,

The Lender version of Iterator::is_sorted_by_key.

fn iter<'this>(self) -> Iter<'this, Self>

where Self: Sized + 'this, for<'all> Lend<'all, Self>: 'this,

Turns this Lender into an Iterator where it has already fulfilled the requirements of the Iterator trait.

fn lender_by_ref<'this>(self) -> FromIterRef<Iter<'this, Self>>

where Self: Sized + 'this, for<'all> Lend<'all, Self>: 'this,

Turns this Lender into a new Lender that lends references to the items of the original lender.

fn convert<E>(self) -> Convert<E, Self>

where Self: Sized,

Converts a Lender whose lend type is Result<T, E> into a FallibleLender with error type E and lend type T.

fn into_fallible(self) -> IntoFallible<Self>

where Self: Sized,

Converts a Lender into a FallibleLender by wrapping into Result<Lend<'_, Self>, Infallible> where Infallible is an error that can never actually happen.

impl<'lend, 'a, L, F> Lending<'lend> for RepeatWith<'a, L, F>

where L: ?Sized + CovariantLending + 'a, F: FnMut() -> Lend<'a, L>,

type Lend = <L as Lending<'lend>>::Lend

The type being lent.

impl<'a, L, F> FusedLender for RepeatWith<'a, L, F>

where L: ?Sized + CovariantLending + 'a, F: FnMut() -> Lend<'a, L>,