pub struct Chunks<'a, T> where T: 'a, { /* fields omitted */ }
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.
impl<'_, T> Clone for Chunks<'_, T>[src]
fn clone(&self) -> Chunks<'_, T>ⓘNotable traits for Chunks<'a, T>
impl<'a, T> Iterator for Chunks<'a, T>
type Item = &'a [T];
[src]
fn clone_from(&mut self, source: &Self)[src]
impl<'a, T> Debug for Chunks<'a, T> where
T: 'a + Debug, [src]
impl<'a, T> DoubleEndedIterator for Chunks<'a, T>[src]
fn next_back(&mut self) -> Option<&'a [T]>[src]
fn nth_back(&mut self, n: usize) -> Option<<Chunks<'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 Chunks<'_, T>[src]
impl<'_, T> FusedIterator for Chunks<'_, T>[src]1.26.0
impl<'a, T> Iterator for Chunks<'a, T>[src]
type Item = &'a [T]The type of the elements being iterated over.
fn next(&mut self) -> Option<&'a [T]>[src]
fn size_hint(&self) -> (usize, Option<usize>)[src]
fn count(self) -> usize[src]
fn nth(&mut self, n: usize) -> Option<<Chunks<'a, T> as Iterator>::Item>[src]
fn last(self) -> Option<<Chunks<'a, T> as Iterator>::Item>[src]
fn step_by(self, step: usize) -> StepBy<Self>ⓘNotable traits for StepBy<I>
impl<I> Iterator for StepBy<I> where
I: Iterator,
type Item = <I as Iterator>::Item;
[src]1.28.0
fn chain<U>(self, other: U) -> Chain<Self, <U as IntoIterator>::IntoIter>ⓘNotable traits for Chain<A, B>
impl<A, B> Iterator for Chain<A, B> where
A: Iterator,
B: Iterator<Item = <A as Iterator>::Item>,
type Item = <A as Iterator>::Item;
where
U: IntoIterator<Item = Self::Item>, [src]
fn zip<U>(self, other: U) -> Zip<Self, <U as IntoIterator>::IntoIter>ⓘNotable traits for Zip<A, B>
impl<A, B> Iterator for Zip<A, B> where
A: Iterator,
B: Iterator,
type Item = (<A as Iterator>::Item, <B as Iterator>::Item);
where
U: IntoIterator, [src]
fn map<B, F>(self, f: F) -> Map<Self, F>ⓘNotable traits for Map<I, F>
impl<B, I, F> Iterator for Map<I, F> where
F: FnMut(<I as Iterator>::Item) -> B,
I: Iterator,
type Item = B;
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>ⓘNotable traits for Filter<I, P>
impl<I, P> Iterator for Filter<I, P> where
I: Iterator,
P: FnMut(&<I as Iterator>::Item) -> bool,
type Item = <I as Iterator>::Item;
where
P: FnMut(&Self::Item) -> bool, [src]
fn filter_map<B, F>(self, f: F) -> FilterMap<Self, F>ⓘNotable traits for FilterMap<I, F>
impl<B, I, F> Iterator for FilterMap<I, F> where
F: FnMut(<I as Iterator>::Item) -> Option<B>,
I: Iterator,
type Item = B;
where
F: FnMut(Self::Item) -> Option<B>, [src]
fn enumerate(self) -> Enumerate<Self>ⓘNotable traits for Enumerate<I>
impl<I> Iterator for Enumerate<I> where
I: Iterator,
type Item = (usize, <I as Iterator>::Item);
[src]
fn peekable(self) -> Peekable<Self>ⓘNotable traits for Peekable<I>
impl<I> Iterator for Peekable<I> where
I: Iterator,
type Item = <I as Iterator>::Item;
[src]
fn skip_while<P>(self, predicate: P) -> SkipWhile<Self, P>ⓘNotable traits for SkipWhile<I, P>
impl<I, P> Iterator for SkipWhile<I, P> where
I: Iterator,
P: FnMut(&<I as Iterator>::Item) -> bool,
type Item = <I as Iterator>::Item;
where
P: FnMut(&Self::Item) -> bool, [src]
fn take_while<P>(self, predicate: P) -> TakeWhile<Self, P>ⓘNotable traits for TakeWhile<I, P>
impl<I, P> Iterator for TakeWhile<I, P> where
I: Iterator,
P: FnMut(&<I as Iterator>::Item) -> bool,
type Item = <I as Iterator>::Item;
where
P: FnMut(&Self::Item) -> bool, [src]
fn map_while<B, P>(self, predicate: P) -> MapWhile<Self, P>ⓘNotable traits for MapWhile<I, P>
impl<B, I, P> Iterator for MapWhile<I, P> where
I: Iterator,
P: FnMut(<I as Iterator>::Item) -> Option<B>,
type Item = B;
where
P: FnMut(Self::Item) -> Option<B>, [src]
fn skip(self, n: usize) -> Skip<Self>ⓘNotable traits for Skip<I>
impl<I> Iterator for Skip<I> where
I: Iterator,
type Item = <I as Iterator>::Item;
[src]
fn take(self, n: usize) -> Take<Self>ⓘNotable traits for Take<I>
impl<I> Iterator for Take<I> where
I: Iterator,
type Item = <I as Iterator>::Item;
[src]
fn scan<St, B, F>(self, initial_state: St, f: F) -> Scan<Self, St, F>ⓘNotable traits for Scan<I, St, F>
impl<B, I, St, F> Iterator for Scan<I, St, F> where
F: FnMut(&mut St, <I as Iterator>::Item) -> Option<B>,
I: Iterator,
type Item = B;
where
F: FnMut(&mut St, Self::Item) -> Option<B>, [src]
fn flat_map<U, F>(self, f: F) -> FlatMap<Self, U, F>ⓘNotable traits for FlatMap<I, U, F>
impl<I, U, F> Iterator for FlatMap<I, U, F> where
F: FnMut(<I as Iterator>::Item) -> U,
I: Iterator,
U: IntoIterator,
type Item = <U as IntoIterator>::Item;
where
F: FnMut(Self::Item) -> U,
U: IntoIterator, [src]
fn flatten(self) -> Flatten<Self>ⓘNotable traits for Flatten<I>
impl<I, U> Iterator for Flatten<I> where
I: Iterator,
U: Iterator,
<I as Iterator>::Item: IntoIterator,
<<I as Iterator>::Item as IntoIterator>::IntoIter == U,
<<I as Iterator>::Item as IntoIterator>::Item == <U as Iterator>::Item,
type Item = <U as Iterator>::Item;
where
Self::Item: IntoIterator, [src]1.29.0
fn fuse(self) -> Fuse<Self>ⓘNotable traits for Fuse<I>
impl<I> Iterator for Fuse<I> where
I: Iterator,
type Item = <I as Iterator>::Item;
[src]
fn inspect<F>(self, f: F) -> Inspect<Self, F>ⓘNotable traits for Inspect<I, F>
impl<I, F> Iterator for Inspect<I, F> where
F: FnMut(&<I as Iterator>::Item),
I: Iterator,
type Item = <I as Iterator>::Item;
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>ⓘNotable traits for Rev<I>
impl<I> Iterator for Rev<I> where
I: DoubleEndedIterator,
type Item = <I as Iterator>::Item;
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>ⓘNotable traits for Copied<I>
impl<'a, I, T> Iterator for Copied<I> where
I: Iterator<Item = &'a T>,
T: 'a + Copy,
type Item = T;
where
Self: Iterator<Item = &'a T>,
T: 'a + Copy, [src]1.36.0
fn cloned<'a, T>(self) -> Cloned<Self>ⓘNotable traits for Cloned<I>
impl<'a, I, T> Iterator for Cloned<I> where
I: Iterator<Item = &'a T>,
T: 'a + Clone,
type Item = T;
where
Self: Iterator<Item = &'a T>,
T: 'a + Clone, [src]
fn cycle(self) -> Cycle<Self>ⓘNotable traits for Cycle<I>
impl<I> Iterator for Cycle<I> where
I: Clone + Iterator,
type Item = <I as Iterator>::Item;
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 Chunks<'_, T>[src]
impl<'a, T> RefUnwindSafe for Chunks<'a, T> where
T: RefUnwindSafe, impl<'a, T> Send for Chunks<'a, T> where
T: Sync, impl<'a, T> Sync for Chunks<'a, T> where
T: Sync, impl<'a, T> Unpin for Chunks<'a, T>impl<'a, T> UnwindSafe for Chunks<'a, T> where
T: RefUnwindSafe, 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>::ItemThe type of the elements being iterated over.
type IntoIter = IWhich kind of iterator are we turning this into?
fn into_iter(self) -> I[src]
impl<T> ToOwned for T where
T: Clone, [src]
type Owned = TThe resulting type after obtaining ownership.
fn to_owned(&self) -> T[src]
fn clone_into(&self, target: &mut T)[src]
impl<T, U> TryFrom<U> for T where
U: Into<T>, [src]
type Error = InfallibleThe 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.Chunks.html