pub struct ChunksMut<'a, T> where 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.
impl<'a, T> Debug for ChunksMut<'a, T> where
T: 'a + Debug,
[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<<ChunksMut<'a, T> as Iterator>::Item>
[src]
fn try_rfold<B, F, R>(&mut self, init: B, f: F) -> R where
F: FnMut(B, Self::Item) -> R,
R: Try<Ok = B>,
[src]1.27.0
fn rfold<B, F>(self, init: B, f: F) -> B where
F: FnMut(B, Self::Item) -> B,
[src]1.27.0
fn rfind<P>(&mut self, predicate: P) -> Option<Self::Item> where
P: FnMut(&Self::Item) -> bool,
[src]1.27.0
impl<'_, T> ExactSizeIterator for ChunksMut<'_, T>
[src]
impl<'_, T> FusedIterator for ChunksMut<'_, T>
[src]1.26.0
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<<ChunksMut<'a, T> as Iterator>::Item>
[src]
fn step_by(self, step: usize) -> StepBy<Self>β
[src]1.28.0
fn chain<U>(self, other: U) -> Chain<Self, <U as IntoIterator>::IntoIter>β where
U: IntoIterator<Item = Self::Item>,
[src]
fn zip<U>(self, other: U) -> Zip<Self, <U as IntoIterator>::IntoIter>β where
U: IntoIterator,
[src]
fn map<B, F>(self, f: F) -> Map<Self, F>β where
F: FnMut(Self::Item) -> B,
[src]
fn for_each<F>(self, f: F) where
F: FnMut(Self::Item),
[src]1.21.0
fn filter<P>(self, predicate: P) -> Filter<Self, P>β where
P: FnMut(&Self::Item) -> bool,
[src]
fn filter_map<B, F>(self, f: F) -> FilterMap<Self, F>β where
F: FnMut(Self::Item) -> Option<B>,
[src]
fn enumerate(self) -> Enumerate<Self>β
[src]
fn peekable(self) -> Peekable<Self>β
[src]
fn skip_while<P>(self, predicate: P) -> SkipWhile<Self, P>β where
P: FnMut(&Self::Item) -> bool,
[src]
fn take_while<P>(self, predicate: P) -> TakeWhile<Self, P>β where
P: FnMut(&Self::Item) -> bool,
[src]
fn map_while<B, P>(self, predicate: P) -> MapWhile<Self, P>β where
P: FnMut(Self::Item) -> Option<B>,
[src]
fn skip(self, n: usize) -> Skip<Self>β
[src]
fn take(self, n: usize) -> Take<Self>β
[src]
fn scan<St, B, F>(self, initial_state: St, f: F) -> Scan<Self, St, F>β where
F: FnMut(&mut St, Self::Item) -> Option<B>,
[src]
fn flat_map<U, F>(self, f: F) -> FlatMap<Self, U, F>β where
F: FnMut(Self::Item) -> U,
U: IntoIterator,
[src]
fn flatten(self) -> Flatten<Self>β where
Self::Item: IntoIterator,
[src]1.29.0
fn fuse(self) -> Fuse<Self>β
[src]
fn inspect<F>(self, f: F) -> Inspect<Self, F>β where
F: FnMut(&Self::Item),
[src]
fn by_ref(&mut self) -> &mut SelfβNotable traits for &'_ mut F
impl<'_, F> Future for &'_ mut F where
F: Unpin + Future + ?Sized,
type Output = <F as Future>::Output;
impl<'_, I> Iterator for &'_ mut I where
I: Iterator + ?Sized,
type Item = <I as Iterator>::Item;
impl<R: Read + ?Sized, '_> Read for &'_ mut R
impl<W: Write + ?Sized, '_> Write for &'_ mut W
[src]
#[must_use =
"if you really need to exhaust the iterator, consider `.for_each(drop)` instead"]fn collect<B>(self) -> B where
B: FromIterator<Self::Item>,
[src]
fn partition<B, F>(self, f: F) -> (B, B) where
B: Default + Extend<Self::Item>,
F: FnMut(&Self::Item) -> bool,
[src]
fn partition_in_place<'a, T, P>(self, predicate: P) -> usize where
P: FnMut(&T) -> bool,
Self: DoubleEndedIterator<Item = &'a mut T>,
T: 'a,
[src]
fn is_partitioned<P>(self, predicate: P) -> bool where
P: FnMut(Self::Item) -> bool,
[src]
fn try_fold<B, F, R>(&mut self, init: B, f: F) -> R where
F: FnMut(B, Self::Item) -> R,
R: Try<Ok = B>,
[src]1.27.0
fn try_for_each<F, R>(&mut self, f: F) -> R where
F: FnMut(Self::Item) -> R,
R: Try<Ok = ()>,
[src]1.27.0
fn fold<B, F>(self, init: B, f: F) -> B where
F: FnMut(B, Self::Item) -> B,
[src]
fn fold_first<F>(self, f: F) -> Option<Self::Item> where
F: FnMut(Self::Item, Self::Item) -> Self::Item,
[src]
fn all<F>(&mut self, f: F) -> bool where
F: FnMut(Self::Item) -> bool,
[src]
fn any<F>(&mut self, f: F) -> bool where
F: FnMut(Self::Item) -> bool,
[src]
fn find<P>(&mut self, predicate: P) -> Option<Self::Item> where
P: FnMut(&Self::Item) -> bool,
[src]
fn find_map<B, F>(&mut self, f: F) -> Option<B> where
F: FnMut(Self::Item) -> Option<B>,
[src]1.30.0
fn try_find<F, R>(
&mut self,
f: F
) -> Result<Option<Self::Item>, <R as Try>::Error> where
F: FnMut(&Self::Item) -> R,
R: Try<Ok = bool>,
[src]
fn position<P>(&mut self, predicate: P) -> Option<usize> where
P: FnMut(Self::Item) -> bool,
[src]
fn rposition<P>(&mut self, predicate: P) -> Option<usize> where
P: FnMut(Self::Item) -> bool,
Self: ExactSizeIterator + DoubleEndedIterator,
[src]
fn max(self) -> Option<Self::Item> where
Self::Item: Ord,
[src]
fn min(self) -> Option<Self::Item> where
Self::Item: Ord,
[src]
fn max_by_key<B, F>(self, f: F) -> Option<Self::Item> where
B: Ord,
F: FnMut(&Self::Item) -> B,
[src]1.6.0
fn max_by<F>(self, compare: F) -> Option<Self::Item> where
F: FnMut(&Self::Item, &Self::Item) -> Ordering,
[src]1.15.0
fn min_by_key<B, F>(self, f: F) -> Option<Self::Item> where
B: Ord,
F: FnMut(&Self::Item) -> B,
[src]1.6.0
fn min_by<F>(self, compare: F) -> Option<Self::Item> where
F: FnMut(&Self::Item, &Self::Item) -> Ordering,
[src]1.15.0
fn rev(self) -> Rev<Self>β where
Self: DoubleEndedIterator,
[src]
fn unzip<A, B, FromA, FromB>(self) -> (FromA, FromB) where
FromA: Default + Extend<A>,
FromB: Default + Extend<B>,
Self: Iterator<Item = (A, B)>,
[src]
fn copied<'a, T>(self) -> Copied<Self>β where
Self: Iterator<Item = &'a T>,
T: 'a + Copy,
[src]1.36.0
fn cloned<'a, T>(self) -> Cloned<Self>β where
Self: Iterator<Item = &'a T>,
T: 'a + Clone,
[src]
fn cycle(self) -> Cycle<Self>β where
Self: Clone,
[src]
fn sum<S>(self) -> S where
S: Sum<Self::Item>,
[src]1.11.0
fn product<P>(self) -> P where
P: Product<Self::Item>,
[src]1.11.0
fn cmp<I>(self, other: I) -> Ordering where
I: IntoIterator<Item = Self::Item>,
Self::Item: Ord,
[src]1.5.0
fn cmp_by<I, F>(self, other: I, cmp: F) -> Ordering where
F: FnMut(Self::Item, <I as IntoIterator>::Item) -> Ordering,
I: IntoIterator,
[src]
fn partial_cmp<I>(self, other: I) -> Option<Ordering> where
I: IntoIterator,
Self::Item: PartialOrd<<I as IntoIterator>::Item>,
[src]1.5.0
fn partial_cmp_by<I, F>(self, other: I, partial_cmp: F) -> Option<Ordering> where
F: FnMut(Self::Item, <I as IntoIterator>::Item) -> Option<Ordering>,
I: IntoIterator,
[src]
fn eq<I>(self, other: I) -> bool where
I: IntoIterator,
Self::Item: PartialEq<<I as IntoIterator>::Item>,
[src]1.5.0
fn eq_by<I, F>(self, other: I, eq: F) -> bool where
F: FnMut(Self::Item, <I as IntoIterator>::Item) -> bool,
I: IntoIterator,
[src]
fn ne<I>(self, other: I) -> bool where
I: IntoIterator,
Self::Item: PartialEq<<I as IntoIterator>::Item>,
[src]1.5.0
fn lt<I>(self, other: I) -> bool where
I: IntoIterator,
Self::Item: PartialOrd<<I as IntoIterator>::Item>,
[src]1.5.0
fn le<I>(self, other: I) -> bool where
I: IntoIterator,
Self::Item: PartialOrd<<I as IntoIterator>::Item>,
[src]1.5.0
fn gt<I>(self, other: I) -> bool where
I: IntoIterator,
Self::Item: PartialOrd<<I as IntoIterator>::Item>,
[src]1.5.0
fn ge<I>(self, other: I) -> bool where
I: IntoIterator,
Self::Item: PartialOrd<<I as IntoIterator>::Item>,
[src]1.5.0
fn is_sorted(self) -> bool where
Self::Item: PartialOrd<Self::Item>,
[src]
fn is_sorted_by<F>(self, compare: F) -> bool where
F: FnMut(&Self::Item, &Self::Item) -> Option<Ordering>,
[src]
fn is_sorted_by_key<F, K>(self, f: F) -> bool where
F: FnMut(Self::Item) -> K,
K: PartialOrd<K>,
[src]
impl<'_, T> TrustedLen for ChunksMut<'_, T>
[src]
impl<'a, T> RefUnwindSafe for ChunksMut<'a, T> where
T: RefUnwindSafe,
impl<'a, T> Send for ChunksMut<'a, T> where
T: Send,
impl<'a, T> Sync for ChunksMut<'a, T> where
T: Sync,
impl<'a, T> Unpin for ChunksMut<'a, T>
impl<'a, T> !UnwindSafe for ChunksMut<'a, T>
impl<T> Any for T where
T: 'static + ?Sized,
[src]
impl<T> Borrow<T> for T where
T: ?Sized,
[src]
fn borrow(&self) -> &TβNotable traits for &'_ mut F
impl<'_, F> Future for &'_ mut F where
F: Unpin + Future + ?Sized,
type Output = <F as Future>::Output;
impl<'_, I> Iterator for &'_ mut I where
I: Iterator + ?Sized,
type Item = <I as Iterator>::Item;
impl<R: Read + ?Sized, '_> Read for &'_ mut R
impl<W: Write + ?Sized, '_> Write for &'_ mut W
[src]
impl<T> BorrowMut<T> for T where
T: ?Sized,
[src]
fn borrow_mut(&mut self) -> &mut TβNotable traits for &'_ mut F
impl<'_, F> Future for &'_ mut F where
F: Unpin + Future + ?Sized,
type Output = <F as Future>::Output;
impl<'_, I> Iterator for &'_ mut I where
I: Iterator + ?Sized,
type Item = <I as Iterator>::Item;
impl<R: Read + ?Sized, '_> Read for &'_ mut R
impl<W: Write + ?Sized, '_> Write for &'_ mut W
[src]
impl<T> From<T> for T
[src]
impl<T, U> Into<U> for T where
U: From<T>,
[src]
impl<I> IntoIterator for I where
I: Iterator,
[src]
type Item = <I as Iterator>::Item
The type of the elements being iterated over.
type IntoIter = I
Which kind of iterator are we turning this into?
fn into_iter(self) -> I
[src]
impl<T, U> TryFrom<U> for T where
U: Into<T>,
[src]
type Error = Infallible
The type returned in the event of a conversion error.
fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>
[src]
impl<T, U> TryInto<U> for T where
U: TryFrom<T>,
[src]
Β© 2010 The Rust Project Developers
Licensed under the Apache License, Version 2.0 or the MIT license, at your option.
https://doc.rust-lang.org/std/slice/struct.ChunksMut.html