Trait gat_lending_iterator::LendingIterator

pub trait LendingIterator {
    type Item<'a>
       where Self: 'a;

    // Required method
    fn next(&mut self) -> Option<Self::Item<'_>>;

    // Provided methods
    fn size_hint(&self) -> (usize, Option<usize>) { ... }
    fn count(self) -> usize
       where Self: Sized { ... }
    fn advance_by(&mut self, n: usize) -> Result<(), NonZeroUsize> { ... }
    fn nth(&mut self, n: usize) -> Option<Self::Item<'_>> { ... }
    fn step_by(self, step: usize) -> StepBy<Self>
       where Self: Sized { ... }
    fn take(self, n: usize) -> Take<Self>
       where Self: Sized { ... }
    fn take_while<P>(self, predicate: P) -> TakeWhile<Self, P>
       where Self: Sized,
             P: for<'a> FnMut(&Self::Item<'a>) -> bool { ... }
    fn chain<I>(self, other: I) -> Chain<Self, I>
       where Self: Sized,
             for<'a> I: LendingIterator<Item<'a> = Self::Item<'a>> + 'a { ... }
    fn zip<I>(self, other: I) -> Zip<Self, I>
       where Self: Sized,
             I: LendingIterator { ... }
    fn map<F>(self, f: F) -> Map<Self, F>
       where Self: Sized,
             F: for<'a> SingleArgFnMut<Self::Item<'a>> { ... }
    fn for_each<F>(self, f: F)
       where Self: Sized,
             F: FnMut(Self::Item<'_>) { ... }
    fn filter<P>(self, predicate: P) -> Filter<Self, P>
       where Self: Sized,
             P: for<'a> FnMut(&Self::Item<'a>) -> bool { ... }
    fn filter_map<F>(self, f: F) -> FilterMap<Self, F>
       where Self: Sized,
             F: for<'a> SingleArgFnMut<Self::Item<'a>>,
             for<'a> <F as SingleArgFnOnce<Self::Item<'a>>>::Output: OptionTrait { ... }
    fn fold<B, F>(self, init: B, f: F) -> B
       where Self: Sized,
             F: FnMut(B, Self::Item<'_>) -> B { ... }
    fn cloned<T>(self) -> Cloned<Self>
       where Self: Sized,
             for<'a> Self::Item<'a>: Deref<Target = T>,
             T: Clone { ... }
    fn enumerate(self) -> Enumerate<Self>
       where Self: Sized { ... }
    fn skip(self, n: usize) -> Skip<Self>
       where Self: Sized { ... }
    fn skip_while<P>(self, predicate: P) -> SkipWhile<Self, P>
       where Self: Sized,
             P: for<'a> FnMut(&Self::Item<'a>) -> bool { ... }
    fn by_ref(&mut self) -> &mut Self
       where Self: Sized { ... }
    fn all<P>(&mut self, predicate: P) -> bool
       where P: FnMut(Self::Item<'_>) -> bool { ... }
    fn any<P>(&mut self, predicate: P) -> bool
       where P: FnMut(Self::Item<'_>) -> bool { ... }
    fn is_partitioned<P>(self, predicate: P) -> bool
       where Self: Sized,
             P: FnMut(Self::Item<'_>) -> bool { ... }
    fn find<P>(&mut self, predicate: P) -> Option<Self::Item<'_>>
       where P: FnMut(&Self::Item<'_>) -> bool { ... }
    fn find_map<B, F>(&mut self, f: F) -> Option<B>
       where F: FnMut(Self::Item<'_>) -> Option<B> { ... }
    fn position<P>(&mut self, predicate: P) -> Option<usize>
       where P: FnMut(Self::Item<'_>) -> bool { ... }
    fn cmp<I>(self, other: I) -> Ordering
       where I: for<'a> LendingIterator<Item<'a> = Self::Item<'a>>,
             for<'a> Self::Item<'a>: Ord,
             Self: Sized { ... }
    fn cmp_by<I, F>(self, other: I, cmp: F) -> Ordering
       where Self: Sized,
             I: LendingIterator,
             F: FnMut(Self::Item<'_>, I::Item<'_>) -> Ordering { ... }
    fn partial_cmp<I>(self, other: I) -> Option<Ordering>
       where I: LendingIterator,
             for<'a> Self::Item<'a>: PartialOrd<I::Item<'a>>,
             Self: Sized { ... }
    fn partial_cmp_by<I, F>(self, other: I, partial_cmp: F) -> Option<Ordering>
       where Self: Sized,
             I: LendingIterator,
             F: FnMut(Self::Item<'_>, I::Item<'_>) -> Option<Ordering> { ... }
    fn eq<I>(self, other: I) -> bool
       where I: LendingIterator,
             for<'a> Self::Item<'a>: PartialEq<I::Item<'a>>,
             Self: Sized { ... }
    fn eq_by<I, F>(self, other: I, eq: F) -> bool
       where Self: Sized,
             I: LendingIterator,
             F: FnMut(Self::Item<'_>, I::Item<'_>) -> bool { ... }
    fn ne<I>(self, other: I) -> bool
       where I: LendingIterator,
             for<'a> Self::Item<'a>: PartialEq<I::Item<'a>>,
             Self: Sized { ... }
    fn lt<I>(self, other: I) -> bool
       where I: LendingIterator,
             for<'a> Self::Item<'a>: PartialOrd<I::Item<'a>>,
             Self: Sized { ... }
    fn le<I>(self, other: I) -> bool
       where I: LendingIterator,
             for<'a> Self::Item<'a>: PartialOrd<I::Item<'a>>,
             Self: Sized { ... }
    fn gt<I>(self, other: I) -> bool
       where I: LendingIterator,
             for<'a> Self::Item<'a>: PartialOrd<I::Item<'a>>,
             Self: Sized { ... }
    fn ge<I>(self, other: I) -> bool
       where I: LendingIterator,
             for<'a> Self::Item<'a>: PartialOrd<I::Item<'a>>,
             Self: Sized { ... }
}

Like Iterator, but items may borrow from &mut self.

This means that the compiler will check that you finish using an item before requesting the next item, as it’s not allowed for two &mut self to exist at the same time.

Required Associated Types

type Item<'a> where Self: 'a

The type of the elements being iterated over.

Required Methods

fn next(&mut self) -> Option<Self::Item<'_>>

Advances the lending iterator and returns the next value.

See Iterator::next.

Provided Methods

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

Returns the bounds on the remaining length of the iterator.

See Iterator::size_hint.

fn count(self) -> usize

where Self: Sized,

Returns the number of items in the lending iterator.

See Iterator::count.

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

Advances the lending iterator by n elements.

See Iterator::advance_by.

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

Returns the nth element of the lending iterator.

See Iterator::nth.

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

where Self: Sized,

Creates a lending iterator starting at the same point, but stepping by the given amount at each iteration.

See Iterator::step_by.

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

where Self: Sized,

Creates a lending iterator that lends the first n elements, or fewer if the underlying iterator ends sooner.

See Iterator::take.

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

where Self: Sized, P: for<'a> FnMut(&Self::Item<'a>) -> bool,

Creates a lending iterator that lends items matching a predicate.

The predicate is called once for every item. Once it returns false once, None is returned for all subsequent calls to next.

fn chain<I>(self, other: I) -> Chain<Self, I>

where Self: Sized, for<'a> I: LendingIterator<Item<'a> = Self::Item<'a>> + 'a,

Takes two lending iterators and creates a new lending iterator over both in sequence.

See Iterator::chain.

fn zip<I>(self, other: I) -> Zip<Self, I>

where Self: Sized, I: LendingIterator,

‘Zips up’ two lending iterators into a single lending iterator of pairs.

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

where Self: Sized, F: for<'a> SingleArgFnMut<Self::Item<'a>>,

Takes a closure and creates a lending iterator which calls that closure on each element.

As of writing, in stable rust it’s not possible to create a closure where the lifetime of its output is tied to its input. If you’re on nightly, you can use the unstable closure_lifetime_binder feature. If you’re on stable, try using a function.

In the case that the closure’s return type doesn’t borrow from its input, the resulting LendingIterator will implement IntoIterator.

See Iterator::map.

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

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

Calls a closure on each element of the lending iterator.

See Iterator::for_each.

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

where Self: Sized, P: for<'a> FnMut(&Self::Item<'a>) -> bool,

Creates a lending iterator which uses a closure to determine if an element should be yielded.

See Iterator::filter.

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

where Self: Sized, F: for<'a> SingleArgFnMut<Self::Item<'a>>, for<'a> <F as SingleArgFnOnce<Self::Item<'a>>>::Output: OptionTrait,

Creates a lending iterator that both filters and maps.

See Iterator::filter_map.

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

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

Folds every element into an accumulator by applying an operation, returning the final result.

See Iterator::fold.

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

where Self: Sized, for<'a> Self::Item<'a>: Deref<Target = T>, T: Clone,

Creates a lending iterator which clones all of its elements.

The resulting lending iterator implements IntoIterator.

See Iterator::cloned.

fn enumerate(self) -> Enumerate<Self>

where Self: Sized,

Creates a lending iterator which gives the current iteration count as well as the next value.

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

where Self: Sized,

Creates a lending iterator that skips over the first n elements of self.

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

where Self: Sized, P: for<'a> FnMut(&Self::Item<'a>) -> bool,

Creates a lending iterator that rejects elements while predicate returns true.

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

where Self: Sized,

Borrows the lending iterator.

This is useful to allow applying iterator adapters while still retaining ownership of the original iterator.

Unfortunately adapters that take in a closure are currently incompatible with this, due to limitations in the borrow checker.

fn all<P>(&mut self, predicate: P) -> bool

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

Tests if every element of the iterator matches a predicate.

fn any<P>(&mut self, predicate: P) -> bool

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

Tests if any element of the iterator matches a predicate.

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

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

Checks if the elements of this iterator are partitioned according to the given predicate, such that all those that return true precede all those that return false.

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

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

Searches for an element of an iterator that satisfies a predicate.

fn find_map<B, F>(&mut self, f: F) -> Option<B>

where F: FnMut(Self::Item<'_>) -> Option<B>,

Applies function to the elements of iterator and returns the first non-none result.

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

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

Searches for an element in an iterator, returning its index.

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

where I: for<'a> LendingIterator<Item<'a> = Self::Item<'a>>, for<'a> Self::Item<'a>: Ord, Self: Sized,

Lexicographically compares the elements of this Iterator with those of another.

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

where Self: Sized, I: LendingIterator, F: FnMut(Self::Item<'_>, I::Item<'_>) -> Ordering,

Lexicographically compares the elements of this Iterator with those of another with respect to the specified comparison function.

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

where I: LendingIterator, for<'a> Self::Item<'a>: PartialOrd<I::Item<'a>>, Self: Sized,

Lexicographically compares the PartialOrd elements of this Iterator with those of another. The comparison works like short-circuit evaluation, returning a result without comparing the remaining elements. As soon as an order can be determined, the evaluation stops and a result is returned.

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

where Self: Sized, I: LendingIterator, F: FnMut(Self::Item<'_>, I::Item<'_>) -> Option<Ordering>,

Lexicographically compares the elements of this Iterator with those of another with respect to the specified comparison function.

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

where I: LendingIterator, for<'a> Self::Item<'a>: PartialEq<I::Item<'a>>, Self: Sized,

Determines if the elements of this Iterator are equal to those of another.

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

where Self: Sized, I: LendingIterator, F: FnMut(Self::Item<'_>, I::Item<'_>) -> bool,

Determines if the elements of this Iterator are equal to those of another with respect to the specified equality function.

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

where I: LendingIterator, for<'a> Self::Item<'a>: PartialEq<I::Item<'a>>, Self: Sized,

Determines if the elements of this Iterator are not equal to those of another.

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

where I: LendingIterator, for<'a> Self::Item<'a>: PartialOrd<I::Item<'a>>, Self: Sized,

Determines if the elements of this Iterator are lexicographically less than those of another.

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

where I: LendingIterator, for<'a> Self::Item<'a>: PartialOrd<I::Item<'a>>, Self: Sized,

Determines if the elements of this Iterator are lexicographically less or equal to those of another.

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

where I: LendingIterator, for<'a> Self::Item<'a>: PartialOrd<I::Item<'a>>, Self: Sized,

Determines if the elements of this Iterator are lexicographically greater than those of another.

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

where I: LendingIterator, for<'a> Self::Item<'a>: PartialOrd<I::Item<'a>>, Self: Sized,

Determines if the elements of this Iterator are lexicographically greater or equal to those of another.

Object Safety

This trait is not object safe.

Implementations on Foreign Types

impl<T: LendingIterator> LendingIterator for &mut T

type Item<'a> = <T as LendingIterator>::Item<'a> where Self: 'a

fn next(&mut self) -> Option<Self::Item<'_>>

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

Implementors

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

where A: LendingIterator, for<'a> B: LendingIterator<Item<'a> = A::Item<'a>> + 'a,

type Item<'a> = <A as LendingIterator>::Item<'a> where Self: 'a

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

where A: LendingIterator, B: LendingIterator,

type Item<'a> = (<A as LendingIterator>::Item<'a>, <B as LendingIterator>::Item<'a>) where A: 'a, B: 'a

impl<I> LendingIterator for Cloned<I>

where I: LendingIterator, for<'a> I::Item<'a>: Deref, for<'a> <I::Item<'a> as Deref>::Target: Clone,

type Item<'a> = <<I as LendingIterator>::Item<'a> as Deref>::Target where Self: 'a

impl<I> LendingIterator for LendRefs<I>

where I: Iterator,

type Item<'a> = &'a <I as Iterator>::Item where Self: 'a

impl<I> LendingIterator for Skip<I>

where I: LendingIterator,

type Item<'a> = <I as LendingIterator>::Item<'a> where I: 'a

impl<I> LendingIterator for StepBy<I>

where I: LendingIterator,

type Item<'a> = <I as LendingIterator>::Item<'a> where Self: 'a

impl<I> LendingIterator for Take<I>

where I: LendingIterator,

type Item<'a> = <I as LendingIterator>::Item<'a> where I: 'a

impl<I, F> LendingIterator for FilterMap<I, F>

where I: LendingIterator, F: for<'a> SingleArgFnMut<I::Item<'a>>, for<'a> <F as SingleArgFnOnce<I::Item<'a>>>::Output: OptionTrait,

type Item<'a> = <<F as SingleArgFnOnce<<I as LendingIterator>::Item<'a>>>::Output as OptionTrait>::Item where Self: 'a

impl<I, F> LendingIterator for Map<I, F>

where I: LendingIterator, F: for<'a> SingleArgFnMut<I::Item<'a>>,

type Item<'a> = <F as SingleArgFnOnce<<I as LendingIterator>::Item<'a>>>::Output where Self: 'a

impl<I, P> LendingIterator for Filter<I, P>

where I: LendingIterator, P: for<'a> FnMut(&I::Item<'a>) -> bool,

type Item<'a> = <I as LendingIterator>::Item<'a> where Self: 'a

impl<I, P> LendingIterator for SkipWhile<I, P>

where I: LendingIterator, P: for<'a> FnMut(&I::Item<'a>) -> bool,

type Item<'a> = <I as LendingIterator>::Item<'a> where Self: 'a

impl<I, P> LendingIterator for TakeWhile<I, P>

where I: LendingIterator, P: for<'a> FnMut(&I::Item<'a>) -> bool,

type Item<'a> = <I as LendingIterator>::Item<'a> where I: 'a, P: 'a

impl<I: Iterator> LendingIterator for IntoLending<I>

type Item<'a> = <I as Iterator>::Item where Self: 'a

impl<I: Iterator> LendingIterator for LendRefsMut<I>

type Item<'a> = &'a mut <I as Iterator>::Item where Self: 'a

impl<I: Iterator> LendingIterator for Windows<I>

type Item<'a> = &'a [<I as Iterator>::Item] where Self: 'a

impl<I: Iterator> LendingIterator for WindowsMut<I>

type Item<'a> = &'a mut [<I as Iterator>::Item] where Self: 'a

impl<I: LendingIterator> LendingIterator for Enumerate<I>

type Item<'a> = (usize, <I as LendingIterator>::Item<'a>) where Self: 'a