Trait fallible_iterator::FallibleIterator

source · 
pub trait FallibleIterator {
    type Item;
    type Error;


Show 54 methods    // Required method
    fn next(&mut self) -> Result<Option<Self::Item>, Self::Error>;

    // Provided methods
    fn size_hint(&self) -> (usize, Option<usize>) { ... }
    fn count(self) -> Result<usize, Self::Error>
       where Self: Sized { ... }
    fn last(self) -> Result<Option<Self::Item>, Self::Error>
       where Self: Sized { ... }
    fn nth(&mut self, n: usize) -> Result<Option<Self::Item>, Self::Error> { ... }
    fn step_by(self, step: usize) -> StepBy<Self>
       where Self: Sized { ... }
    fn chain<I>(self, it: I) -> Chain<Self, I>
       where I: IntoFallibleIterator<Item = Self::Item, Error = Self::Error>,
             Self: Sized { ... }
    fn zip<I>(self, o: I) -> Zip<Self, I::IntoFallibleIter>
       where Self: Sized,
             I: IntoFallibleIterator<Error = Self::Error> { ... }
    fn map<F, B>(self, f: F) -> Map<Self, F>
       where Self: Sized,
             F: FnMut(Self::Item) -> Result<B, Self::Error> { ... }
    fn for_each<F>(self, f: F) -> Result<(), Self::Error>
       where Self: Sized,
             F: FnMut(Self::Item) -> Result<(), Self::Error> { ... }
    fn filter<F>(self, f: F) -> Filter<Self, F>
       where Self: Sized,
             F: FnMut(&Self::Item) -> Result<bool, Self::Error> { ... }
    fn filter_map<B, F>(self, f: F) -> FilterMap<Self, F>
       where Self: Sized,
             F: FnMut(Self::Item) -> Result<Option<B>, Self::Error> { ... }
    fn enumerate(self) -> Enumerate<Self>
       where Self: Sized { ... }
    fn peekable(self) -> Peekable<Self>
       where Self: Sized { ... }
    fn skip_while<P>(self, predicate: P) -> SkipWhile<Self, P>
       where Self: Sized,
             P: FnMut(&Self::Item) -> Result<bool, Self::Error> { ... }
    fn take_while<P>(self, predicate: P) -> TakeWhile<Self, P>
       where Self: Sized,
             P: FnMut(&Self::Item) -> Result<bool, Self::Error> { ... }
    fn skip(self, n: usize) -> Skip<Self>
       where Self: Sized { ... }
    fn take(self, n: usize) -> Take<Self>
       where Self: Sized { ... }
    fn scan<St, B, F>(self, initial_state: St, f: F) -> Scan<Self, St, F>
       where Self: Sized,
             F: FnMut(&mut St, Self::Item) -> Result<Option<B>, Self::Error> { ... }
    fn flat_map<U, F>(self, f: F) -> FlatMap<Self, U, F>
       where Self: Sized,
             U: IntoFallibleIterator<Error = Self::Error>,
             F: FnMut(Self::Item) -> Result<U, Self::Error> { ... }
    fn flatten(self) -> Flatten<Self>
       where Self: Sized,
             Self::Item: IntoFallibleIterator<Error = Self::Error> { ... }
    fn fuse(self) -> Fuse<Self>
       where Self: Sized { ... }
    fn inspect<F>(self, f: F) -> Inspect<Self, F>
       where Self: Sized,
             F: FnMut(&Self::Item) -> Result<(), Self::Error> { ... }
    fn by_ref(&mut self) -> &mut Self
       where Self: Sized { ... }
    fn collect<T>(self) -> Result<T, Self::Error>
       where T: FromIterator<Self::Item>,
             Self: Sized { ... }
    fn partition<B, F>(self, f: F) -> Result<(B, B), Self::Error>
       where Self: Sized,
             B: Default + Extend<Self::Item>,
             F: FnMut(&Self::Item) -> Result<bool, Self::Error> { ... }
    fn fold<B, F>(self, init: B, f: F) -> Result<B, Self::Error>
       where Self: Sized,
             F: FnMut(B, Self::Item) -> Result<B, Self::Error> { ... }
    fn try_fold<B, E, F>(&mut self, init: B, f: F) -> Result<B, E>
       where Self: Sized,
             E: From<Self::Error>,
             F: FnMut(B, Self::Item) -> Result<B, E> { ... }
    fn all<F>(&mut self, f: F) -> Result<bool, Self::Error>
       where Self: Sized,
             F: FnMut(Self::Item) -> Result<bool, Self::Error> { ... }
    fn any<F>(&mut self, f: F) -> Result<bool, Self::Error>
       where Self: Sized,
             F: FnMut(Self::Item) -> Result<bool, Self::Error> { ... }
    fn find<F>(&mut self, f: F) -> Result<Option<Self::Item>, Self::Error>
       where Self: Sized,
             F: FnMut(&Self::Item) -> Result<bool, Self::Error> { ... }
    fn find_map<B, F>(&mut self, f: F) -> Result<Option<B>, Self::Error>
       where Self: Sized,
             F: FnMut(Self::Item) -> Result<Option<B>, Self::Error> { ... }
    fn position<F>(&mut self, f: F) -> Result<Option<usize>, Self::Error>
       where Self: Sized,
             F: FnMut(Self::Item) -> Result<bool, Self::Error> { ... }
    fn max(self) -> Result<Option<Self::Item>, Self::Error>
       where Self: Sized,
             Self::Item: Ord { ... }
    fn max_by_key<B, F>(self, f: F) -> Result<Option<Self::Item>, Self::Error>
       where Self: Sized,
             B: Ord,
             F: FnMut(&Self::Item) -> Result<B, Self::Error> { ... }
    fn max_by<F>(self, f: F) -> Result<Option<Self::Item>, Self::Error>
       where Self: Sized,
             F: FnMut(&Self::Item, &Self::Item) -> Result<Ordering, Self::Error> { ... }
    fn min(self) -> Result<Option<Self::Item>, Self::Error>
       where Self: Sized,
             Self::Item: Ord { ... }
    fn min_by_key<B, F>(self, f: F) -> Result<Option<Self::Item>, Self::Error>
       where Self: Sized,
             B: Ord,
             F: FnMut(&Self::Item) -> Result<B, Self::Error> { ... }
    fn min_by<F>(self, f: F) -> Result<Option<Self::Item>, Self::Error>
       where Self: Sized,
             F: FnMut(&Self::Item, &Self::Item) -> Result<Ordering, Self::Error> { ... }
    fn rev(self) -> Rev<Self>
       where Self: Sized + DoubleEndedFallibleIterator { ... }
    fn unzip<A, B, FromA, FromB>(self) -> Result<(FromA, FromB), Self::Error>
       where Self: Sized + FallibleIterator<Item = (A, B)>,
             FromA: Default + Extend<A>,
             FromB: Default + Extend<B> { ... }
    fn cloned<'a, T>(self) -> Cloned<Self>
       where Self: Sized + FallibleIterator<Item = &'a T>,
             T: 'a + Clone { ... }
    fn cycle(self) -> Cycle<Self>
       where Self: Sized + Clone { ... }
    fn cmp<I>(self, other: I) -> Result<Ordering, Self::Error>
       where Self: Sized,
             I: IntoFallibleIterator<Item = Self::Item, Error = Self::Error>,
             Self::Item: Ord { ... }
    fn partial_cmp<I>(self, other: I) -> Result<Option<Ordering>, Self::Error>
       where Self: Sized,
             I: IntoFallibleIterator<Error = Self::Error>,
             Self::Item: PartialOrd<I::Item> { ... }
    fn eq<I>(self, other: I) -> Result<bool, Self::Error>
       where Self: Sized,
             I: IntoFallibleIterator<Error = Self::Error>,
             Self::Item: PartialEq<I::Item> { ... }
    fn ne<I>(self, other: I) -> Result<bool, Self::Error>
       where Self: Sized,
             I: IntoFallibleIterator<Error = Self::Error>,
             Self::Item: PartialEq<I::Item> { ... }
    fn lt<I>(self, other: I) -> Result<bool, Self::Error>
       where Self: Sized,
             I: IntoFallibleIterator<Error = Self::Error>,
             Self::Item: PartialOrd<I::Item> { ... }
    fn le<I>(self, other: I) -> Result<bool, Self::Error>
       where Self: Sized,
             I: IntoFallibleIterator<Error = Self::Error>,
             Self::Item: PartialOrd<I::Item> { ... }
    fn gt<I>(self, other: I) -> Result<bool, Self::Error>
       where Self: Sized,
             I: IntoFallibleIterator<Error = Self::Error>,
             Self::Item: PartialOrd<I::Item> { ... }
    fn ge<I>(self, other: I) -> Result<bool, Self::Error>
       where Self: Sized,
             I: IntoFallibleIterator<Error = Self::Error>,
             Self::Item: PartialOrd<I::Item> { ... }
    fn iterator(self) -> Iterator<Self> ⓘ
       where Self: Sized { ... }
    fn map_err<B, F>(self, f: F) -> MapErr<Self, F>
       where F: FnMut(Self::Error) -> B,
             Self: Sized { ... }
    fn unwrap<T>(self) -> Unwrap<Self> ⓘ
       where Self: Sized + FallibleIterator<Item = T>,
             Self::Error: Debug { ... }

}
Expand description

