Trait fallible_iterator::DoubleEndedFallibleIterator

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

    fn rfold<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_rfold<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>,
    { ... }
}

A fallible iterator able to yield elements from both ends.

Required methods

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

Advances the end of the iterator, returning the last value.

Loading content...

Provided methods

fn rfold<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 in reverse order, producing a single final value.

fn try_rfold<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 in reverse, producing a single final value.

This is used as the "base" of many methods on DoubleEndedFallibleIterator.

Loading content...

Implementations on Foreign Types

impl<I: DoubleEndedFallibleIterator + ?Sized, '_> DoubleEndedFallibleIterator for &'_ mut I

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

fn rfold<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_rfold<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>, 

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

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

fn rfold<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_rfold<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>, 

Loading content...

Implementors

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

fn next_back(&mut self) -> Result<Option<T>, I::Error>

fn try_rfold<B, E, F>(&mut self, init: B, f: F) -> Result<B, E> where
    E: From<I::Error>,
    F: FnMut(B, T) -> Result<B, E>, 

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

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

fn next_back(&mut self) -> Result<Option<B>, I::Error>

fn try_rfold<C, E, G>(&mut self, init: C, f: G) -> Result<C, E> where
    E: From<I::Error>,
    G: FnMut(C, B) -> Result<C, E>, 

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

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

fn next_back(&mut self) -> Result<Option<I::Item>, B>

fn try_rfold<C, E, G>(&mut self, init: C, f: G) -> Result<C, E> where
    E: From<B>,
    G: FnMut(C, I::Item) -> Result<C, E>, 

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

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

fn next_back(&mut self) -> Result<Option<B>, I::Error>

fn try_rfold<C, E, G>(&mut self, init: C, f: G) -> Result<C, E> where
    E: From<I::Error>,
    G: FnMut(C, B) -> Result<C, E>, 

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

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

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

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

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

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

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

fn try_rfold<B, E, G>(&mut self, init: B, f: G) -> Result<B, E> where
    E: From<I::Error>,
    G: FnMut(B, I::Item) -> Result<B, E>, 

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

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

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

fn try_rfold<B, E, G>(&mut self, init: B, f: G) -> Result<B, E> where
    E: From<I::Error>,
    G: FnMut(B, I::Item) -> Result<B, E>, 

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

impl<T, E, I> DoubleEndedFallibleIterator for Convert<I> where
    I: DoubleEndedIterator<Item = Result<T, E>>, 

fn next_back(&mut self) -> Result<Option<T>, E>

fn try_rfold<B, E2, F>(&mut self, init: B, f: F) -> Result<B, E2> where
    E2: From<E>,
    F: FnMut(B, T) -> Result<B, E2>, 

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

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

fn next_back(&mut self) -> Result<Option<T::Item>, T::Error>

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

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

Loading content...