1.31.0[−][src]Struct core::slice::RChunksMut  
An iterator over a slice in (non-overlapping) mutable chunks (chunk_size
elements at a time), starting at the end of the slice.
When the slice len is not evenly divided by the chunk size, the last slice of the iteration will be the remainder.
This struct is created by the rchunks_mut method on slices.
Trait Implementations
impl<'a, T: Debug + 'a> Debug for RChunksMut<'a, T>[src]
impl<'a, T> DoubleEndedIterator for RChunksMut<'a, T>[src]
fn next_back(&mut self) -> Option<&'a mut [T]>[src]
fn nth_back(&mut self, n: usize) -> Option<Self::Item>[src]
fn try_rfold<B, F, R>(&mut self, init: B, f: F) -> R where
    Self: Sized,
    F: FnMut(B, Self::Item) -> R,
    R: Try<Ok = B>, 1.27.0[src]
Self: Sized,
F: FnMut(B, Self::Item) -> R,
R: Try<Ok = B>,
fn rfold<B, F>(self, accum: B, f: F) -> B where
    Self: Sized,
    F: FnMut(B, Self::Item) -> B, 1.27.0[src]
Self: Sized,
F: FnMut(B, Self::Item) -> B,
fn rfind<P>(&mut self, predicate: P) -> Option<Self::Item> where
    Self: Sized,
    P: FnMut(&Self::Item) -> bool, 1.27.0[src]
Self: Sized,
P: FnMut(&Self::Item) -> bool,
impl<'_, T> ExactSizeIterator for RChunksMut<'_, T>[src]
impl<'_, T> FusedIterator for RChunksMut<'_, T>[src]
impl<'a, T> Iterator for RChunksMut<'a, T>[src]
type Item = &'a mut [T]
The type of the elements being iterated over.
fn next(&mut self) -> Option<&'a mut [T]>[src]
fn size_hint(&self) -> (usize, Option<usize>)[src]
fn count(self) -> usize[src]
fn nth(&mut self, n: usize) -> Option<&'a mut [T]>[src]
fn last(self) -> Option<Self::Item>[src]
fn step_by(self, step: usize) -> StepBy<Self> where
    Self: Sized, 1.28.0[src]
Self: Sized,
fn chain<U>(self, other: U) -> Chain<Self, U::IntoIter> where
    Self: Sized,
    U: IntoIterator<Item = Self::Item>, 1.0.0[src]
Self: Sized,
U: IntoIterator<Item = Self::Item>,
fn zip<U>(self, other: U) -> Zip<Self, U::IntoIter> where
    Self: Sized,
    U: IntoIterator, 1.0.0[src]
Self: Sized,
U: IntoIterator,
fn map<B, F>(self, f: F) -> Map<Self, F> where
    Self: Sized,
    F: FnMut(Self::Item) -> B, 1.0.0[src]
Self: Sized,
F: FnMut(Self::Item) -> B,
fn for_each<F>(self, f: F) where
    Self: Sized,
    F: FnMut(Self::Item), 1.21.0[src]
Self: Sized,
F: FnMut(Self::Item),
fn filter<P>(self, predicate: P) -> Filter<Self, P> where
    Self: Sized,
    P: FnMut(&Self::Item) -> bool, 1.0.0[src]
Self: Sized,
P: FnMut(&Self::Item) -> bool,
fn filter_map<B, F>(self, f: F) -> FilterMap<Self, F> where
    Self: Sized,
    F: FnMut(Self::Item) -> Option<B>, 1.0.0[src]
Self: Sized,
F: FnMut(Self::Item) -> Option<B>,
fn enumerate(self) -> Enumerate<Self> where
    Self: Sized, 1.0.0[src]
Self: Sized,
fn peekable(self) -> Peekable<Self> where
    Self: Sized, 1.0.0[src]
Self: Sized,
fn skip_while<P>(self, predicate: P) -> SkipWhile<Self, P> where
    Self: Sized,
    P: FnMut(&Self::Item) -> bool, 1.0.0[src]
Self: Sized,
P: FnMut(&Self::Item) -> bool,
fn take_while<P>(self, predicate: P) -> TakeWhile<Self, P> where
    Self: Sized,
    P: FnMut(&Self::Item) -> bool, 1.0.0[src]
Self: Sized,
P: FnMut(&Self::Item) -> bool,
fn map_while<B, P>(self, predicate: P) -> MapWhile<Self, P> where
    Self: Sized,
    P: FnMut(Self::Item) -> Option<B>, [src]