An Iterator-like trait that allows for calculation of items to fail.

Required Associated Types§

source

type Item

The type being iterated over.

source

type Error

The error type.

Required Methods§

source

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

Advances the iterator and returns the next value.

Returns Ok(None) when iteration is finished.

The behavior of calling this method after a previous call has returned Ok(None) or Err is implementation defined.

Provided Methods§

source

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

Returns bounds on the remaining length of the iterator.

Specifically, the first half of the returned tuple is a lower bound and the second half is an upper bound.

For the upper bound, None indicates that the upper bound is either unknown or larger than can be represented as a usize.

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.

The default implementation returns (0, None), which is correct for any iterator.

source

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

Consumes the iterator, returning the number of remaining items.

source

fn last(self) -> Result<Option<Self::Item>, Self::Error>where Self: Sized,

Returns the last element of the iterator.

source

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

Returns the nth element of the iterator.

source

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

Returns an iterator starting at the same point, but stepping by the given amount at each iteration.

Panics

Panics if step is 0.

source

fn chain<I>(self, it: I) -> Chain<Self, I>where I: IntoFallibleIterator<Item = Self::Item, Error = Self::Error>, Self: Sized,

Returns an iterator which yields the elements of this iterator followed by another.

source

fn zip<I>(self, o: I) -> Zip<Self, I::IntoFallibleIter>where Self: Sized, I: IntoFallibleIterator<Error = Self::Error>,

