Trait fallible_iterator::FallibleIterator [−] [src]

pub trait FallibleIterator {
    type Item;
    type Error;
    fn next(&mut self) -> Result<Option<Self::Item>, Self::Error>;

    fn size_hint(&self) -> (usize, Option<usize>) { ... }
    fn all<F>(&mut self, f: F) -> Result<bool, Self::Error> where Self: Sized, F: FnMut(Self::Item) -> bool { ... }
    fn any<F>(&mut self, f: F) -> Result<bool, Self::Error> where Self: Sized, F: FnMut(Self::Item) -> bool { ... }
    fn by_ref(&mut self) -> &mut 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 cloned<'a, T>(self) -> Cloned<Self> where Self: Sized + FallibleIterator<Item=&'a T>, T: 'a + Clone { ... }
    fn count(self) -> Result<usize, Self::Error> where Self: Sized { ... }
    fn collect<T>(self) -> Result<T, Self::Error> where T: FromFallibleIterator<Self::Item>, Self: Sized { ... }
    fn enumerate(self) -> Enumerate<Self> where Self: Sized { ... }
    fn filter<F>(self, f: F) -> Filter<Self, F> where Self: Sized, F: FnMut(&Self::Item) -> bool { ... }
    fn filter_map<B, F>(self, f: F) -> FilterMap<Self, F> where Self: Sized, F: FnMut(Self::Item) -> Option<B> { ... }
    fn find<F>(&mut self, f: F) -> Result<Option<Self::Item>, Self::Error> where Self: Sized, F: FnMut(&Self::Item) -> bool { ... }
    fn fuse(self) -> Fuse<Self> where Self: Sized { ... }
    fn fold<B, F>(self, init: B, f: F) -> Result<B, Self::Error> where Self: Sized, F: FnMut(B, Self::Item) -> B { ... }
    fn iterator(self) -> Iterator<Self> where Self: Sized { ... }
    fn last(self) -> Result<Option<Self::Item>, Self::Error> where Self: Sized { ... }
    fn map<B, F>(self, f: F) -> Map<Self, F> where F: FnMut(Self::Item) -> B, Self: Sized { ... }
    fn map_err<B, F>(self, f: F) -> MapErr<Self, F> where F: FnMut(Self::Error) -> B, Self: Sized { ... }
    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) -> B { ... }
    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) -> B { ... }
    fn nth(&mut self, n: usize) -> Result<Option<Self::Item>, Self::Error> { ... }
    fn peekable(self) -> Peekable<Self> where Self: Sized { ... }
    fn position<F>(&mut self, f: F) -> Result<Option<usize>, Self::Error> where Self: Sized, F: FnMut(Self::Item) -> bool { ... }
    fn rev(self) -> Rev<Self> where Self: Sized + DoubleEndedFallibleIterator { ... }
    fn take(self, n: usize) -> Take<Self> where Self: Sized { ... }
    fn zip<I>(self, o: I) -> Zip<Self, I::IntoIter> where Self: Sized, I: IntoFallibleIterator<Error=Self::Error> { ... }
    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> { ... }
}

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

Associated Types

type Item

The type being iterated over.

type Error

The error type.

Required Methods

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 implemenetation defined.

Provided Methods

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.

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

Determines if all elements of this iterator matches a predicate.

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

Determines if any element of this iterator matches a predicate.

fn by_ref(&mut self) -> &mut Self where 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.

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.

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.

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

Consumes the iterator, returning the number of remaining items.

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

Transforms the iterator into a collection.

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

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

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

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

Returns an iterator which uses a predicate to determine which values should be yielded.

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

Returns an iterator which both filters and maps.

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

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

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

Returns an iterator which yields this iterator's elements and ends after the frist 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.

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

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

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

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

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

Returns the last element of the iterator.

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

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

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.

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

Returns the maximal element of the iterator.

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

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

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

Returns the minimal element of the iterator.

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

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

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

Returns the nth element of the iterator.

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

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

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

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

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

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

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

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

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

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

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.

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.

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.

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.

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.

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.

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.

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.

Implementors