Self: Sized,
P: FnMut(Self::Item) -> Option<B>,
fn skip(self, n: usize) -> Skip<Self> where
    Self: Sized, 1.0.0[src]
Self: Sized,
fn take(self, n: usize) -> Take<Self> where
    Self: Sized, 1.0.0[src]
Self: Sized,
fn scan<St, B, F>(self, initial_state: St, f: F) -> Scan<Self, St, F> where
    Self: Sized,
    F: FnMut(&mut St, Self::Item) -> Option<B>, 1.0.0[src]
Self: Sized,
F: FnMut(&mut St, Self::Item) -> Option<B>,
fn flat_map<U, F>(self, f: F) -> FlatMap<Self, U, F> where
    Self: Sized,
    U: IntoIterator,
    F: FnMut(Self::Item) -> U, 1.0.0[src]
Self: Sized,
U: IntoIterator,
F: FnMut(Self::Item) -> U,
fn flatten(self) -> Flatten<Self> where
    Self: Sized,
    Self::Item: IntoIterator, 1.29.0[src]
Self: Sized,
Self::Item: IntoIterator,
fn fuse(self) -> Fuse<Self> where
    Self: Sized, 1.0.0[src]
Self: Sized,
fn inspect<F>(self, f: F) -> Inspect<Self, F> where
    Self: Sized,
    F: FnMut(&Self::Item), 1.0.0[src]
Self: Sized,
F: FnMut(&Self::Item),
fn by_ref(&mut self) -> &mut Self where
    Self: Sized, 1.0.0[src]
Self: Sized,
#[must_use = "if you really need to exhaust the iterator, consider `.for_each(drop)` instead"]
fn collect<B: FromIterator<Self::Item>>(self) -> B where
    Self: Sized, 1.0.0[src]
Self: Sized,
fn partition<B, F>(self, f: F) -> (B, B) where
    Self: Sized,
    B: Default + Extend<Self::Item>,
    F: FnMut(&Self::Item) -> bool, 1.0.0[src]
Self: Sized,
B: Default + Extend<Self::Item>,
F: FnMut(&Self::Item) -> bool,
fn partition_in_place<'a, T: 'a, P>(self, predicate: P) -> usize where
    Self: Sized + DoubleEndedIterator<Item = &'a mut T>,
    P: FnMut(&T) -> bool, [src]
Self: Sized + DoubleEndedIterator<Item = &'a mut T>,
P: FnMut(&T) -> bool,
fn is_partitioned<P>(self, predicate: P) -> bool where
    Self: Sized,
    P: FnMut(Self::Item) -> bool, [src]
Self: Sized,
P: FnMut(Self::Item) -> bool,
fn try_fold<B, F, R>(&mut self, init: B, f: F) -> R where
    Self: Sized,
    F: FnMut(B, Self::Item) -> R,
    R: Try<Ok = B>, 1.27.0[src]
Self: Sized,
F: FnMut(B, Self::Item) -> R,
R: Try<Ok = B>,
fn try_for_each<F, R>(&mut self, f: F) -> R where
    Self: Sized,
    F: FnMut(Self::Item) -> R,
    R: Try<Ok = ()>, 1.27.0[src]
Self: Sized,
F: FnMut(Self::Item) -> R,
R: Try<Ok = ()>,
fn fold<B, F>(self, init: B, f: F) -> B where
    Self: Sized,
    F: FnMut(B, Self::Item) -> B, 1.0.0[src]
Self: Sized,
F: FnMut(B, Self::Item) -> B,
fn all<F>(&mut self, f: F) -> bool where
    Self: Sized,
    F: FnMut(Self::Item) -> bool, 1.0.0[src]
Self: Sized,
F: FnMut(Self::Item) -> bool,
fn any<F>(&mut self, f: F) -> bool where
    Self: Sized,
    F: FnMut(Self::Item) -> bool, 1.0.0[src]
Self: Sized,
F: FnMut(Self::Item) -> bool,
fn find<P>(&mut self, predicate: P) -> Option<Self::Item> where
    Self: Sized,
    P: FnMut(&Self::Item) -> bool, 1.0.0[src]
Self: Sized,
P: FnMut(&Self::Item) -> bool,
fn find_map<B, F>(&mut self, f: F) -> Option<B> where
    Self: Sized,
    F: FnMut(Self::Item) -> Option<B>, 1.30.0[src]
