Struct core::slice::ChunksMut 1.0.0[−][src]
pub struct ChunksMut<'a, T: 'a> { /* fields omitted */ }
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);Run
Trait Implementations
impl<'a, T> DoubleEndedIterator for ChunksMut<'a, T>
[src]
impl<'a, T> DoubleEndedIterator for ChunksMut<'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 advance_back_by(&mut self, n: usize) -> Result<(), usize>
[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, init: 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 ChunksMut<'_, T>
[src]
impl<T> ExactSizeIterator for ChunksMut<'_, T>
[src]impl<'a, T> Iterator for ChunksMut<'a, T>
[src]
impl<'a, T> Iterator for ChunksMut<'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 advance_by(&mut self, n: usize) -> Result<(), usize>
[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>,
[src]
Self: Sized,
U: IntoIterator<Item = Self::Item>,
fn zip<U>(self, other: U) -> Zip<Self, U::IntoIter>ⓘ where
Self: Sized,
U: IntoIterator,
[src]
Self: Sized,
U: IntoIterator,
fn intersperse(self, separator: Self::Item) -> Intersperse<Self>ⓘNotable traits for Intersperse<I>
impl<I> Iterator for Intersperse<I> where
I: Iterator,
I::Item: Clone, type Item = I::Item;
where
Self: Sized,
Self::Item: Clone,
[src]
Notable traits for Intersperse<I>
impl<I> Iterator for Intersperse<I> where
I: Iterator,
I::Item: Clone, type Item = I::Item;
Self: Sized,
Self::Item: Clone,
fn intersperse_with<G>(self, separator: G) -> IntersperseWith<Self, G>ⓘNotable traits for IntersperseWith<I, G>
impl<I, G> Iterator for IntersperseWith<I, G> where
I: Iterator,
G: FnMut() -> I::Item, type Item = I::Item;
where
Self: Sized,
G: FnMut() -> Self::Item,
[src]
Notable traits for IntersperseWith<I, G>
impl<I, G> Iterator for IntersperseWith<I, G> where
I: Iterator,
G: FnMut() -> I::Item, type Item = I::Item;
Self: Sized,
G: FnMut() -> Self::Item,
fn map<B, F>(self, f: F) -> Map<Self, F>ⓘ where
Self: Sized,
F: FnMut(Self::Item) -> B,
[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,
[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>,
[src]
Self: Sized,
F: FnMut(Self::Item) -> Option<B>,
fn enumerate(self) -> Enumerate<Self>ⓘ where
Self: Sized,
[src]
Self: Sized,
fn peekable(self) -> Peekable<Self>ⓘ where
Self: Sized,
[src]
Self: Sized,
fn skip_while<P>(self, predicate: P) -> SkipWhile<Self, P>ⓘ where
Self: Sized,
P: FnMut(&Self::Item) -> bool,
[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,
[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,
[src]
Self: Sized,
fn take(self, n: usize) -> Take<Self>ⓘ where
Self: Sized,
[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>,
[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,
[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,
[src]
Self: Sized,
fn inspect<F>(self, f: F) -> Inspect<Self, F>ⓘ where
Self: Sized,
F: FnMut(&Self::Item),
[src]
Self: Sized,
F: FnMut(&Self::Item),
fn by_ref(&mut self) -> &mut Self where
Self: Sized,
[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,
[src]
#[must_use = "if you really need to exhaust the iterator, consider `.for_each(drop)` instead"]
fn collect<B: FromIterator<Self::Item>>(self) -> B whereSelf: Sized,
fn partition<B, F>(self, f: F) -> (B, B) where
Self: Sized,
B: Default + Extend<Self::Item>,
F: FnMut(&Self::Item) -> bool,
[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,
[src]
Self: Sized,
F: FnMut(B, Self::Item) -> B,
fn reduce<F>(self, f: F) -> Option<Self::Item> where
Self: Sized,
F: FnMut(Self::Item, Self::Item) -> Self::Item,
1.51.0[src]
Self: Sized,
F: FnMut(Self::Item, Self::Item) -> Self::Item,
fn all<F>(&mut self, f: F) -> bool where
Self: Sized,
F: FnMut(Self::Item) -> bool,
[src]
Self: Sized,
F: FnMut(Self::Item) -> bool,
fn any<F>(&mut self, f: F) -> bool where
Self: Sized,
F: FnMut(Self::Item) -> bool,
[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,
[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, R>(&mut self, f: F) -> Result<Option<Self::Item>, R::Error> where
Self: Sized,
F: FnMut(&Self::Item) -> R,
R: Try<Ok = bool>,
[src]
Self: Sized,
F: FnMut(&Self::Item) -> R,
R: Try<Ok = bool>,
fn position<P>(&mut self, predicate: P) -> Option<usize> where
Self: Sized,
P: FnMut(Self::Item) -> bool,
[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,
[src]
P: FnMut(Self::Item) -> bool,
Self: Sized + ExactSizeIterator + DoubleEndedIterator,
fn max(self) -> Option<Self::Item> where
Self: Sized,
Self::Item: Ord,
[src]
Self: Sized,
Self::Item: Ord,
fn min(self) -> Option<Self::Item> where
Self: Sized,
Self::Item: Ord,
[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,
[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)>,
[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,
[src]
Self: Sized + Iterator<Item = &'a T>,
T: Clone,
fn cycle(self) -> Cycle<Self>ⓘ where
Self: Sized + Clone,
[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> FusedIterator for ChunksMut<'_, T>
1.26.0[src]
impl<T> TrustedLen for ChunksMut<'_, T>
[src]
Auto Trait Implementations
impl<'a, T> Send for ChunksMut<'a, T> where
T: Send,
T: Send,
impl<'a, T> Sync for ChunksMut<'a, T> where
T: Sync,
T: Sync,