Returns an iterator that yields pairs of this iterator’s and another iterator’s values.

source

fn map<F, B>(self, f: F) -> Map<Self, F>where Self: Sized, F: FnMut(Self::Item) -> Result<B, Self::Error>,

Returns an iterator which applies a fallible transform to the elements of the underlying iterator.

source

fn for_each<F>(self, f: F) -> Result<(), Self::Error>where Self: Sized, F: FnMut(Self::Item) -> Result<(), Self::Error>,

Calls a fallible closure on each element of an iterator.

source

fn filter<F>(self, f: F) -> Filter<Self, F>where Self: Sized, F: FnMut(&Self::Item) -> Result<bool, Self::Error>,

Returns an iterator which uses a predicate to determine which values should be yielded. The predicate may fail; such failures are passed to the caller.

source

fn filter_map<B, F>(self, f: F) -> FilterMap<Self, F>where Self: Sized, F: FnMut(Self::Item) -> Result<Option<B>, Self::Error>,

Returns an iterator which both filters and maps. The closure may fail; such failures are passed along to the consumer.

source

fn enumerate(self) -> Enumerate<Self>where Self: Sized,

Returns an iterator which yields the current iteration count as well as the value.

source

fn peekable(self) -> Peekable<Self>where Self: Sized,

Returns an iterator that can peek at the next element without consuming it.