Self: Sized,
F: FnMut(Self::Item) -> Option<B>,
fn try_find<F, E, R>(&mut self, f: F) -> Result<Option<Self::Item>, E> where
    Self: Sized,
    F: FnMut(&Self::Item) -> R,
    R: Try<Ok = bool, Error = E>, [src]
Self: Sized,
F: FnMut(&Self::Item) -> R,
R: Try<Ok = bool, Error = E>,
fn position<P>(&mut self, predicate: P) -> Option<usize> where
    Self: Sized,
    P: FnMut(Self::Item) -> bool, 1.0.0[src]
Self: Sized,
P: FnMut(Self::Item) -> bool,
fn rposition<P>(&mut self, predicate: P) -> Option<usize> where
    P: FnMut(Self::Item) -> bool,
    Self: Sized + ExactSizeIterator + DoubleEndedIterator, 1.0.0[src]
P: FnMut(Self::Item) -> bool,
Self: Sized + ExactSizeIterator + DoubleEndedIterator,
fn max(self) -> Option<Self::Item> where
    Self: Sized,
    Self::Item: Ord, 1.0.0[src]
Self: Sized,
Self::Item: Ord,
fn min(self) -> Option<Self::Item> where
    Self: Sized,
    Self::Item: Ord, 1.0.0[src]
Self: Sized,
Self::Item: Ord,
fn max_by_key<B: Ord, F>(self, f: F) -> Option<Self::Item> where
    Self: Sized,
    F: FnMut(&Self::Item) -> B, 1.6.0[src]
Self: Sized,
F: FnMut(&Self::Item) -> B,
fn max_by<F>(self, compare: F) -> Option<Self::Item> where
    Self: Sized,
    F: FnMut(&Self::Item, &Self::Item) -> Ordering, 1.15.0[src]
Self: Sized,
F: FnMut(&Self::Item, &Self::Item) -> Ordering,
fn min_by_key<B: Ord, F>(self, f: F) -> Option<Self::Item> where
    Self: Sized,
    F: FnMut(&Self::Item) -> B, 1.6.0[src]
Self: Sized,
F: FnMut(&Self::Item) -> B,
fn min_by<F>(self, compare: F) -> Option<Self::Item> where
    Self: Sized,
    F: FnMut(&Self::Item, &Self::Item) -> Ordering, 1.15.0[src]
Self: Sized,
F: FnMut(&Self::Item, &Self::Item) -> Ordering,
fn rev(self) -> Rev<Self> where
    Self: Sized + DoubleEndedIterator, 1.0.0[src]
Self: Sized + DoubleEndedIterator,
fn unzip<A, B, FromA, FromB>(self) -> (FromA, FromB) where
    FromA: Default + Extend<A>,
    FromB: Default + Extend<B>,
    Self: Sized + Iterator<Item = (A, B)>, 1.0.0[src]
FromA: Default + Extend<A>,
FromB: Default + Extend<B>,
Self: Sized + Iterator<Item = (A, B)>,
fn copied<'a, T: 'a>(self) -> Copied<Self> where
    Self: Sized + Iterator<Item = &'a T>,
    T: Copy, 1.36.0[src]
Self: Sized + Iterator<Item = &'a T>,
T: Copy,
fn cloned<'a, T: 'a>(self) -> Cloned<Self> where
    Self: Sized + Iterator<Item = &'a T>,
    T: Clone, 1.0.0[src]
Self: Sized + Iterator<Item = &'a T>,
T: Clone,
fn cycle(self) -> Cycle<Self> where
    Self: Sized + Clone, 1.0.0[src]
Self: Sized + Clone,
fn sum<S>(self) -> S where
    Self: Sized,
    S: Sum<Self::Item>, 1.11.0[src]
Self: Sized,
S: Sum<Self::Item>,
fn product<P>(self) -> P where
    Self: Sized,
    P: Product<Self::Item>, 1.11.0[src]
Self: Sized,
P: Product<Self::Item>,
fn cmp<I>(self, other: I) -> Ordering where
    I: IntoIterator<Item = Self::Item>,
    Self::Item: Ord,
    Self: Sized, 1.5.0[src]
I: IntoIterator<Item = Self::Item>,
Self::Item: Ord,
Self: Sized,
fn cmp_by<I, F>(self, other: I, cmp: F) -> Ordering where
    Self: Sized,
    I: IntoIterator,
    F: FnMut(Self::Item, I::Item) -> Ordering, [src]
Self: Sized,
I: IntoIterator,
F: FnMut(Self::Item, I::Item) -> Ordering,
fn partial_cmp<I>(self, other: I) -> Option<Ordering> where
    I: IntoIterator,
    Self::Item: PartialOrd<I::Item>,
    Self: Sized, 1.5.0[src]
