[−][src]Trait fdt_rs::prelude::FallibleIterator

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 count(self) -> Result<usize, Self::Error> { ... }

    fn last(self) -> Result<Option<Self::Item>, Self::Error> { ... }

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

    fn step_by(self, step: usize) -> StepBy<Self> { ... }

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

    fn zip<I>(
        self, 
        o: I
    ) -> Zip<Self, <I as IntoFallibleIterator>::IntoFallibleIter>
    where
        I: IntoFallibleIterator<Error = Self::Error>,
    { ... }

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

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

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

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

    fn enumerate(self) -> Enumerate<Self> { ... }

    fn peekable(self) -> Peekable<Self> { ... }

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

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

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

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

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

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

    fn flatten(self) -> Flatten<Self>
    where
        Self::Item: IntoFallibleIterator,
        <Self::Item as IntoFallibleIterator>::Error == Self::Error,
    { ... }

    fn fuse(self) -> Fuse<Self> { ... }

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

    fn by_ref(&mut self) -> &mut Self { ... }

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

    fn partition<B, F>(self, f: F) -> Result<(B, B), Self::Error>
    where
        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
        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
        E: From<Self::Error>,
        F: FnMut(B, Self::Item) -> Result<B, E>,
    { ... }

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

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

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

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

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

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

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

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

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

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

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

    fn rev(self) -> Rev<Self>
    where
        Self: DoubleEndedFallibleIterator,
    { ... }

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

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

    fn cycle(self) -> Cycle<Self>
    where
        Self: Clone,
    { ... }

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

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

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

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

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

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

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

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

    fn iterator(self) -> Iterator<Self> { ... }

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

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.

Loading content...

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.

Loading content...

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 count(self) -> Result<usize, Self::Error>

Consumes the iterator, returning the number of remaining items.

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

Returns the last element of the iterator.

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

Returns the nth element of the iterator.

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

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

Panics

Panics if step is 0.

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

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

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

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

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

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

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

Calls a fallible closure on each element of an iterator.

fn filter<F>(self, f: F) -> Filter<Self, F> where
    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.

fn filter_map<B, F>(self, f: F) -> FilterMap<Self, F> where
    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.

fn enumerate(self) -> Enumerate<Self>

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

fn peekable(self) -> Peekable<Self>

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

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

Returns an iterator that skips elements based on a predicate.

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

Returns an iterator that yields elements based on a predicate.

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

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

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

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

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

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

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

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

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

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

fn fuse(self) -> Fuse<Self>

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.

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

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

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

Borrow an iterator rather than consuming it.

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

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

Transforms the iterator into a collection.

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

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

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

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

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

fn try_fold<B, E, F>(&mut self, init: B, f: F) -> Result<B, E> where
    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.

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

Determines if all elements of this iterator match a predicate.

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

Determines if any element of this iterator matches a predicate.

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

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

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

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

fn position<F>(&mut self, f: F) -> Result<Option<usize>, Self::Error> where
    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.

fn max(self) -> Result<Option<Self::Item>, Self::Error> where
    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
    B: Ord,
    F: FnMut(&Self::Item) -> Result<B, Self::Error>, 

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

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

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

fn min(self) -> Result<Option<Self::Item>, Self::Error> where
    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
    B: Ord,
    F: FnMut(&Self::Item) -> Result<B, Self::Error>, 

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

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

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

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

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

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

Converts an iterator of pairs into a pair of containers.

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

Returns an iterator which clones all of its elements.

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

Returns an iterator which repeas this iterator endlessly.

fn cmp<I>(self, other: I) -> Result<Ordering, Self::Error> where
    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
    I: IntoFallibleIterator<Error = Self::Error>,
    Self::Item: PartialOrd<<I as IntoFallibleIterator>::Item>, 

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

fn eq<I>(self, other: I) -> Result<bool, Self::Error> where
    I: IntoFallibleIterator<Error = Self::Error>,
    Self::Item: PartialEq<<I as IntoFallibleIterator>::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
    I: IntoFallibleIterator<Error = Self::Error>,
    Self::Item: PartialEq<<I as IntoFallibleIterator>::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
    I: IntoFallibleIterator<Error = Self::Error>,
    Self::Item: PartialOrd<<I as IntoFallibleIterator>::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
    I: IntoFallibleIterator<Error = Self::Error>,
    Self::Item: PartialOrd<<I as IntoFallibleIterator>::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
    I: IntoFallibleIterator<Error = Self::Error>,
    Self::Item: PartialOrd<<I as IntoFallibleIterator>::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
    I: IntoFallibleIterator<Error = Self::Error>,
    Self::Item: PartialOrd<<I as IntoFallibleIterator>::Item>, 

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

fn iterator(self) -> Iterator<Self>

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

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

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