source

fn skip_while<P>(self, predicate: P) -> SkipWhile<Self, P>where Self: Sized, P: FnMut(&Self::Item) -> Result<bool, Self::Error>,

Returns an iterator that skips elements based on a predicate.

source

fn take_while<P>(self, predicate: P) -> TakeWhile<Self, P>where Self: Sized, P: FnMut(&Self::Item) -> Result<bool, Self::Error>,

Returns an iterator that yields elements based on a predicate.

source

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

Returns an iterator which skips the first n values of this iterator.

source

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

Returns an iterator that yields only the first n values of this iterator.

source

fn scan<St, B, F>(self, initial_state: St, f: F) -> Scan<Self, St, F>where Self: Sized, F: FnMut(&mut St, Self::Item) -> Result<Option<B>, Self::Error>,

Returns an iterator which applies a stateful map to values of this iterator.

source

fn flat_map<U, F>(self, f: F) -> FlatMap<Self, U, F>where Self: Sized, U: IntoFallibleIterator<Error = Self::Error>, F: FnMut(Self::Item) -> Result<U, Self::Error>,

Returns an iterator which maps this iterator’s elements to iterators, yielding those iterators’ values.

source

fn flatten(self) -> Flatten<Self>where Self: Sized, Self::Item: IntoFallibleIterator<Error = Self::Error>,

Returns an iterator which flattens an iterator of iterators, yielding those iterators’ values.

source

fn fuse(self) -> Fuse<Self>where Self: Sized,

Returns an iterator which yields this iterator’s elements and ends after the first Ok(None).

The behavior of calling next after it has previously returned Ok(None) is normally unspecified. The iterator returned by this method guarantees that Ok(None) will always be returned.

source

fn inspect<F>(self, f: F) -> Inspect<Self, F>where Self: Sized, F: FnMut(&Self::Item) -> Result<(), Self::Error>,

Returns an iterator which passes each element to a closure before returning it.

source

fn by_ref(&mut self) -> &mut Selfwhere Self: Sized,

Borrow an iterator rather than consuming it.

This is useful to allow the use of iterator adaptors that would otherwise consume the value.

source

fn collect<T>(self) -> Result<T, Self::Error>where T: FromIterator<Self::Item>, Self: Sized,

Transforms the iterator into a collection.

An Err will be returned if any invocation of next returns Err.

source

fn partition<B, F>(self, f: F) -> Result<(B, B), Self::Error>where Self: Sized, B: Default + Extend<Self::Item>, F: FnMut(&Self::Item) -> Result<bool, Self::Error>,

Transforms the iterator into two collections, partitioning elements by a closure.

source

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

Applies a function over the elements of the iterator, producing a single final value.

source

fn try_fold<B, E, F>(&mut self, init: B, f: F) -> Result<B, E>where Self: Sized, E: From<Self::Error>, F: FnMut(B, Self::Item) -> Result<B, E>,

Applies a function over the elements of the iterator, producing a single final value.

This is used as the “base” of many methods on FallibleIterator.

source

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

Determines if all elements of this iterator match a predicate.

source

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

Determines if any element of this iterator matches a predicate.

source

fn find<F>(&mut self, f: F) -> Result<Option<Self::Item>, Self::Error>where Self: Sized, F: FnMut(&Self::Item) -> Result<bool, Self::Error>,

Returns the first element of the iterator that matches a predicate.

source

fn find_map<B, F>(&mut self, f: F) -> Result<Option<B>, Self::Error>where Self: Sized, F: FnMut(Self::Item) -> Result<Option<B>, Self::Error>,

Applies a function to the elements of the iterator, returning the first non-None result.