I: IntoIterator,
Self::Item: PartialOrd<I::Item>,
Self: Sized,
fn partial_cmp_by<I, F>(self, other: I, partial_cmp: F) -> Option<Ordering> where
    Self: Sized,
    I: IntoIterator,
    F: FnMut(Self::Item, I::Item) -> Option<Ordering>, [src]
Self: Sized,
I: IntoIterator,
F: FnMut(Self::Item, I::Item) -> Option<Ordering>,
fn eq<I>(self, other: I) -> bool where
    I: IntoIterator,
    Self::Item: PartialEq<I::Item>,
    Self: Sized, 1.5.0[src]
I: IntoIterator,
Self::Item: PartialEq<I::Item>,
Self: Sized,
fn eq_by<I, F>(self, other: I, eq: F) -> bool where
    Self: Sized,
    I: IntoIterator,
    F: FnMut(Self::Item, I::Item) -> bool, [src]
Self: Sized,
I: IntoIterator,
F: FnMut(Self::Item, I::Item) -> bool,
fn ne<I>(self, other: I) -> bool where
    I: IntoIterator,
    Self::Item: PartialEq<I::Item>,
    Self: Sized, 1.5.0[src]
I: IntoIterator,
Self::Item: PartialEq<I::Item>,
Self: Sized,
fn lt<I>(self, other: I) -> bool where
    I: IntoIterator,
    Self::Item: PartialOrd<I::Item>,
    Self: Sized, 1.5.0[src]
I: IntoIterator,
Self::Item: PartialOrd<I::Item>,
Self: Sized,
fn le<I>(self, other: I) -> bool where
    I: IntoIterator,
    Self::Item: PartialOrd<I::Item>,
    Self: Sized, 1.5.0[src]
I: IntoIterator,
Self::Item: PartialOrd<I::Item>,
Self: Sized,
fn gt<I>(self, other: I) -> bool where
    I: IntoIterator,
    Self::Item: PartialOrd<I::Item>,
    Self: Sized, 1.5.0[src]
I: IntoIterator,
Self::Item: PartialOrd<I::Item>,
Self: Sized,
fn ge<I>(self, other: I) -> bool where
    I: IntoIterator,
    Self::Item: PartialOrd<I::Item>,
    Self: Sized, 1.5.0[src]
I: IntoIterator,
Self::Item: PartialOrd<I::Item>,
Self: Sized,
fn is_sorted(self) -> bool where
    Self: Sized,
    Self::Item: PartialOrd, [src]
Self: Sized,
Self::Item: PartialOrd,
fn is_sorted_by<F>(self, compare: F) -> bool where
    Self: Sized,
    F: FnMut(&Self::Item, &Self::Item) -> Option<Ordering>, [src]
Self: Sized,
F: FnMut(&Self::Item, &Self::Item) -> Option<Ordering>,
fn is_sorted_by_key<F, K>(self, f: F) -> bool where
    Self: Sized,
    F: FnMut(Self::Item) -> K,
    K: PartialOrd, [src]
Self: Sized,
F: FnMut(Self::Item) -> K,
K: PartialOrd,
impl<'_, T> TrustedLen for RChunksMut<'_, T>[src]
Auto Trait Implementations
impl<'a, T> Send for RChunksMut<'a, T> where
    T: Send, 
T: Send,
impl<'a, T> Sync for RChunksMut<'a, T> where
    T: Sync, 
T: Sync,
impl<'a, T> Unpin for RChunksMut<'a, T>
Blanket Implementations
impl<T> Any for T where
    T: 'static + ?Sized, [src]
T: 'static + ?Sized,
impl<T> Borrow<T> for T where
    T: ?Sized, [src]
T: ?Sized,
impl<T> BorrowMut<T> for T where
    T: ?Sized, [src]
T: ?Sized,
fn borrow_mut(&mut Self) -> &mut T[src]
impl<T> From<T> for T[src]
impl<T, U> Into<U> for T where
    U: From<T>, [src]
U: From<T>,
impl<T, U> TryFrom<U> for T where
    U: Into<T>, [src]
U: Into<T>,
type Error = Infallible
The type returned in the event of a conversion error.
fn try_from(U) -> Result<T, <T as TryFrom<U>>::Error>[src]
impl<T, U> TryInto<U> for T where
    U: TryFrom<T>, [src]
U: TryFrom<T>,