Trait fallible_streaming_iterator::FallibleStreamingIterator

pub trait FallibleStreamingIterator {
    type Item: ?Sized;
    type Error;

    // Required methods
    fn advance(&mut self) -> Result<(), Self::Error>;
    fn get(&self) -> Option<&Self::Item>;

    // Provided methods
    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 count(self) -> Result<usize, Self::Error>
       where Self: Sized { ... }
    fn filter<F>(self, f: F) -> Filter<Self, F>
       where Self: Sized,
             F: FnMut(&Self::Item) -> bool { ... }
    fn find<F>(&mut self, f: F) -> Result<Option<&Self::Item>, Self::Error>
       where Self: Sized,
             F: FnMut(&Self::Item) -> bool { ... }
    fn for_each<F>(self, f: F) -> Result<(), Self::Error>
       where Self: Sized,
             F: FnMut(&Self::Item) { ... }
    fn fuse(self) -> Fuse<Self>
       where Self: Sized { ... }
    fn map<F, B>(self, f: F) -> Map<Self, F, B>
       where Self: Sized,
             F: FnMut(&Self::Item) -> B { ... }
    fn map_ref<F, B: ?Sized>(self, f: F) -> MapRef<Self, F>
       where Self: Sized,
             F: Fn(&Self::Item) -> &B { ... }
    fn map_err<F, B>(self, f: F) -> MapErr<Self, F>
       where Self: Sized,
             F: Fn(Self::Error) -> B { ... }
    fn nth(&mut self, n: usize) -> Result<Option<&Self::Item>, Self::Error> { ... }
    fn position<F>(&mut self, f: F) -> Result<Option<usize>, Self::Error>
       where Self: Sized,
             F: FnMut(&Self::Item) -> bool { ... }
    fn skip(self, n: usize) -> Skip<Self>
       where Self: Sized { ... }
    fn skip_while<F>(self, f: F) -> SkipWhile<Self, F>
       where Self: Sized,
             F: FnMut(&Self::Item) -> bool { ... }
    fn take(self, n: usize) -> Take<Self>
       where Self: Sized { ... }
    fn take_while<F>(self, f: F) -> TakeWhile<Self, F>
       where Self: Sized,
             F: FnMut(&Self::Item) -> bool { ... }
}

A fallible, streaming iterator.

Required Associated Types

type Item: ?Sized

The type being iterated over.

type Error

The error type of iteration.

Required Methods

fn advance(&mut self) -> Result<(), Self::Error>

Advances the iterator to the next position.

Iterators start just before the first item, so this method should be called before get when iterating.

The behavior of calling this method after get has returned None, or after this method has returned an error is unspecified.

fn get(&self) -> Option<&Self::Item>

Returns the current element.

The behavior of calling this method before any calls to advance is unspecified.

Provided Methods

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

Advances the iterator, returning the next element.

The default implementation simply calls advance followed by get.

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

Returns bounds on the number of remaining elements in the 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 the iterator satisfy a predicate.

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

where Self: Sized, F: FnMut(&Self::Item) -> bool,

Determines if any elements of the iterator satisfy a predicate.

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

where Self: Sized,

Borrows an iterator, rather than consuming it.

This is useful to allow the application of iterator adaptors while still retaining ownership of the original adaptor.

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

where Self: Sized,

Returns the number of remaining elements in the iterator.

fn filter<F>(self, f: F) -> Filter<Self, F>

where Self: Sized, F: FnMut(&Self::Item) -> bool,

Returns an iterator which filters elements by a predicate.

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 which satisfies a predicate.

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

where Self: Sized, F: FnMut(&Self::Item),

Calls a closure on each element of an iterator.

fn fuse(self) -> Fuse<Self>

where Self: Sized,

Returns an iterator which is well-behaved at the beginning and end of iteration.

fn map<F, B>(self, f: F) -> Map<Self, F, B>

where Self: Sized, F: FnMut(&Self::Item) -> B,