source

fn position<F>(&mut self, f: F) -> Result<Option<usize>, Self::Error>where Self: Sized, F: FnMut(Self::Item) -> Result<bool, Self::Error>,

Returns the position of the first element of this iterator that matches a predicate. The predicate may fail; such failures are returned to the caller.

source

fn max(self) -> Result<Option<Self::Item>, Self::Error>where Self: Sized, Self::Item: Ord,

Returns the maximal element of the iterator.

source

fn max_by_key<B, F>(self, f: F) -> Result<Option<Self::Item>, Self::Error>where Self: Sized, B: Ord, F: FnMut(&Self::Item) -> Result<B, Self::Error>,

Returns the element of the iterator which gives the maximum value from the function.

source

fn max_by<F>(self, f: F) -> Result<Option<Self::Item>, Self::Error>where Self: Sized, F: FnMut(&Self::Item, &Self::Item) -> Result<Ordering, Self::Error>,

Returns the element that gives the maximum value with respect to the function.

source

fn min(self) -> Result<Option<Self::Item>, Self::Error>where Self: Sized, Self::Item: Ord,

Returns the minimal element of the iterator.

source

fn min_by_key<B, F>(self, f: F) -> Result<Option<Self::Item>, Self::Error>where Self: Sized, B: Ord, F: FnMut(&Self::Item) -> Result<B, Self::Error>,

Returns the element of the iterator which gives the minimum value from the function.

source

fn min_by<F>(self, f: F) -> Result<Option<Self::Item>, Self::Error>where Self: Sized, F: FnMut(&Self::Item, &Self::Item) -> Result<Ordering, Self::Error>,

Returns the element that gives the minimum value with respect to the function.

source

fn rev(self) -> Rev<Self>where Self: Sized + DoubleEndedFallibleIterator,

Returns an iterator that yields this iterator’s items in the opposite order.

source

fn unzip<A, B, FromA, FromB>(self) -> Result<(FromA, FromB), Self::Error>where Self: Sized + FallibleIterator<Item = (A, B)>, FromA: Default + Extend<A>, FromB: Default + Extend<B>,

Converts an iterator of pairs into a pair of containers.

source

fn cloned<'a, T>(self) -> Cloned<Self>where Self: Sized + FallibleIterator<Item = &'a T>, T: 'a + Clone,

Returns an iterator which clones all of its elements.

source

fn cycle(self) -> Cycle<Self>where Self: Sized + Clone,

Returns an iterator which repeats this iterator endlessly.

source

fn cmp<I>(self, other: I) -> Result<Ordering, Self::Error>where Self: Sized, I: IntoFallibleIterator<Item = Self::Item, Error = Self::Error>, Self::Item: Ord,

Lexicographically compares the elements of this iterator to that of another.

source

fn partial_cmp<I>(self, other: I) -> Result<Option<Ordering>, Self::Error>where Self: Sized, I: IntoFallibleIterator<Error = Self::Error>, Self::Item: PartialOrd<I::Item>,

Lexicographically compares the elements of this iterator to that of another.

source

fn eq<I>(self, other: I) -> Result<bool, Self::Error>where Self: Sized, I: IntoFallibleIterator<Error = Self::Error>, Self::Item: PartialEq<I::Item>,

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

source

fn ne<I>(self, other: I) -> Result<bool, Self::Error>where Self: Sized, I: IntoFallibleIterator<Error = Self::Error>, Self::Item: PartialEq<I::Item>,

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

source

fn lt<I>(self, other: I) -> Result<bool, Self::Error>where Self: Sized, I: IntoFallibleIterator<Error = Self::Error>, Self::Item: PartialOrd<I::Item>,

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

source

fn le<I>(self, other: I) -> Result<bool, Self::Error>where Self: Sized, I: IntoFallibleIterator<Error = Self::Error>, Self::Item: PartialOrd<I::Item>,

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

source

