Struct Peekable 

pub struct Peekable<'this, L>
where
    L: Lender,
{ /* private fields */ }

A lender with a peek() method that returns an optional reference to the next element.

This struct is created by the peekable() method on Lender.

Implementations

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

where L: Lender,

pub fn into_inner(self) -> L

Returns the inner lender.

pub fn peek(&mut self) -> Option<&Lend<'_, L>>

Returns a reference to the next element without advancing the lender.

Like next, if there is a next value, it is borrowed from the underlying lender and cached. Calling peek() multiple times without advancing the lender returns the same cached element.

Examples

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

assert_eq!(lender.peek(), Some(&&1));
assert_eq!(lender.peek(), Some(&&1)); // Doesn't advance
assert_eq!(lender.next(), Some(&1));
assert_eq!(lender.peek(), Some(&&2));

pub fn peek_mut(&mut self) -> Option<&mut Lend<'this, L>>

Returns a mutable reference to the next element without advancing the lender.

Like peek, if there is a next value, it is borrowed from the underlying lender and cached. The returned mutable reference allows modifying the peeked value.

Examples

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

if let Some(p) = lender.peek_mut() {
    // p is &mut &i32, so we replace the reference
    *p = &10;
}
assert_eq!(lender.next(), Some(&10));
assert_eq!(lender.next(), Some(&2));

pub fn next_if<F>(&mut self, f: F) -> Option<Lend<'_, L>>

where F: FnOnce(&Lend<'_, L>) -> bool,

Consumes and returns the next element if the given predicate is true.

If f(&next_element) returns true, consumes and returns the next element. Otherwise, returns None and the element remains peeked.

Examples

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

// Consume 1 since it's odd
assert_eq!(lender.next_if(|&x| *x % 2 == 1), Some(&1));
// Don't consume 2 since it's not odd
assert_eq!(lender.next_if(|&x| *x % 2 == 1), None);
// 2 is still there
assert_eq!(lender.next(), Some(&2));

pub fn next_if_eq<'a, T>(&'a mut self, t: &T) -> Option<Lend<'a, L>>

where T: for<'all> PartialEq<Lend<'all, L>>,

Consumes and returns the next element if it equals the given value.

If the next element equals t, consumes and returns it. Otherwise, returns None and the element remains peeked.

Examples

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

// Consume 1 since it equals 1
assert_eq!(lender.next_if_eq(&&1), Some(&1));
// Don't consume 2 since it doesn't equal 1
assert_eq!(lender.next_if_eq(&&1), None);
// 2 is still there
assert_eq!(lender.next(), Some(&2));

Trait Implementations

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

where L: Lender + Debug, Lend<'this, L>: Debug,

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

Formats the value using the given formatter.

impl<'this, L: DoubleEndedLender> DoubleEndedLender for Peekable<'this, L>

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

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

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

where Self: Sized, 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 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 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<L: ExactSizeLender> ExactSizeLender for Peekable<'_, L>

fn len(&self) -> usize

Returns the exact remaining length of the lender.

fn is_empty(&self) -> bool

Returns true if the lender has no more elements.

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

where L: Lender,

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 count(self) -> usize

Counts the number of lends in the lender 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 last<'a>(&'a mut self) -> Option<Lend<'a, Self>>

where Self: Sized,

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

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 try_fold<B, F, R>(&mut self, init: B, f: F) -> R

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

The Lender version of Iterator::try_fold.

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 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 advance_by(&mut self, n: usize) -> Result<(), NonZeroUsize>

Advances the lender by n lends.

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_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 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 rposition<P>(&mut self, predicate: P) -> Option<usize>

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

The Lender version of Iterator::rposition.

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 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 chunky(self, chunk_size: usize) -> Chunky<Self>

where Self: Sized + ExactSizeLender,

A lending replacement for Iterator::array_chunks.

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, L> Lending<'lend> for Peekable<'_, L>

where L: Lender,

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

The type being lent.

impl<L: FusedLender> FusedLender for Peekable<'_, L>