Struct `RChunks`

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

An iterator over a slice in (non-overlapping) 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 method on slices.

Example

let slice = ['l', 'o', 'r', 'e', 'm'];
let mut iter = slice.rchunks(2);
assert_eq!(iter.next(), Some(&['e', 'm'][..]));
assert_eq!(iter.next(), Some(&['o', 'r'][..]));
assert_eq!(iter.next(), Some(&['l'][..]));
assert_eq!(iter.next(), None);

Implementations

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

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

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

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

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

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

`impl<'a, T> Send for RChunks<'a, T>`

`impl<'a, T> Sync for RChunks<'a, T>`

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

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

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

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

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

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

fn into_iter(self: Self) -> I

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

fn type_id(self: &Self) -> TypeId

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

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

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

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

`impl<T> Clone for RChunks<'_, T>`

fn clone(self: &Self) -> Self

`impl<T> CloneToUninit for RChunks<'a, T>`

unsafe fn clone_to_uninit(self: &Self, dest: *mut u8)

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

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

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

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

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

`impl<T, U> Into for RChunks<'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 RChunks<'a, T>`

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

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

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