Struct `RSplitMut`

struct RSplitMut<'a, T: 'a, P> { ... }
where
    P: FnMut(&T) -> bool

An iterator over the subslices of the vector which are separated by elements that match pred, starting from the end of the slice.

This struct is created by the rsplit_mut method on slices.

Example

let mut slice = [11, 22, 33, 0, 44, 55];
let iter = slice.rsplit_mut(|num| *num == 0);

Implementations

`impl<'a, T, P> DoubleEndedIterator for RSplitMut<'a, T, P>`

fn next_back(self: &mut Self) -> Option<&'a mut [T]>

`impl<'a, T, P> Freeze for RSplitMut<'a, T, P>`

`impl<'a, T, P> Iterator for RSplitMut<'a, T, P>`

fn next(self: &mut Self) -> Option<&'a mut [T]>
fn size_hint(self: &Self) -> (usize, Option<usize>)

`impl<'a, T, P> RefUnwindSafe for RSplitMut<'a, T, P>`

`impl<'a, T, P> Send for RSplitMut<'a, T, P>`

`impl<'a, T, P> Sync for RSplitMut<'a, T, P>`

`impl<'a, T, P> Unpin for RSplitMut<'a, T, P>`

`impl<'a, T, P> UnsafeUnpin for RSplitMut<'a, T, P>`

`impl<'a, T, P> UnwindSafe for RSplitMut<'a, T, P>`

`impl<I> IntoIterator for RSplitMut<'a, T, P>`

fn into_iter(self: Self) -> I

`impl<T> Any for RSplitMut<'a, T, P>`

fn type_id(self: &Self) -> TypeId

`impl<T> Borrow for RSplitMut<'a, T, P>`

fn borrow(self: &Self) -> &T

`impl<T> BorrowMut for RSplitMut<'a, T, P>`

fn borrow_mut(self: &mut Self) -> &mut T

`impl<T> From for RSplitMut<'a, T, P>`

fn from(t: T) -> T: Returns the argument unchanged.

`impl<T, P> FusedIterator for RSplitMut<'_, T, P>`

`impl<T, U> Into for RSplitMut<'a, T, P>`

fn into(self: Self) -> U

Calls U::from(self).

That is, this conversion is whatever the implementation of [From]<T> for U chooses to do.

`impl<T, U> TryFrom for RSplitMut<'a, T, P>`

fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

`impl<T, U> TryInto for RSplitMut<'a, T, P>`

fn try_into(self: Self) -> Result<U, <U as TryFrom<T>>::Error>

`impl<T: fmt::Debug, P> Debug for RSplitMut<'_, T, P>`

fn fmt(self: &Self, f: &mut Formatter<'_>) -> Result