Trait Lender 

pub trait Lender: for<'all> Lending<'all> {
    // Required methods
    fn __check_covariance<'long: 'short, 'short>(
        proof: CovariantProof<<Self as Lending<'long>>::Lend>,
    ) -> CovariantProof<<Self as Lending<'short>>::Lend>;
    fn next(&mut self) -> Option<Lend<'_, Self>>;

    // Provided methods
    fn next_chunk(&mut self, chunk_size: usize) -> Chunk<'_, Self>
       where Self: Sized { ... }
    fn size_hint(&self) -> (usize, Option<usize>) { ... }
    fn count(self) -> usize
       where Self: Sized { ... }
    fn last<'call>(&'call mut self) -> Option<Lend<'call, Self>>
       where Self: Sized { ... }
    fn advance_by(&mut self, n: usize) -> Result<(), NonZeroUsize> { ... }
    fn nth(&mut self, n: usize) -> Option<Lend<'_, Self>> { ... }
    fn step_by(self, step: usize) -> StepBy<Self>
       where Self: Sized { ... }
    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>> { ... }
    fn zip<U: IntoLender>(
        self,
        other: U,
    ) -> Zip<Self, <U as IntoLender>::Lender>
       where Self: Sized { ... }
    fn intersperse<'call>(
        self,
        separator: Lend<'call, Self>,
    ) -> Intersperse<'call, Self>
       where Self: Sized,
             for<'all> Lend<'all, Self>: Clone { ... }
    fn intersperse_with<'call, G>(
        self,
        separator: G,
    ) -> IntersperseWith<'call, Self, G>
       where Self: Sized,
             G: FnMut() -> Lend<'call, Self> { ... }
    fn map<F>(self, f: Covar<F>) -> Map<Self, F>
       where Self: Sized,
             F: for<'all> FnMutHKA<'all, Lend<'all, Self>> { ... }
    fn map_into_iter<O, F: FnMut(Lend<'_, Self>) -> O>(
        self,
        f: F,
    ) -> MapIntoIter<Self, O, F> 
       where Self: Sized { ... }
    fn for_each<F>(self, f: F)
       where Self: Sized,
             F: FnMut(Lend<'_, Self>) { ... }
    fn filter<P>(self, predicate: P) -> Filter<Self, P>
       where Self: Sized,
             P: FnMut(&Lend<'_, Self>) -> bool { ... }
    fn filter_map<F>(self, f: Covar<F>) -> FilterMap<Self, F>
       where Self: Sized,
             F: for<'all> FnMutHKAOpt<'all, Lend<'all, Self>> { ... }
    fn enumerate(self) -> Enumerate<Self>
       where Self: Sized { ... }
    fn peekable<'call>(self) -> Peekable<'call, Self>
       where Self: Sized { ... }
    fn skip_while<P>(self, predicate: P) -> SkipWhile<Self, P>
       where Self: Sized,
             P: FnMut(&Lend<'_, Self>) -> bool { ... }
    fn take_while<P>(self, predicate: P) -> TakeWhile<Self, P>
       where Self: Sized,
             P: FnMut(&Lend<'_, Self>) -> bool { ... }
    fn map_while<P>(self, predicate: Covar<P>) -> MapWhile<Self, P>
       where Self: Sized,
             P: for<'all> FnMutHKAOpt<'all, Lend<'all, Self>> { ... }
    fn skip(self, n: usize) -> Skip<Self>
       where Self: Sized { ... }
    fn take(self, n: usize) -> Take<Self>
       where Self: Sized { ... }
    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>)> { ... }
    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 { ... }
    fn flatten<'call>(self) -> Flatten<'call, Self>
       where Self: Sized,
             for<'all> Lend<'all, Self>: IntoLender { ... }
    fn fuse(self) -> Fuse<Self>
       where Self: Sized { ... }
    fn inspect<F>(self, f: F) -> Inspect<Self, F>
       where Self: Sized,
             F: FnMut(&Lend<'_, Self>) { ... }
    fn mutate<F>(self, f: F) -> Mutate<Self, F>
       where Self: Sized,
             F: FnMut(&mut Lend<'_, Self>) { ... }
    fn by_ref(&mut self) -> &mut Self
       where Self: Sized { ... }
    fn collect<B>(self) -> B
       where Self: Sized,
             B: FromLender<Self> { ... }
    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>> { ... }
    fn collect_into<E>(self, collection: &mut E) -> &mut E
       where Self: Sized,
             E: ExtendLender<Self> { ... }
    fn partition<E, F>(self, f: F) -> (E, E)
       where Self: Sized,
             E: Default + ExtendLender<Self>,
             F: FnMut(&Lend<'_, Self>) -> bool { ... }
    fn is_partitioned<P>(self, predicate: P) -> bool
       where Self: Sized,
             P: FnMut(Lend<'_, Self>) -> bool { ... }
    fn try_fold<B, F, R>(&mut self, init: B, f: F) -> R
       where F: FnMut(B, Lend<'_, Self>) -> R,
             R: Try<Output = B> { ... }
    fn try_for_each<F, R>(&mut self, f: F) -> R
       where F: FnMut(Lend<'_, Self>) -> R,
             R: Try<Output = ()> { ... }
    fn fold<B, F>(self, init: B, f: F) -> B
       where Self: Sized,
             F: FnMut(B, Lend<'_, Self>) -> B { ... }
    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 { ... }
    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>> { ... }
    fn all<F>(&mut self, f: F) -> bool
       where F: FnMut(Lend<'_, Self>) -> bool { ... }
    fn any<F>(&mut self, f: F) -> bool
       where F: FnMut(Lend<'_, Self>) -> bool { ... }
    fn find<P>(&mut self, predicate: P) -> Option<Lend<'_, Self>>
       where Self: Sized,
             P: FnMut(&Lend<'_, Self>) -> bool { ... }
    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>> { ... }
    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>>> { ... }
    fn position<P>(&mut self, predicate: P) -> Option<usize>
       where Self: Sized,
             P: FnMut(Lend<'_, Self>) -> bool { ... }
    fn rposition<P>(&mut self, predicate: P) -> Option<usize>
       where P: FnMut(Lend<'_, Self>) -> bool,
             Self: Sized + ExactSizeLender + DoubleEndedLender { ... }
    fn max<T: Ord>(self) -> Option<T>
       where Self: Sized,
             for<'all> Lend<'all, Self>: ToOwned<Owned = T> { ... }
    fn min<T: Ord>(self) -> Option<T>
       where Self: Sized,
             for<'all> Lend<'all, Self>: ToOwned<Owned = T> { ... }
    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 { ... }
    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 { ... }
    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 { ... }
    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 { ... }
    fn rev(self) -> Rev<Self>
       where Self: Sized + DoubleEndedLender { ... }
    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>> { ... }
    fn copied<T>(self) -> Copied<Self> 
       where Self: Sized + for<'all> Lending<'all, Lend = &'all T>,
             T: Copy { ... }
    fn cloned<T>(self) -> Cloned<Self> 
       where Self: Sized + for<'all> Lending<'all, Lend = &'all T>,
             T: Clone { ... }
    fn owned(self) -> Owned<Self> 
       where Self: Sized,
             for<'all> Lend<'all, Self>: ToOwned { ... }
    fn cycle(self) -> Cycle<Self>
       where Self: Sized + Clone { ... }
    fn sum<S>(self) -> S
       where Self: Sized,
             S: SumLender<Self> { ... }
    fn product<P>(self) -> P
       where Self: Sized,
             P: ProductLender<Self> { ... }
    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 { ... }
    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 { ... }
    fn partial_cmp<L>(self, other: L) -> Option<Ordering>
       where L: IntoLender,
             for<'all> Lend<'all, Self>: PartialOrd<Lend<'all, L::Lender>>,
             Self: Sized { ... }
    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> { ... }
    fn eq<L>(self, other: L) -> bool
       where L: IntoLender,
             for<'all> Lend<'all, Self>: PartialEq<Lend<'all, L::Lender>>,
             Self: Sized { ... }
    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 { ... }
    fn ne<L>(self, other: L) -> bool
       where L: IntoLender,
             for<'all> Lend<'all, Self>: PartialEq<Lend<'all, L::Lender>>,
             Self: Sized { ... }
    fn lt<L>(self, other: L) -> bool
       where L: IntoLender,
             for<'all> Lend<'all, Self>: PartialOrd<Lend<'all, L::Lender>>,
             Self: Sized { ... }
    fn le<L>(self, other: L) -> bool
       where L: IntoLender,
             for<'all> Lend<'all, Self>: PartialOrd<Lend<'all, L::Lender>>,
             Self: Sized { ... }
    fn gt<L>(self, other: L) -> bool
       where L: IntoLender,
             for<'all> Lend<'all, Self>: PartialOrd<Lend<'all, L::Lender>>,
             Self: Sized { ... }
    fn ge<L>(self, other: L) -> bool
       where L: IntoLender,
             for<'all> Lend<'all, Self>: PartialOrd<Lend<'all, L::Lender>>,
             Self: Sized { ... }
    fn is_sorted<T>(self) -> bool
       where Self: Sized,
             for<'all> Lend<'all, Self>: ToOwned<Owned = T>,
             T: PartialOrd { ... }
    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> { ... }
    fn is_sorted_by_key<F, K>(self, f: F) -> bool
       where Self: Sized,
             F: FnMut(Lend<'_, Self>) -> K,
             K: PartialOrd { ... }
    fn iter<'this>(self) -> Iter<'this, Self> 
       where Self: Sized + 'this,
             for<'all> Lend<'all, Self>: 'this { ... }
    fn lender_by_ref<'this>(self) -> FromIterRef<Iter<'this, Self>>
       where Self: Sized + 'this,
             for<'all> Lend<'all, Self>: 'this { ... }
    fn chunky(self, chunk_size: usize) -> Chunky<Self>
       where Self: Sized + ExactSizeLender { ... }
    fn convert<E>(self) -> Convert<E, Self>
       where Self: Sized { ... }
    fn into_fallible(self) -> IntoFallible<Self>
       where Self: Sized { ... }
}

A trait for dealing with lending iterators.

This is the main lender trait. For more about the concept of lenders generally, please see the crate documentation.

For more about the concept of iterators generally, please see core::iter.

Covariance Checking

This crate provide a mechanism to guarantee that the Lend type of a lender is covariant in its lifetime. This is crucial to avoid undefined behavior, as many of the operations on lenders rely on covariance to ensure that lends do not outlive their lenders.

The mechanism is based on the __check_covariance method of this trait, which is an internal method for compile-time covariance checking. Adapters relying on covariance of other lenders should call this method for the lenders they are adapting.

The mechanism can be circumvented with unsafe code, and in this case the burden of checking covariance is on the implementor. However, there’s no way to prevent that __check_covariance is implemented vacuously using a non-returning statement (todo!(), unimplemented!(), panic!(), loop {}, etc.), unless you call the method explicitly somewhere in your code. Adapters will call recursively adapted lenders, but there is no way to force the call on the user-facing type.

Required Methods

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.

This method should rarely be implemented directly. Instead, use the provided macros:

• When implementing source lenders (lenders with concrete Lend types), use check_covariance! in the Lender impl. The macro implements the method as { proof }, which only compiles if the Lend type is covariant in its lifetime. This happens because CovariantProof<T> is covariant in T, so an implicit coercion from CovariantProof<Lend<'long>> to CovariantProof<Lend<'short>> is only possible when Lend<'long> is a subtype of Lend<'short>, which is the definition of covariance.

• In all other cases (e.g., when implementing adapters), use unsafe_assume_covariance! in the Lender impl. The macro implements the method as { unsafe { core::mem::transmute(proof) } }, which is a no-op. This is unsafe because it is up to the implementor to guarantee that the Lend type is covariant in its lifetime.

When relying on covariance of other types, this method should be called in every constructor, or in every method requiring covariance, of such types. In particular, adapters should call this method for the lender they are adapting. The call makes it impossible to implement the check with non-returning code (todo!(), unimplemented!(), panic!(), loop {}, etc.).

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

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

Every lend is only guaranteed to be valid one at a time for any kind of lender.

Examples

let mut lender = [1, 2, 3].iter().into_lender();
assert_eq!(lender.next(), Some(&1));
assert_eq!(lender.next(), Some(&2));
assert_eq!(lender.next(), Some(&3));
assert_eq!(lender.next(), None);

Provided Methods

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.

Examples

let mut lender = [1, 2, 3].iter().into_lender();
let mut chunk_lender = lender.next_chunk(2);
assert_eq!(chunk_lender.next(), Some(&1));
assert_eq!(chunk_lender.next(), Some(&2));
assert_eq!(chunk_lender.next(), None);

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.

Examples

let mut lender = [1, 2, 3].iter().into_lender();
assert_eq!(lender.size_hint(), (3, Some(3)));

fn count(self) -> usize

where Self: Sized,

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

Examples

let mut lender = [1, 2, 3].iter().into_lender();
assert_eq!(lender.count(), 3);

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.

Unlike Iterator::last, this method takes &mut self rather than self because returning a lend that borrows from the lender requires the lender to remain alive.

Examples

let mut lender = [1, 2, 3].iter().into_lender();
assert_eq!(lender.last(), Some(&3));

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

Advances the lender by n lends.

Returns Ok(()) if n lends were successfully skipped.

Returns Err(NonZeroUsize) if the lender did not have enough lends, where the value is the number of lends that could not be skipped.

Examples

let mut lender = [1, 2, 3].iter().into_lender();
assert_eq!(lender.advance_by(2), Ok(()));
assert_eq!(lender.next(), Some(&3));

let mut lender = [1, 2].iter().into_lender();
// Trying to advance by 5 when only 2 elements remain
assert_eq!(lender.advance_by(5), Err(NonZeroUsize::new(3).unwrap()));

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.

n is zero-indexed.

Examples

let mut lender = [1, 2, 3].iter().into_lender();
assert_eq!(lender.nth(2), Some(&3));

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

where Self: Sized,

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

Panics

Panics if step is zero.

Examples

let mut lender = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10].iter().into_lender();
let mut step_lender = lender.step_by(2);
assert_eq!(step_lender.next(), Some(&1));
assert_eq!(step_lender.next(), Some(&3));
assert_eq!(step_lender.next(), Some(&5));
assert_eq!(step_lender.next(), Some(&7));
assert_eq!(step_lender.next(), Some(&9));
assert_eq!(step_lender.next(), None);

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.

The resulting lender will first yield all lends from self, then all lends from other.

Examples

let mut lender = [1, 2].iter().into_lender();
let mut other = [3, 4].iter().into_lender();
let mut chained = lender.chain(other);
assert_eq!(chained.next(), Some(&1));
assert_eq!(chained.next(), Some(&2));
assert_eq!(chained.next(), Some(&3));
assert_eq!(chained.next(), Some(&4));
assert_eq!(chained.next(), None);

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.

Examples

let mut lender = [1, 2].iter().into_lender();
let mut other = [3, 4].iter().into_lender();
let mut zipped = lender.zip(other);
assert_eq!(zipped.next(), Some((&1, &3)));
assert_eq!(zipped.next(), Some((&2, &4)));
assert_eq!(zipped.next(), None);

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.

Examples

let mut lender = [1, 2].iter().into_lender();
let mut interspersed = lender.intersperse(&0);
assert_eq!(interspersed.next(), Some(&1));
assert_eq!(interspersed.next(), Some(&0));
assert_eq!(interspersed.next(), Some(&2));
assert_eq!(interspersed.next(), None);

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.

Examples

let mut lender = [1, 2].iter().into_lender();
let mut interspersed = lender.intersperse_with(|| &0);
assert_eq!(interspersed.next(), Some(&1));
assert_eq!(interspersed.next(), Some(&0));
assert_eq!(interspersed.next(), Some(&2));
assert_eq!(interspersed.next(), None);

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.

Note that functions passed to this method must be built using the covar! or covar_mut! macros, which also checks for covariance of the returned type.

Examples

let mut data = [1, 2];
let mut lender = lender::lend_iter::<lend!(&'lend mut i32), _>(data.iter_mut());
let mut mapped = lender.map(covar_mut!(for<'all>
    |a: &'all mut i32| -> &'all i32 {
    *a += 1;
    &*a
}));
assert_eq!(mapped.next(), Some(&2));
assert_eq!(mapped.next(), Some(&3));
assert_eq!(mapped.next(), None);

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.

This is a weaker version of Lender::map that returns an Iterator instead of a Lender. However, this behavior is very common, and so this method is included for convenience. The main advantage is better type inference for the mapping function.

Examples

let mut data = [1, 2];
let mut lender = data.iter_mut().into_lender();
let mut mapped_into_iter = lender.map_into_iter(|a| {
    *a += 1;
    *a
});
assert_eq!(mapped_into_iter.next(), Some(2));
assert_eq!(mapped_into_iter.next(), Some(3));
assert_eq!(mapped_into_iter.next(), None);

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

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

Calls the given function with each lend of this lender.

Examples

let mut lender = [1, 2].iter().into_lender();
lender.for_each(|a| {
    let _ = *a + 1;
});

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

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

Filters this lender using the given predicate.

Examples

let mut lender = [1, 2].iter().into_lender();
let mut filtered = lender.filter(|&a| *a > 1);
assert_eq!(filtered.next(), Some(&2));
assert_eq!(filtered.next(), None);

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.

Note that functions passed to this method must be built using the covar! or covar_mut! macros, which also checks for covariance of the returned type.

Examples

let mut data = [1, 2];
let mut lender = lender::lend_iter::<lend!(&'lend mut i32), _>(data.iter_mut());
let mut filtered = lender.filter_map(
    covar_mut!(for<'all>
        |a: &'all mut i32| -> Option<&'all i32> {
    if *a > 1 {
        Some(&*a)
    } else {
        None
    }
}));
assert_eq!(filtered.next(), Some(&2));
assert_eq!(filtered.next(), None);

fn enumerate(self) -> Enumerate<Self>

where Self: Sized,

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

Examples

let mut lender = [1, 2].iter().into_lender();
let mut enumerated = lender.enumerate();
assert_eq!(enumerated.next(), Some((0, &1)));
assert_eq!(enumerated.next(), Some((1, &2)));
assert_eq!(enumerated.next(), None);

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.

Examples

let mut lender = [1, 2].iter().into_lender();
let mut peekable = lender.peekable();
assert_eq!(peekable.peek(), Some(&&1));
assert_eq!(peekable.next(), Some(&1));
assert_eq!(peekable.peek(), Some(&&2));
assert_eq!(peekable.next(), Some(&2));
assert_eq!(peekable.peek(), None);

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.

Examples

let mut lender = [1, 2, 3, 4, 5].iter().into_lender();
let mut skipped = lender.skip_while(|&a| *a < 3);
assert_eq!(skipped.next(), Some(&3));
assert_eq!(skipped.next(), Some(&4));
assert_eq!(skipped.next(), Some(&5));
assert_eq!(skipped.next(), None);

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.

Examples

let mut lender = [1, 2, 3, 4, 5].iter().into_lender();
let mut taken = lender.take_while(|&a| *a < 3);
assert_eq!(taken.next(), Some(&1));
assert_eq!(taken.next(), Some(&2));
assert_eq!(taken.next(), None);

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.

Note that functions passed to this method must be built using the covar! or covar_mut! macros, which also checks for covariance of the returned type.

Examples

let mut data = [1, 2];
let mut lender = lender::lend_iter::<lend!(&'lend mut i32), _>(data.iter_mut());
let mut mapped = lender.map_while(
    covar_mut!(for<'all>
        |a: &'all mut i32| -> Option<&'all i32> {
    if *a < 2 {
        Some(&*a)
    } else {
        None
    }
}));
assert_eq!(mapped.next(), Some(&1));
assert_eq!(mapped.next(), None);

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

where Self: Sized,

Skips the first n lends of this lender.

Examples

let mut lender = [1, 2, 3, 4, 5].iter().into_lender();
let mut skipped = lender.skip(3);
assert_eq!(skipped.next(), Some(&4));
assert_eq!(skipped.next(), Some(&5));
assert_eq!(skipped.next(), None);

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

where Self: Sized,

Takes the first n lends of this lender.

Examples

let mut lender = [1, 2, 3, 4, 5].iter().into_lender();
let mut taken = lender.take(2);
assert_eq!(taken.next(), Some(&1));
assert_eq!(taken.next(), Some(&2));
assert_eq!(taken.next(), None);

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.

Note that functions passed to this method must be built using the covar! or covar_mut! macros, which also checks for covariance of the returned type.

Examples

let mut lender = lender::lend_iter::<lend!(&'lend i32), _>([1, 2, 3].iter());
let mut scanned = lender.scan(0,
    covar_mut!(for<'all>
        |args: (&'all mut i32, &'all i32)|
            -> Option<&'all i32> {
    *args.0 += *args.1;
    Some(args.1)
}));
assert_eq!(scanned.next(), Some(&1));
assert_eq!(scanned.next(), Some(&2));

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.

Note that functions passed to this method must be built using the covar! or covar_mut! macro, which also checks for covariance of the returned type.

Examples

// Define a wrapper that implements Lender
struct VecLender(Vec<i32>);

impl<'lend> Lending<'lend> for VecLender {
    type Lend = i32;
}

impl Lender for VecLender {
    check_covariance!();
    fn next(&mut self) -> Option<Lend<'_, Self>> {
        if self.0.is_empty() { None } else { Some(self.0.remove(0)) }
    }
}

let data = [1, 2, 3];
let mut flat = data.into_iter().into_lender().flat_map(
    covar_mut!(for<'lend> |x: i32| -> VecLender { VecLender(vec![x, x * 10]) })
);
assert_eq!(flat.next(), Some(1));
assert_eq!(flat.next(), Some(10));
assert_eq!(flat.next(), Some(2));

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

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

The Lender version of Iterator::flatten.

Examples

let data = [vec![1, 2], vec![3, 4]];
let mut flat = data.into_iter()
    .map(|v| v.into_iter().into_lender())
    .into_lender()
    .flatten();
assert_eq!(flat.next(), Some(1));
assert_eq!(flat.next(), Some(2));
assert_eq!(flat.next(), Some(3));
assert_eq!(flat.next(), Some(4));
assert_eq!(flat.next(), None);

fn fuse(self) -> Fuse<Self>

where Self: Sized,

The Lender version of Iterator::fuse.

Examples

let mut lender = [1, 2].iter().into_lender();
let mut fused = lender.fuse();
assert_eq!(fused.next(), Some(&1));
assert_eq!(fused.next(), Some(&2));
assert_eq!(fused.next(), None);
assert_eq!(fused.next(), None);

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

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

The Lender version of Iterator::inspect.

Examples

let mut lender = [1, 2, 3].iter().into_lender();
let mut sum = 0;
let mut inspected = lender.inspect(|&x| sum += x);
assert_eq!(inspected.next(), Some(&1));
assert_eq!(inspected.next(), Some(&2));
assert_eq!(inspected.next(), Some(&3));
assert_eq!(inspected.next(), None);
assert_eq!(sum, 6);

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

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

Mutates each lend with the given function.

Examples

let mut data = [1, 2, 3];
let mut lender = data.iter_mut().into_lender();
let mut mutated = lender.mutate(|x| **x += 10);
assert_eq!(mutated.next(), Some(&mut 11));
assert_eq!(mutated.next(), Some(&mut 12));
assert_eq!(mutated.next(), Some(&mut 13));
assert_eq!(mutated.next(), None);

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

where Self: Sized,

The Lender version of Iterator::by_ref.

Examples

let mut lender = [1, 2, 3, 4, 5].iter().into_lender();
// Take the first two elements using by_ref, so the original lender
// is not consumed.
let mut first_two = lender.by_ref().take(2);
assert_eq!(first_two.next(), Some(&1));
assert_eq!(first_two.next(), Some(&2));
assert_eq!(first_two.next(), None);
drop(first_two);
// Continue iterating from the third element.
assert_eq!(lender.next(), Some(&3));

fn collect<B>(self) -> B

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

The Lender version of Iterator::collect.

Examples

let lender = lender::lend_iter::<lend!(&'lend i32), _>([1, 2, 3].iter());
let collected: Vec<i32> = lender.copied().collect();
assert_eq!(collected, vec![1, 2, 3]);

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.

Collects the lends of a lender that are themselves Try types into a collection of their outputs, short-circuiting on Try failures.

This method requires the target collection type B to implement FromLender for the [TryShunt] adapter. See FromLender for how to implement this trait.

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

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

The Lender version of Iterator::collect_into.

Extends an existing collection with lends from this lender. The collection type must implement ExtendLender for this lender type.

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.

Examples

let lender = lender::lend_iter::<lend!(&'lend i32), _>([1, 2, 3, 4, 5].iter());
let (even, odd): (Vec<i32>, Vec<i32>) =
    lender.copied().partition(|x| x % 2 == 0);
assert_eq!(even, vec![2, 4]);
assert_eq!(odd, vec![1, 3, 5]);

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

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

The Lender version of Iterator::is_partitioned.

Examples

// [1, 3, 2, 4] is partitioned: all odd elements come before all even elements.
let mut lender = [1, 3, 2, 4].iter().into_lender();
assert!(lender.is_partitioned(|&x| x % 2 != 0));

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.

Examples

let mut lender = [1, 2, 3].iter().into_lender();
let sum = lender.try_fold(0, |acc: i32, &x| acc.checked_add(x));
assert_eq!(sum, Some(6));

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.

Examples

let mut lender = [1, 2, 3].iter().into_lender();
let result = lender.try_for_each(|&x| if x < 3 { Some(()) } else { None });
assert_eq!(result, None);

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.

Examples

let mut lender = [1, 2, 3].iter().into_lender();
let sum = lender.fold(0, |acc, &x| acc + x);
assert_eq!(sum, 6);

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.

Examples

let lender = lender::lend_iter::<lend!(&'lend i32), _>([1, 2, 3].iter());
let max = lender.copied().reduce(|max, x| if x > max { x } else { max });
assert_eq!(max, Some(3));

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.

Examples

let lender = [1, 2, 3].into_iter().into_lender();
let sum = lender.try_reduce(|acc: i32, x| acc.checked_add(x));
assert_eq!(sum, Some(Some(6)));

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

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

The Lender version of Iterator::all.

Examples

let mut lender = [1, 2, 3].iter().into_lender();
assert!(lender.all(|&x| x > 0));

let mut lender = [1, 2, 3].iter().into_lender();
assert!(!lender.all(|&x| x > 2));

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

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

The Lender version of Iterator::any.

Examples

let mut lender = [1, 2, 3].iter().into_lender();
assert!(lender.any(|&x| x == 2));

let mut lender = [1, 2, 3].iter().into_lender();
assert!(!lender.any(|&x| x > 5));

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

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

The Lender version of Iterator::find.

Examples

let mut lender = [1, 2, 3].iter().into_lender();
assert_eq!(lender.find(|&x| *x == 2), Some(&2));

let mut lender = [1, 2, 3].iter().into_lender();
assert_eq!(lender.find(|&x| *x > 5), None);

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.

Examples

let mut data = [1, 2, 3];
let mut lender = lender::lend_iter::<lend!(&'lend mut i32), _>(data.iter_mut());
let found = lender.find_map(|x: &mut i32| {
    if *x > 1 { Some(*x) } else { None }
});
assert_eq!(found, Some(2));

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.

Examples

let mut lender = [1, 2, 3].iter().into_lender();
let result: Option<Option<&i32>> =
    lender.try_find(|&x| Some(*x > 1));
assert_eq!(result, Some(Some(&2)));

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

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

The Lender version of Iterator::position.

Examples

let mut lender = [1, 2, 3].iter().into_lender();
assert_eq!(lender.position(|&x| x == 2), Some(1));

let mut lender = [1, 2, 3].iter().into_lender();
assert_eq!(lender.position(|&x| x > 5), None);

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

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

The Lender version of Iterator::rposition.

Examples

let mut lender = [1, 2, 3, 2, 1].iter().into_lender();
assert_eq!(lender.rposition(|&x| x == 2), Some(3));

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

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

The Lender version of Iterator::max.

Examples

let lender = [1, 3, 2].into_iter().into_lender();
assert_eq!(lender.max(), Some(3));

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

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

The Lender version of Iterator::min.

Examples

let lender = [3, 1, 2].into_iter().into_lender();
assert_eq!(lender.min(), Some(1));

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.

Examples

let lender =
    [-3, 0, 1, 5, -10].into_iter().into_lender();
assert_eq!(
    lender.max_by_key(|x: &i32| x.abs()),
    Some(-10)
);

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.

Examples

let lender =
    [-3, 0, 1, 5, -10].into_iter().into_lender();
assert_eq!(
    lender.max_by(|a: &i32, b: &i32| a.abs().cmp(&b.abs())),
    Some(-10)
);

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.

Examples

let lender =
    [-3, 0, 1, 5, -10].into_iter().into_lender();
assert_eq!(
    lender.min_by_key(|x: &i32| x.abs()),
    Some(0)
);

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.

Examples

let lender =
    [-3, 0, 1, 5, -10].into_iter().into_lender();
assert_eq!(
    lender.min_by(|a: &i32, b: &i32| a.abs().cmp(&b.abs())),
    Some(0)
);

fn rev(self) -> Rev<Self>

where Self: Sized + DoubleEndedLender,

The Lender version of Iterator::rev.

Examples

let lender = lender::lend_iter::<lend!(&'lend i32), _>(
    [1, 2, 3].iter(),
);
let result: Vec<i32> =
    lender.rev().copied().collect();
assert_eq!(result, vec![3, 2, 1]);

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.

Examples

let lender = lender::lend_iter::<lend!(&'lend (i32, char)), _>(
    [(1, 'a'), (2, 'b'), (3, 'c')].iter()
);
let (nums, chars): (Vec<i32>, Vec<char>) = lender.copied().unzip();
assert_eq!(nums, vec![1, 2, 3]);
assert_eq!(chars, vec!['a', 'b', 'c']);

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

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

The Lender version of Iterator::copied.

Turns this Lender into an Iterator.

Examples

let lender = lender::lend_iter::<lend!(&'lend i32), _>(
    [1, 2, 3].iter(),
);
let result: Vec<i32> = lender.copied().collect();
assert_eq!(result, vec![1, 2, 3]);

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

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

The Lender version of Iterator::cloned.

Turns this Lender into an Iterator.

Examples

let data =
    [String::from("a"), String::from("b")];
let lender = lender::lend_iter::<
    lend!(&'lend String),
    _,
>(data.iter());
let result: Vec<String> =
    lender.cloned().collect();
assert_eq!(
    result,
    vec![String::from("a"), String::from("b")]
);

fn owned(self) -> Owned<Self>

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

Turns this Lender into an Iterator.

Examples

let lender = [1, 2, 3].into_iter().into_lender();
let result: Vec<i32> = lender.owned().collect();
assert_eq!(result, vec![1, 2, 3]);

fn cycle(self) -> Cycle<Self>

where Self: Sized + Clone,

The Lender version of Iterator::cycle.

Examples

let mut lender = [1, 2].iter().into_lender().cycle();
assert_eq!(lender.next(), Some(&1));
assert_eq!(lender.next(), Some(&2));
assert_eq!(lender.next(), Some(&1));
assert_eq!(lender.next(), Some(&2));

fn sum<S>(self) -> S

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

The Lender version of Iterator::sum.

Examples

let lender = lender::lend_iter::<lend!(&'lend i32), _>([1, 2, 3].iter());
let total: i32 = lender.copied().sum();
assert_eq!(total, 6);

fn product<P>(self) -> P

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

The Lender version of Iterator::product.

Examples

let lender = lender::lend_iter::<lend!(&'lend i32), _>([1, 2, 3].iter());
let total: i32 = lender.copied().product();
assert_eq!(total, 6);

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.

Note: Due to HRTB limitations, consider using cmp_by instead.

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.

Note: the closure receives both lends under a single lifetime (for<'all>). This is an HRTB limitation: the two lenders cannot be advanced independently within the closure.

Examples

let a = [1, 2, 3].into_iter().into_lender();
let b = [1, 2, 4].into_iter().into_lender();
assert_eq!(a.cmp_by(b, |x: i32, y: i32| x.cmp(&y)), Ordering::Less);

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.

Note: Due to HRTB limitations, consider using partial_cmp_by instead.

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.

See cmp_by for a note on the unified lifetime constraint.

Examples

let a = [1, 2].into_iter().into_lender();
let b = [1, 3].into_iter().into_lender();
assert_eq!(
    a.partial_cmp_by(b, |x: i32, y: i32| x.partial_cmp(&y)),
    Some(Ordering::Less)
);

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.

Note: Due to HRTB limitations, consider using eq_by instead.

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.

See cmp_by for a note on the unified lifetime constraint.

Examples

let a = [1, 2, 3].into_iter().into_lender();
let b = [2, 3, 4].into_iter().into_lender();
assert!(a.eq_by(b, |x: i32, y: i32| x + 1 == y));

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.

Note: Due to HRTB limitations, consider using eq_by instead.

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.

Note: Due to HRTB limitations, consider using partial_cmp_by instead.

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.

Note: Due to HRTB limitations, consider using partial_cmp_by instead.

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.

Note: Due to HRTB limitations, consider using partial_cmp_by instead.

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.

Note: Due to HRTB limitations, consider using partial_cmp_by instead.

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.

Examples

let lender = [1, 2, 3].into_iter().into_lender();
assert!(lender.is_sorted());

let lender = [3, 1, 2].into_iter().into_lender();
assert!(!lender.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.

Examples

let lender = [3, 2, 1].into_iter().into_lender();
assert!(lender.is_sorted_by(|a, b| b.partial_cmp(a)));

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.

Examples

let mut lender = [1, -2, -3].into_iter().into_lender();
assert!(lender.is_sorted_by_key(|x: i32| x.unsigned_abs()));

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.

Note: Due to HRTB limitations, consider using copied or cloned instead if you need to collect into a container.

Examples

let lender =
    [1, 2, 3].into_iter().into_lender();
let v: Vec<i32> = lender.iter().collect();
assert_eq!(v, vec![1, 2, 3]);

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.

This is a convenience for self.iter().into_ref_lender(): first, iter converts this lender into an Iterator; then, into_ref_lender wraps it back into a Lender that stores each element and lends a reference to it.

Examples

let mut lender =
    [1, 2, 3].into_iter().into_lender()
        .lender_by_ref();
let item: &i32 = lender.next().unwrap();
assert_eq!(*item, 1);

fn chunky(self, chunk_size: usize) -> Chunky<Self>

where Self: Sized + ExactSizeLender,

A lending replacement for Iterator::array_chunks.

It is not possible to implement the exact behavior of Iterator::array_chunks in a lender, so this is the closest approximation: at each iteration, it yields a lender returning the next chunk_size lends.

Examples

let mut lender = lender::lend_iter::<lend!(&'lend i32), _>([1, 2, 3].iter());
let mut chunky = lender.chunky(2);
let mut chunk1 = chunky.next().unwrap();
assert_eq!(chunk1.next(), Some(&1));
assert_eq!(chunk1.next(), Some(&2));
assert_eq!(chunk1.next(), None);
let mut chunk2 = chunky.next().unwrap();
assert_eq!(chunk2.next(), Some(&3));
assert_eq!(chunk2.next(), None);

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.

This is the lending equivalent of fallible_iterator::convert.

Examples

let data = [Ok(1), Ok(2), Err("oops")];
let mut lender = data.into_iter().into_lender()
    .convert::<&str>();
assert_eq!(lender.next(), Ok(Some(1)));
assert_eq!(lender.next(), Ok(Some(2)));
assert!(lender.next().is_err());

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.

Examples

let lender =
    [1, 2, 3].into_iter().into_lender();
let mut fallible = lender.into_fallible();
assert_eq!(fallible.next(), Ok(Some(1)));
assert_eq!(fallible.next(), Ok(Some(2)));
assert_eq!(fallible.next(), Ok(Some(3)));
assert_eq!(fallible.next(), Ok(None));

Dyn Compatibility

This trait is not dyn compatible.

In older versions of Rust, dyn compatibility was called "object safety", so this trait is not object safe.

Implementations on Foreign Types

impl<L: Lender> Lender for &mut L

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

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

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

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

Implementors

impl<'a, L> Lender for Once<'a, L>

where L: ?Sized + CovariantLending,

impl<'a, L> Lender for Repeat<'a, L>

where L: ?Sized + CovariantLending + 'a, for<'all> Lend<'all, L>: Clone,

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

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

impl<'a, L, I> Lender for LendIter<'a, L, I>

where L: ?Sized + CovariantLending + 'a, I: Iterator<Item = Lend<'a, L>>,

impl<'this, L> Lender for Intersperse<'this, L>

where for<'all> Lend<'all, L>: Clone, L: Lender,

impl<'this, L> Lender for Peekable<'this, L>

where L: Lender,

impl<'this, L, G> Lender for IntersperseWith<'this, L, G>

where L: Lender, G: FnMut() -> Lend<'this, L>,

impl<A, B> Lender for Chain<A, B>

where A: Lender, B: Lender + for<'all> Lending<'all, Lend = Lend<'all, A>>,

impl<A, B> Lender for Zip<A, B>

where A: Lender, B: Lender,

impl<I: Iterator> Lender for FromIter<I>

impl<I: Iterator> Lender for FromIterRef<I>

impl<L> Lender for Chunky<L>

where L: Lender,

impl<L> Lender for Cycle<L>

where L: Clone + Lender,

impl<L> Lender for Empty<L>

where L: ?Sized + for<'all> Lending<'all>,

impl<L> Lender for Enumerate<L>

where L: Lender,

impl<L> Lender for Fuse<L>

where L: Lender,

impl<L> Lender for Rev<L>

where L: DoubleEndedLender,

impl<L> Lender for Skip<L>

where L: Lender,

impl<L> Lender for StepBy<L>

where L: Lender,

impl<L> Lender for Take<L>

where L: Lender,

impl<L, F> Lender for FilterMap<L, F>

where for<'all> F: FnMutHKAOpt<'all, Lend<'all, L>>, L: Lender,

impl<L, F> Lender for Inspect<L, F>

where L: Lender, F: FnMut(&Lend<'_, L>),

impl<L, F> Lender for Map<L, F>

where F: for<'all> FnMutHKA<'all, Lend<'all, L>>, L: Lender,

impl<L, F> Lender for Mutate<L, F>

where L: Lender, F: FnMut(&mut Lend<'_, L>),

impl<L, P> Lender for Filter<L, P>

where P: FnMut(&Lend<'_, L>) -> bool, L: Lender,

impl<L, P> Lender for MapWhile<L, P>

where P: for<'all> FnMutHKAOpt<'all, Lend<'all, L>>, L: Lender,

impl<L, P> Lender for SkipWhile<L, P>

where P: FnMut(&Lend<'_, L>) -> bool, L: Lender,

impl<L, P> Lender for TakeWhile<L, P>

where P: FnMut(&Lend<'_, L>) -> bool, L: Lender,

impl<L, St, F> Lender for Scan<L, St, F>

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

impl<L: Lender> Lender for Flatten<'_, L>

where for<'all> Lend<'all, L>: IntoLender,

impl<L: Lender, F> Lender for FlatMap<'_, L, F>

where Map<L, F>: Lender, for<'all> Lend<'all, Map<L, F>>: IntoLender,

impl<St, F> Lender for FromFn<St, F>

where F: for<'all> FnMutHKAOpt<'all, &'all mut St>,

impl<St, F> Lender for OnceWith<St, F>

where F: for<'all> FnOnceHKA<'all, &'all mut St>,

impl<T> Lender for Chunk<'_, T>

where T: Lender,

impl<T> Lender for WindowsMut<'_, T>

impl<T, const WINDOW_SIZE: usize> Lender for ArrayWindowsMut<'_, T, WINDOW_SIZE>