Struct `ChunksMut`

struct ChunksMut<'a, T: 'a> { ... }

An iterator over a slice in (non-overlapping) mutable chunks (chunk_size elements at a time), starting at the beginning 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 chunks_mut method on slices.

Example

let mut slice = ['l', 'o', 'r', 'e', 'm'];
let iter = slice.chunks_mut(2);

Implementations

`impl<'a, T> DoubleEndedIterator for ChunksMut<'a, T>`

fn next_back(self: &mut Self) -> Option<&'a mut [T]>
fn nth_back(self: &mut Self, n: usize) -> Option<<Self as >::Item>

`impl<'a, T> Freeze for ChunksMut<'a, T>`

`impl<'a, T> Iterator for ChunksMut<'a, T>`

fn next(self: &mut Self) -> Option<&'a mut [T]>
fn size_hint(self: &Self) -> (usize, Option<usize>)
fn count(self: Self) -> usize
fn nth(self: &mut Self, n: usize) -> Option<&'a mut [T]>
fn last(self: Self) -> Option<<Self as >::Item>

`impl<'a, T> RefUnwindSafe for ChunksMut<'a, T>`

`impl<'a, T> Unpin for ChunksMut<'a, T>`

`impl<'a, T> UnsafeUnpin for ChunksMut<'a, T>`

`impl<'a, T> UnwindSafe for ChunksMut<'a, T>`

`impl<'a, T: $crate::fmt::Debug + 'a> Debug for ChunksMut<'a, T>`

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

`impl<I> IntoIterator for ChunksMut<'a, T>`

fn into_iter(self: Self) -> I

`impl<T> Any for ChunksMut<'a, T>`

fn type_id(self: &Self) -> TypeId

`impl<T> Borrow for ChunksMut<'a, T>`

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

`impl<T> BorrowMut for ChunksMut<'a, T>`

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

`impl<T> ExactSizeIterator for ChunksMut<'_, T>`

`impl<T> From for ChunksMut<'a, T>`

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

`impl<T> FusedIterator for ChunksMut<'_, T>`

`impl<T> Send for ChunksMut<'_, T>`

`impl<T> Sync for ChunksMut<'_, T>`

`impl<T> TrustedLen for ChunksMut<'_, T>`

`impl<T, U> Into for ChunksMut<'a, T>`

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 ChunksMut<'a, T>`

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

`impl<T, U> TryInto for ChunksMut<'a, T>`

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