Trait streaming_iterator::DoubleEndedStreamingIteratorMut

pub trait DoubleEndedStreamingIteratorMut: DoubleEndedStreamingIterator + StreamingIteratorMut {
    fn next_back_mut(&mut self) -> Option<&mut Self::Item> { ... }
    fn rfold_mut<B, F>(self, init: B, f: F) -> B
    where
        Self: Sized,
        F: FnMut(B, &mut Self::Item) -> B,
    { ... }
}

A mutable streaming iterator able to yield elements from both ends.

Provided methods

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

Advances the iterator and returns the next mutable value from the back.

The behavior of calling this method after the end of the iterator has been reached is unspecified.

The default implementation simply calls advance_back followed by get_mut.

fn rfold_mut<B, F>(self, init: B, f: F) -> B where
    Self: Sized,
    F: FnMut(B, &mut Self::Item) -> B, 

Reduces the iterator’s mutable elements to a single, final value, starting from the back.

Loading content...

Implementors

impl<'a, I, T: ?Sized> DoubleEndedStreamingIteratorMut for ConvertMut<'a, I, T> where
    I: DoubleEndedIterator<Item = &'a mut T>, 

fn rfold_mut<B, F>(self, init: B, f: F) -> B where
    Self: Sized,
    F: FnMut(B, &mut Self::Item) -> B, 

impl<A, B> DoubleEndedStreamingIteratorMut for Chain<A, B> where
    A: DoubleEndedStreamingIteratorMut,
    B: DoubleEndedStreamingIteratorMut<Item = A::Item>, 

fn rfold_mut<Acc, F>(self, init: Acc, f: F) -> Acc where
    Self: Sized,
    F: FnMut(Acc, &mut Self::Item) -> Acc, 

impl<I> DoubleEndedStreamingIteratorMut for Convert<I> where
    I: DoubleEndedIterator, 

fn rfold_mut<B, F>(self, init: B, f: F) -> B where
    Self: Sized,
    F: FnMut(B, &mut Self::Item) -> B, 

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

fn rfold_mut<B, F>(self, init: B, f: F) -> B where
    Self: Sized,
    F: FnMut(B, &mut Self::Item) -> B, 

impl<I, B, F> DoubleEndedStreamingIteratorMut for FilterMap<I, B, F> where
    I: DoubleEndedStreamingIterator,
    F: FnMut(&I::Item) -> Option<B>, 

fn rfold_mut<Acc, Fold>(self, init: Acc, fold: Fold) -> Acc where
    Self: Sized,
    Fold: FnMut(Acc, &mut Self::Item) -> Acc, 

impl<I, B, F> DoubleEndedStreamingIteratorMut for Map<I, B, F> where
    I: DoubleEndedStreamingIterator,
    F: FnMut(&I::Item) -> B, 

fn rfold_mut<Acc, Fold>(self, init: Acc, fold: Fold) -> Acc where
    Self: Sized,
    Fold: FnMut(Acc, &mut Self::Item) -> Acc, 

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

fn rfold_mut<Acc, Fold>(self, init: Acc, fold: Fold) -> Acc where
    Self: Sized,
    Fold: FnMut(Acc, &mut Self::Item) -> Acc, 

impl<I, F> DoubleEndedStreamingIteratorMut for Inspect<I, F> where
    I: DoubleEndedStreamingIteratorMut,
    F: FnMut(&I::Item), 

fn rfold_mut<Acc, Fold>(self, init: Acc, fold: Fold) -> Acc where
    Self: Sized,
    Fold: FnMut(Acc, &mut Self::Item) -> Acc, 

impl<T> DoubleEndedStreamingIteratorMut for Empty<T>

impl<T> DoubleEndedStreamingIteratorMut for Once<T>

impl<T> DoubleEndedStreamingIteratorMut for Repeat<T>

impl<T, F: FnOnce() -> T> DoubleEndedStreamingIteratorMut for OnceWith<T, F>

Loading content...