Trait rin::ecs::streaming_iterator::DoubleEndedStreamingIteratorMut

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

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

Provided methods

pub 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.

pub fn rfold_mut<B, F>(self, init: B, f: F) -> B where
    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> DoubleEndedStreamingIteratorMut for ConvertMut<'a, I, T> where
    T: ?Sized,
    I: DoubleEndedIterator<Item = &'a mut T>, 

pub fn rfold_mut<B, F>(self, init: B, f: F) -> B where
    F: FnMut(B, &mut <ConvertMut<'a, I, T> as StreamingIterator>::Item) -> B,
    ConvertMut<'a, I, T>: Sized, 

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

pub fn rfold_mut<Acc, F>(self, init: Acc, f: F) -> Acc where
    F: FnMut(Acc, &mut <Chain<A, B> as StreamingIterator>::Item) -> Acc,
    Chain<A, B>: Sized, 

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

pub fn rfold_mut<B, F>(self, init: B, f: F) -> B where
    F: FnMut(B, &mut <Convert<I> as StreamingIterator>::Item) -> B,
    Convert<I>: Sized, 

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

pub fn rfold_mut<B, F>(self, init: B, f: F) -> B where
    F: FnMut(B, &mut <Rev<I> as StreamingIterator>::Item) -> B,
    Rev<I>: Sized, 

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

pub fn rfold_mut<Acc, Fold>(self, init: Acc, fold: Fold) -> Acc where
    Fold: FnMut(Acc, &mut <FilterMap<I, B, F> as StreamingIterator>::Item) -> Acc,
    FilterMap<I, B, F>: Sized, 

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

pub fn rfold_mut<Acc, Fold>(self, init: Acc, fold: Fold) -> Acc where
    Fold: FnMut(Acc, &mut <Map<I, B, F> as StreamingIterator>::Item) -> Acc,
    Map<I, B, F>: Sized, 

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

pub fn rfold_mut<Acc, Fold>(self, init: Acc, fold: Fold) -> Acc where
    Fold: FnMut(Acc, &mut <Filter<I, F> as StreamingIterator>::Item) -> Acc,
    Filter<I, F>: Sized, 

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

pub fn rfold_mut<Acc, Fold>(self, init: Acc, fold: Fold) -> Acc where
    Fold: FnMut(Acc, &mut <Inspect<I, F> as StreamingIterator>::Item) -> Acc,
    Inspect<I, F>: Sized, 

impl<T> DoubleEndedStreamingIteratorMut for Empty<T>

impl<T> DoubleEndedStreamingIteratorMut for Once<T>

impl<T> DoubleEndedStreamingIteratorMut for Repeat<T>

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

Loading content...