Returns an iterator which applies a transform to elements.

fn map_ref<F, B: ?Sized>(self, f: F) -> MapRef<Self, F>

where Self: Sized, F: Fn(&Self::Item) -> &B,

Returns an iterator which applies a transform to elements.

Unlike map, the the closure provided to this method returns a reference into the original value.

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

where Self: Sized, F: Fn(Self::Error) -> B,

Returns an iterator that applies a transform to errors.

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

Returns the nth element of the iterator.

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 matching a predicate.

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

where Self: Sized,

Returns an iterator which skips the first n elements.

fn skip_while<F>(self, f: F) -> SkipWhile<Self, F>

where Self: Sized, F: FnMut(&Self::Item) -> bool,

Returns an iterator which skips the first sequence of elements matching a predicate.

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

where Self: Sized,

Returns an iterator which only returns the first n elements.

fn take_while<F>(self, f: F) -> TakeWhile<Self, F>

where Self: Sized, F: FnMut(&Self::Item) -> bool,

Returns an iterator which only returns the first sequence of elements matching a predicate.

Implementations on Foreign Types

impl<'a, I> FallibleStreamingIterator for &'a mut I

where I: FallibleStreamingIterator + ?Sized,

type Item = <I as FallibleStreamingIterator>::Item

type Error = <I as FallibleStreamingIterator>::Error

fn advance(&mut self) -> Result<(), I::Error>

fn get(&self) -> Option<&I::Item>

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

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

Implementors

impl<'a, I, T, E> FallibleStreamingIterator for Convert<'a, I, T>

where I: Iterator<Item = Result<&'a T, E>>,

type Item = T

type Error = E

impl<I> FallibleStreamingIterator for Fuse<I>

where I: FallibleStreamingIterator,

type Item = <I as FallibleStreamingIterator>::Item

type Error = <I as FallibleStreamingIterator>::Error

impl<I> FallibleStreamingIterator for Skip<I>

where I: FallibleStreamingIterator,

type Item = <I as FallibleStreamingIterator>::Item

type Error = <I as FallibleStreamingIterator>::Error

impl<I> FallibleStreamingIterator for Take<I>

where I: FallibleStreamingIterator,

type Item = <I as FallibleStreamingIterator>::Item

type Error = <I as FallibleStreamingIterator>::Error

impl<I, F> FallibleStreamingIterator for Filter<I, F>

where I: FallibleStreamingIterator, F: FnMut(&I::Item) -> bool,

type Item = <I as FallibleStreamingIterator>::Item

type Error = <I as FallibleStreamingIterator>::Error

impl<I, F> FallibleStreamingIterator for SkipWhile<I, F>

where I: FallibleStreamingIterator, F: FnMut(&I::Item) -> bool,

type Item = <I as FallibleStreamingIterator>::Item

type Error = <I as FallibleStreamingIterator>::Error

impl<I, F> FallibleStreamingIterator for TakeWhile<I, F>

where I: FallibleStreamingIterator, F: FnMut(&I::Item) -> bool,

type Item = <I as FallibleStreamingIterator>::Item

type Error = <I as FallibleStreamingIterator>::Error

impl<I, F, B> FallibleStreamingIterator for Map<I, F, B>

where I: FallibleStreamingIterator, F: FnMut(&I::Item) -> B,

type Item = B

type Error = <I as FallibleStreamingIterator>::Error

impl<I, F, B> FallibleStreamingIterator for MapErr<I, F>

where I: FallibleStreamingIterator, F: Fn(I::Error) -> B,

type Item = <I as FallibleStreamingIterator>::Item

type Error = B

impl<I, F, B: ?Sized> FallibleStreamingIterator for MapRef<I, F>

where I: FallibleStreamingIterator, F: Fn(&I::Item) -> &B,

type Item = B

type Error = <I as FallibleStreamingIterator>::Error

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

type Item = T

type Error = E