Struct FalliblePeekable 

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

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

This struct is created by the peekable() method on FallibleLender. See its documentation for more.

Implementations

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

where L: FallibleLender,

pub fn into_inner(self) -> L

Returns the inner lender.

pub fn peek(&mut self) -> Result<Option<&FallibleLend<'_, L>>, L::Error>

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.

Errors

Returns an error if the underlying lender produces an error.

Examples

let mut lender = [1, 2, 3].iter().into_lender()
    .into_fallible()
    .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, ) -> Result<Option<&mut FallibleLend<'this, L>>, L::Error>

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.

Errors

Returns an error if the underlying lender produces an error.

Examples

let mut lender = [1, 2, 3].iter().into_lender()
    .into_fallible()
    .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, ) -> Result<Option<FallibleLend<'_, L>>, L::Error>

where F: FnOnce(&FallibleLend<'_, 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 Ok(None) and the element remains peeked.

Errors

Returns an error if the underlying lender produces an error.

Examples

let mut lender = [1, 2, 3].iter().into_lender()
    .into_fallible()
    .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, ) -> Result<Option<FallibleLend<'a, L>>, L::Error>

where T: for<'all> PartialEq<FallibleLend<'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 Ok(None) and the element remains peeked.

Errors

Returns an error if the underlying lender produces an error.

Examples

let mut lender = [1, 2, 3].iter().into_lender()
    .into_fallible()
    .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: FallibleLender + Debug, FallibleLend<'this, L>: Debug,

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

Formats the value using the given formatter.

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

fn next_back(&mut self) -> Result<Option<FallibleLend<'_, Self>>, Self::Error>

Removes and returns a lend from the end of the lender, or an error.

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

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

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

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

where Self: Sized, F: FnMut(B, FallibleLend<'_, Self>) -> Result<B, Self::Error>,

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

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

Advances the lender from the back by n elements.

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

Returns the nth element from the end of the lender.

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

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

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

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

where L: ExactSizeFallibleLender,

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> FallibleLender for Peekable<'this, L>

where L: FallibleLender,

type Error = <L as FallibleLender>::Error

The error type.

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

Internal method for compile-time covariance checking.

fn next(&mut self) -> Result<Option<FallibleLend<'_, Self>>, Self::Error>

Yields the next lend, if any, of the lender, or Ok(None) when iteration is finished.

fn count(self) -> Result<usize, Self::Error>

Counts the number of lends in the lender by consuming it until the lender yields Ok(None) or Err(_).

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

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

fn last<'a>(&'a mut self) -> Result<Option<FallibleLend<'a, Self>>, Self::Error>

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. Both bounds assume that all remaining calls to next() succeed. That is, next() could return an Err in fewer calls than specified by the lower bound.

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

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

The FallibleLender version of Iterator::try_fold.

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

where Self: Sized, F: FnMut(B, FallibleLend<'_, Self>) -> Result<B, Self::Error>,

The FallibleLender 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<Result<(), NonZeroUsize>, Self::Error>

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 IntoFallibleLender>::FallibleLender>

where Self: Sized, U: IntoFallibleLender<Error = Self::Error> + for<'all> FallibleLending<'all, Lend = FallibleLend<'all, Self>>,

Chains the lender with another lender of the same type.

fn zip<U: IntoFallibleLender>( self, other: U, ) -> Zip<Self, <U as IntoFallibleLender>::FallibleLender>

where Self: Sized,

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

fn intersperse<'call>( self, separator: FallibleLend<'call, Self>, ) -> FallibleIntersperse<'call, Self>

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

Intersperses each lend of this lender with the given separator.

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

where Self: Sized, G: FnMut() -> Result<FallibleLend<'call, Self>, Self::Error>,

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> FnMutHKARes<'all, FallibleLend<'all, Self>, Self::Error>,

Maps each lend of this lender using the given function.

fn map_err<E, F>(self, f: F) -> MapErr<E, Self, F>

where Self: Sized, F: FnMut(Self::Error) -> E,

Maps the error of this lender using the given function.

fn map_into_iter<O, F>(self, f: F) -> MapIntoIter<Self, O, F>