fn gt<I>(self, other: I) -> Result<bool, Self::Error>where Self: Sized, I: IntoFallibleIterator<Error = Self::Error>, Self::Item: PartialOrd<I::Item>,

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

source

fn ge<I>(self, other: I) -> Result<bool, Self::Error>where Self: Sized, I: IntoFallibleIterator<Error = Self::Error>, Self::Item: PartialOrd<I::Item>,

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

source

fn iterator(self) -> Iterator<Self> ⓘwhere Self: Sized,

Returns a normal (non-fallible) iterator over Result<Item, Error>.

source

fn map_err<B, F>(self, f: F) -> MapErr<Self, F>where F: FnMut(Self::Error) -> B, Self: Sized,

Returns an iterator which applies a transform to the errors of the underlying iterator.

source

fn unwrap<T>(self) -> Unwrap<Self> ⓘwhere Self: Sized + FallibleIterator<Item = T>, Self::Error: Debug,

Returns an iterator which unwraps all of its elements.

Implementations on Foreign Types§

source§

impl<I: FallibleIterator + ?Sized> FallibleIterator for &mut I

§

type Item = <I as FallibleIterator>::Item

§

type Error = <I as FallibleIterator>::Error

source§

fn next(&mut self) -> Result<Option<I::Item>, I::Error>

source§

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

source§

fn nth(&mut self, n: usize) -> Result<Option<I::Item>, I::Error>

source§

impl<I: FallibleIterator + ?Sized> FallibleIterator for Box<I>

§

type Item = <I as FallibleIterator>::Item

§

type Error = <I as FallibleIterator>::Error

source§

fn next(&mut self) -> Result<Option<I::Item>, I::Error>

source§

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

source§

fn nth(&mut self, n: usize) -> Result<Option<I::Item>, I::Error>

Implementors§

source§

impl<'a, T, I> FallibleIterator for Cloned<I>where I: FallibleIterator<Item = &'a T>, T: 'a + Clone,

§

type Item = T

§

type Error = <I as FallibleIterator>::Error

source§

impl<B, F, I> FallibleIterator for MapErr<I, F>where I: FallibleIterator, F: FnMut(I::Error) -> B,

§

type Item = <I as FallibleIterator>::Item

§

type Error = B

source§

impl<B, I, F> FallibleIterator for FilterMap<I, F>where I: FallibleIterator, F: FnMut(I::Item) -> Result<Option<B>, I::Error>,

§

type Item = B

§

type Error = <I as FallibleIterator>::Error

source§

impl<B, I, St, F> FallibleIterator for Scan<I, St, F>where I: FallibleIterator, F: FnMut(&mut St, I::Item) -> Result<Option<B>, I::Error>,

§

type Item = B

§

type Error = <I as FallibleIterator>::Error

source§

impl<I> FallibleIterator for Cycle<I>where I: FallibleIterator + Clone,

§

type Item = <I as FallibleIterator>::Item

§

type Error = <I as FallibleIterator>::Error

source§

impl<I> FallibleIterator for Enumerate<I>where I: FallibleIterator,

§

type Item = (usize, <I as FallibleIterator>::Item)

§

type Error = <I as FallibleIterator>::Error

source§

impl<I> FallibleIterator for Flatten<I>where I: FallibleIterator, I::Item: IntoFallibleIterator<Error = I::Error>,

§

type Item = <<I as FallibleIterator>::Item as IntoFallibleIterator>::Item

§

type Error = <<I as FallibleIterator>::Item as IntoFallibleIterator>::Error

source§

impl<I> FallibleIterator for Fuse<I>where I: FallibleIterator,

§

type Item = <I as FallibleIterator>::Item

§

type Error = <I as FallibleIterator>::Error

source§

impl<I> FallibleIterator for Peekable<I>where I: FallibleIterator,

§

type Item = <I as FallibleIterator>::Item

§

type Error = <I as FallibleIterator>::Error

source§

impl<I> FallibleIterator for Rev<I>where I: DoubleEndedFallibleIterator,

§

