Struct `Chunks`

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

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

Example

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

Implementations

`impl<'a, T> DoubleEndedIterator for Chunks<'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 Chunks<'a, T>`

`impl<'a, T> Iterator for Chunks<'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 Chunks<'a, T>`

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

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

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

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

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

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

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

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

fn into_iter(self: Self) -> I

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

fn type_id(self: &Self) -> TypeId

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

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

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

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

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

fn clone(self: &Self) -> Self

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

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

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

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

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

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

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

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

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

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

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