where Self: Sized, F: FnMut(FallibleLend<'_, Self>) -> Result<O, Self::Error>,

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

fn for_each<F>(self, f: F) -> Result<(), Self::Error>

where Self: Sized, F: FnMut(FallibleLend<'_, Self>) -> Result<(), Self::Error>,

Calls the given function with each lend of this lender.

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

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

Filters this lender using the given predicate.

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

where Self: Sized, F: for<'all> FnMutHKAResOpt<'all, FallibleLend<'all, Self>, Self::Error>,

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) -> FalliblePeekable<'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(&FallibleLend<'_, Self>) -> Result<bool, Self::Error>,

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(&FallibleLend<'_, Self>) -> Result<bool, Self::Error>,

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> FnMutHKAResOpt<'all, FallibleLend<'all, Self>, Self::Error>,

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> FnMutHKAResOpt<'all, (&'all mut St, FallibleLend<'all, Self>), Self::Error>,

The FallibleLender version of Iterator::scan.

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

where Self: Sized, F: for<'all> FnMutHKARes<'all, FallibleLend<'all, Self>, Self::Error>, for<'all> <F as FnMutHKARes<'all, FallibleLend<'all, Self>, Self::Error>>::B: IntoFallibleLender<Error = Self::Error>,

The FallibleLender version of Iterator::flat_map.

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

where Self: Sized, for<'all> FallibleLend<'all, Self>: IntoFallibleLender<Error = Self::Error>,

The FallibleLender version of Iterator::flatten.

fn fuse(self) -> Fuse<Self>

where Self: Sized,

The FallibleLender version of Iterator::fuse.

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

where Self: Sized, F: FnMut(&FallibleLend<'_, Self>) -> Result<(), Self::Error>,

The FallibleLender version of Iterator::inspect.

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

where Self: Sized, F: FnMut(&mut FallibleLend<'_, Self>) -> Result<(), Self::Error>,

Mutates each lend with the given function.

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

where Self: Sized,

The FallibleLender version of Iterator::by_ref.

fn collect<B>(self) -> Result<B, (B, Self::Error)>

where Self: Sized, for<'all> B: FromLender<NonFallibleAdapter<'all, Self>>,

Transforms the fallible lender into a collection. If any invocation of next returns Err, returns the collection built from values yielded successfully, together with the error.

fn try_collect<'a, B, T>(&'a mut self) -> Result<T, (T, Self::Error)>

where Self: Sized, for<'all> FallibleLend<'all, Self>: Try, for<'all> <FallibleLend<'all, Self> as Try>::Residual: Residual<B, TryType = T>, for<'b, 'c, 'd> B: FromLender<FallibleTryShuntAdapter<'b, 'c, 'd, 'a, Self>>,

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

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

where Self: Sized, for<'all> E: ExtendLender<NonFallibleAdapter<'all, Self>>,

Extends an existing collection with lends from this fallible lender.

fn partition<'this, E, F>(self, f: F) -> Result<(E, E), ((E, E), Self::Error)>

where Self: Sized + 'this, E: Default + ExtendLender<NonFallibleAdapter<'this, Self>>, F: FnMut(&FallibleLend<'_, Self>) -> Result<bool, Self::Error>,

The FallibleLender version of Iterator::partition.

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

where Self: Sized, P: FnMut(FallibleLend<'_, Self>) -> Result<bool, Self::Error>,

The FallibleLender version of Iterator::is_partitioned.

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

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

The FallibleLender version of Iterator::try_for_each.

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

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

The FallibleLender version of Iterator::reduce.

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

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

The FallibleLender version of Iterator::try_reduce.

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

where F: FnMut(FallibleLend<'_, Self>) -> Result<bool, Self::Error>,

The FallibleLender version of Iterator::all.

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

where F: FnMut(FallibleLend<'_, Self>) -> Result<bool, Self::Error>,

The FallibleLender version of Iterator::any.

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

where P: FnMut(&FallibleLend<'_, Self>) -> Result<bool, Self::Error>,

The FallibleLender version of Iterator::find.

fn find_map<'a, F>( &'a mut self, f: F, ) -> Result<Option<<F as FnMutHKAResOpt<'a, FallibleLend<'a, Self>, Self::Error>>::B>, Self::Error>

where Self: Sized, F: for<'all> FnMutHKAResOpt<'all, FallibleLend<'all, Self>, Self::Error>,

The FallibleLender version of Iterator::find_map.

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

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

The FallibleLender version of Iterator::try_find.

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

where Self: Sized, P: FnMut(FallibleLend<'_, Self>) -> Result<bool, Self::Error>,

The FallibleLender version of Iterator::position.

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

where P: FnMut(FallibleLend<'_, Self>) -> Result<bool, Self::Error>, Self: Sized + ExactSizeFallibleLender + DoubleEndedFallibleLender,

The FallibleLender version of Iterator::rposition.

fn max<T: Ord>(self) -> Result<Option<T>, Self::Error>

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

The FallibleLender version of Iterator::max.

fn min<T: Ord>(self) -> Result<Option<T>, Self::Error>

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

The FallibleLender version of Iterator::min.

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

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

The FallibleLender version of Iterator::max_by_key.

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

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

The FallibleLender version of Iterator::max_by.

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

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

The FallibleLender version of Iterator::min_by_key.

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

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

The FallibleLender version of Iterator::min_by.

fn rev(self) -> Rev<Self>

where Self: Sized + DoubleEndedFallibleLender,

The FallibleLender version of Iterator::rev.

fn unzip<ExtA, ExtB>(self) -> Result<(ExtA, ExtB), Self::Error>

where Self: Sized, for<'all> FallibleLend<'all, Self>: TupleLend<'all>, ExtA: Default + for<'this> ExtendLender<NonFallibleAdapter<'this, <FirstShunt<Self> as IntoFallibleLender>::FallibleLender>>, ExtB: Default + for<'this> ExtendLender<NonFallibleAdapter<'this, <SecondShunt<Self> as IntoFallibleLender>::FallibleLender>>,

The FallibleLender version of Iterator::unzip.

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

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

The FallibleLender version of Iterator::copied.

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

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

The FallibleLender version of Iterator::cloned.

fn owned(self) -> Owned<Self>

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

Turns this FallibleLender into a FallibleIterator.

fn sum<S>(self) -> Result<S, Self::Error>

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

The FallibleLender version of Iterator::sum.

fn product<P>(self) -> Result<P, Self::Error>

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

The FallibleLender version of Iterator::product.

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

where L: IntoFallibleLender<Error = Self::Error>, L::FallibleLender: for<'all> FallibleLending<'all, Lend = FallibleLend<'all, Self>>, for<'all> FallibleLend<'all, Self>: Ord, Self: Sized,

The FallibleLender version of Iterator::cmp.

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

where Self: Sized, L: IntoFallibleLender<Error = Self::Error>, F: for<'all> FnMut(FallibleLend<'all, Self>, FallibleLend<'all, L::FallibleLender>) -> Result<Ordering, Self::Error>,

The FallibleLender version of Iterator::cmp_by.

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

where L: IntoFallibleLender<Error = Self::Error>, for<'all> FallibleLend<'all, Self>: PartialOrd<FallibleLend<'all, L::FallibleLender>>, Self: Sized,

The FallibleLender version of Iterator::partial_cmp.

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

where Self: Sized, L: IntoFallibleLender<Error = Self::Error>, F: for<'all> FnMut(FallibleLend<'all, Self>, FallibleLend<'all, L::FallibleLender>) -> Result<Option<Ordering>, Self::Error>,

The FallibleLender version of Iterator::partial_cmp_by.

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

where L: IntoFallibleLender<Error = Self::Error>, for<'all> FallibleLend<'all, Self>: PartialEq<FallibleLend<'all, L::FallibleLender>>, Self: Sized,

The FallibleLender version of Iterator::eq.

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

where Self: Sized, L: IntoFallibleLender<Error = Self::Error>, F: for<'all> FnMut(FallibleLend<'all, Self>, FallibleLend<'all, L::FallibleLender>) -> Result<bool, Self::Error>,

The FallibleLender version of Iterator::eq_by.

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

where L: IntoFallibleLender<Error = Self::Error>, for<'all> FallibleLend<'all, Self>: PartialEq<FallibleLend<'all, L::FallibleLender>>, Self: Sized,

The FallibleLender version of Iterator::ne.

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

where L: IntoFallibleLender<Error = Self::Error>, for<'all> FallibleLend<'all, Self>: PartialOrd<FallibleLend<'all, L::FallibleLender>>, Self: Sized,

The FallibleLender version of Iterator::lt.

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

where L: IntoFallibleLender<Error = Self::Error>, for<'all> FallibleLend<'all, Self>: PartialOrd<FallibleLend<'all, L::FallibleLender>>, Self: Sized,

The FallibleLender version of Iterator::le.

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

where L: IntoFallibleLender<Error = Self::Error>, for<'all> FallibleLend<'all, Self>: PartialOrd<FallibleLend<'all, L::FallibleLender>>, Self: Sized,

The FallibleLender version of Iterator::gt.

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

where L: IntoFallibleLender<Error = Self::Error>, for<'all> FallibleLend<'all, Self>: PartialOrd<FallibleLend<'all, L::FallibleLender>>, Self: Sized,

The FallibleLender version of Iterator::ge.

fn is_sorted<T>(self) -> Result<bool, Self::Error>

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

The FallibleLender version of Iterator::is_sorted.

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

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

The FallibleLender version of Iterator::is_sorted_by.

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

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

The FallibleLender version of Iterator::is_sorted_by_key.

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

where Self: Sized + ExactSizeFallibleLender,

A lending replacement for Iterator::array_chunks.

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

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

Turns this FallibleLender into a FallibleIterator where it has already fulfilled the requirements of the FallibleIterator trait.

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

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

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

impl<'lend, L> FallibleLending<'lend> for Peekable<'_, L>

where L: FallibleLender,

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

The type being lent.

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

where L: FusedFallibleLender,