type Item = <I as FallibleIterator>::Item

§

type Error = <I as FallibleIterator>::Error

source§

impl<I> FallibleIterator for Skip<I>where I: FallibleIterator,

§

type Item = <I as FallibleIterator>::Item

§

type Error = <I as FallibleIterator>::Error

source§

impl<I> FallibleIterator for StepBy<I>where I: FallibleIterator,

§

type Item = <I as FallibleIterator>::Item

§

type Error = <I as FallibleIterator>::Error

source§

impl<I> FallibleIterator for Take<I>where I: FallibleIterator,

§

type Item = <I as FallibleIterator>::Item

§

type Error = <I as FallibleIterator>::Error

source§

impl<I, E, F> FallibleIterator for FromFn<F>where F: FnMut() -> Result<Option<I>, E>,

§

type Item = I

§

type Error = E

source§

impl<I, F> FallibleIterator for Filter<I, F>where I: FallibleIterator, F: FnMut(&I::Item) -> Result<bool, I::Error>,

§

type Item = <I as FallibleIterator>::Item

§

type Error = <I as FallibleIterator>::Error

source§

impl<I, F> FallibleIterator for Inspect<I, F>where I: FallibleIterator, F: FnMut(&I::Item) -> Result<(), I::Error>,

§

type Item = <I as FallibleIterator>::Item

§

type Error = <I as FallibleIterator>::Error

source§

impl<I, P> FallibleIterator for SkipWhile<I, P>where I: FallibleIterator, P: FnMut(&I::Item) -> Result<bool, I::Error>,

§

type Item = <I as FallibleIterator>::Item

§

type Error = <I as FallibleIterator>::Error

source§

impl<I, P> FallibleIterator for TakeWhile<I, P>where I: FallibleIterator, P: FnMut(&I::Item) -> Result<bool, I::Error>,

§

type Item = <I as FallibleIterator>::Item

§

type Error = <I as FallibleIterator>::Error

source§

impl<I, U, F> FallibleIterator for FlatMap<I, U, F>where I: FallibleIterator, U: IntoFallibleIterator<Error = I::Error>, F: FnMut(I::Item) -> Result<U, I::Error>,

§

type Item = <U as IntoFallibleIterator>::Item

§

type Error = <U as IntoFallibleIterator>::Error

source§

impl<T, E> FallibleIterator for Empty<T, E>

§

type Item = T

§

type Error = E

source§

impl<T, E> FallibleIterator for Once<T, E>

§

type Item = T

§

type Error = E

source§

impl<T, E> FallibleIterator for OnceErr<T, E>

§

type Item = T

§

type Error = E

source§

impl<T, E, I> FallibleIterator for Convert<I>where I: Iterator<Item = Result<T, E>>,

§

type Item = T

§

type Error = E

source§

impl<T, E: Clone> FallibleIterator for RepeatErr<T, E>

§

type Item = T

§

type Error = E

source§

impl<T, F, B> FallibleIterator for Map<T, F>where T: FallibleIterator, F: FnMut(T::Item) -> Result<B, T::Error>,

§

type Item = B

§

type Error = <T as FallibleIterator>::Error

source§

impl<T, I> FallibleIterator for IntoFallible<I>where I: Iterator<Item = T>,

§

type Item = T

§

type Error = Infallible

source§

impl<T, U> FallibleIterator for Chain<T, U>where T: FallibleIterator, U: FallibleIterator<Item = T::Item, Error = T::Error>,

§

type Item = <T as FallibleIterator>::Item

§

type Error = <T as FallibleIterator>::Error

source§

impl<T, U> FallibleIterator for Zip<T, U>where T: FallibleIterator, U: FallibleIterator<Error = T::Error>,

§

type Item = (<T as FallibleIterator>::Item, <U as FallibleIterator>::Item)

§

type Error = <T as FallibleIterator>::Error

source§

impl<T: Clone, E> FallibleIterator for Repeat<T, E>

§

type Item = T

§

type Error = E