Loading content...

Implementations on Foreign Types

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

type Item = T

type Error = <I as FallibleIterator>::Error

impl<I> FallibleIterator for Skip<I> where
    I: FallibleIterator, [src]

type Item = <I as FallibleIterator>::Item

type Error = <I as FallibleIterator>::Error

impl<T, U> FallibleIterator for Zip<T, U> where
    T: FallibleIterator,
    U: FallibleIterator<Error = <T as FallibleIterator>::Error>, [src]

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

type Error = <T as FallibleIterator>::Error

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

type Item = <I as FallibleIterator>::Item

type Error = <I as FallibleIterator>::Error

impl<I> FallibleIterator for Enumerate<I> where
    I: FallibleIterator, [src]

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

type Error = <I as FallibleIterator>::Error

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

type Item = <I as FallibleIterator>::Item

type Error = <I as FallibleIterator>::Error

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

type Item = B

type Error = <I as FallibleIterator>::Error

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

type Item = T

type Error = E

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

type Item = <I as FallibleIterator>::Item

type Error = <I as FallibleIterator>::Error

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

type Item = B

type Error = <I as FallibleIterator>::Error

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

type Item = <I as FallibleIterator>::Item

type Error = <I as FallibleIterator>::Error

impl<I> FallibleIterator for Flatten<I> where
    I: FallibleIterator,
    <I as FallibleIterator>::Item: IntoFallibleIterator,
    <<I as FallibleIterator>::Item as IntoFallibleIterator>::Error == <I as FallibleIterator>::Error, [src]

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

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

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

type Item = B

type Error = <T as FallibleIterator>::Error

impl<I> FallibleIterator for Peekable<I> where
    I: FallibleIterator, [src]

type Item = <I as FallibleIterator>::Item

type Error = <I as FallibleIterator>::Error

impl<I> FallibleIterator for Rev<I> where
    I: DoubleEndedFallibleIterator, [src]

type Item = <I as FallibleIterator>::Item

type Error = <I as FallibleIterator>::Error

impl<I> FallibleIterator for Take<I> where
    I: FallibleIterator, [src]

type Item = <I as FallibleIterator>::Item

type Error = <I as FallibleIterator>::Error

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

type Item = <I as FallibleIterator>::Item

type Error = <I as FallibleIterator>::Error

impl<'_, I> FallibleIterator for &'_ mut I where
    I: FallibleIterator + ?Sized, [src]

type Item = <I as FallibleIterator>::Item

type Error = <I as FallibleIterator>::Error

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

type Item = <U as IntoFallibleIterator>::Item

type Error = <U as IntoFallibleIterator>::Error

impl<T, U> FallibleIterator for Chain<T, U> where
    T: FallibleIterator,
    U: FallibleIterator<Item = <T as FallibleIterator>::Item, Error = <T as FallibleIterator>::Error>, [src]

type Item = <T as FallibleIterator>::Item

type Error = <T as FallibleIterator>::Error

impl<I> FallibleIterator for Fuse<I> where
    I: FallibleIterator, [src]

type Item = <I as FallibleIterator>::Item

type Error = <I as FallibleIterator>::Error

impl<I> FallibleIterator for StepBy<I> where
    I: FallibleIterator, [src]

type Item = <I as FallibleIterator>::Item

type Error = <I as FallibleIterator>::Error

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

type Item = <I as FallibleIterator>::Item

type Error = B

Loading content...

Implementors

impl<'a, 'dt: 'a> FallibleIterator for DevTreeIter<'a, 'dt>[src]

type Error = DevTreeError

type Item = DevTreeItem<'a, 'dt>

impl<'a, 'dt: 'a> FallibleIterator for DevTreeNodeIter<'a, 'dt>[src]

type Item = DevTreeNode<'a, 'dt>

type Error = DevTreeError

impl<'a, 'dt: 'a> FallibleIterator for DevTreeNodePropIter<'a, 'dt>[src]

type Error = DevTreeError

type Item = DevTreeProp<'a, 'dt>

impl<'a, 'dt: 'a> FallibleIterator for DevTreePropIter<'a, 'dt>[src]

type Error = DevTreeError

type Item = DevTreeProp<'a, 'dt>

impl<'dt> FallibleIterator for StringPropIter<'dt>[src]

type Error = DevTreeError

type Item = &'dt str

impl<'dt, 'a: 'dt> FallibleIterator for DevTreeParseIter<'dt, 'a>[src]

type Error = DevTreeError

type Item = ParsedTok<'a>

impl<'s, 'a, 'dt: 'a> FallibleIterator for DevTreeCompatibleNodeIter<'s, 'a, 'dt>[src]

type Error = DevTreeError

type Item = DevTreeNode<'a, 'dt>

Loading content...