Struct gat_lending_iterator::Chain

pub struct Chain<A, B> { /* private fields */ }

A lending iterator that iterates over the elements of two iterators in sequence.

This struct is created by the chain method on LendingIterator. See its documentation for more.

Trait Implementations

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

The type of the elements being iterated over.

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

Advances the lending iterator and returns the next value.

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

Returns the bounds on the remaining length of the iterator.

fn count(self) -> usize

where Self: Sized,

Returns the number of items in the lending iterator.

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

Advances the lending iterator by n elements.

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

Returns the nth element of the lending iterator.

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.

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.

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.

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.

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

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

Calls a closure on each element of the lending iterator.

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.

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.

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.