Struct array_tools::Chunks [−][src]
A consuming iterator over non-overlaping subarrays of equal size.
Consumes array upon creation and yields subarrays "chunks" of requested size.
If array can't be divided evenly into chunks, the last yielded item will be
a "stump" - an array of length input_array_length % chunk_size_length
,
containing what remains at the end.
If array can be divided evenly into "chunks", there will be no "stump".
Because this iterator deals with arrays of constant size, it does not expect chunk size argument, instead it expects four generic parameters:
- Element type.
- Consumed array type.
- Chunk array type.
- Stump array type.
Element type of consumed, chunk and stump array types must match.
Consumed array length could be anything, including zero.
Chunk array length must be non-zero.
In case input array can't be divided evenly into chunks, stump array length
must be consumed_array_length % chunk_array_length
.
In case input array can be divided evenly, stump array length must be 0.
Does not perform any cloning operations, only moves values.
Examples
Case without "stump".
use array_tools::{Chunk, Chunks}; use core::marker::PhantomData; let array = [1u64, 2, 3, 4, 5, 6, 7, 8]; // Divide array `[u64; 8]` into `[u64; 2]` chunks. It can be divided evenly, // so there will be no stump. let mut chunks: Chunks<u64, [u64; 8], [u64; 2], [u64; 0]> = Chunks::new(array); assert_eq!(chunks.next(), Some(Chunk::Chunk([1u64, 2], PhantomData))); assert_eq!(chunks.next(), Some(Chunk::Chunk([3u64, 4], PhantomData))); assert_eq!(chunks.next(), Some(Chunk::Chunk([5u64, 6], PhantomData))); assert_eq!(chunks.next(), Some(Chunk::Chunk([7u64, 8], PhantomData))); assert_eq!(chunks.next(), None);
Case with "stump".
use array_tools::{Chunk, Chunks}; use core::marker::PhantomData; let array = [1u64, 2, 3, 4, 5, 6, 7, 8]; // Divide array `[u64; 8]` into `[u64; 3]` chunks. It can't be divided evenly, so last item // will be stump of type `[u64; 2]`. let mut chunks: Chunks<u64, [u64; 8], [u64; 3], [u64; 2]> = Chunks::new(array); assert_eq!(chunks.next(), Some(Chunk::Chunk([1u64, 2, 3], PhantomData))); assert_eq!(chunks.next(), Some(Chunk::Chunk([4u64, 5, 6], PhantomData))); assert_eq!(chunks.next(), Some(Chunk::Stump([7u64, 8], PhantomData))); assert_eq!(chunks.next(), None);
Actually, most generic parameters may be ommited:
use array_tools::Chunks; let array = [1, 2, 3, 4, 5, 6, 7, 8]; let _chunks: Chunks<_, _, [_; 3], [_; 2]> = Chunks::new(array);
Implementations
impl<T, A, C, S> Chunks<T, A, C, S> where
A: FixedSizeArray<T>,
C: FixedSizeArray<T>,
S: FixedSizeArray<T>,
[src]
A: FixedSizeArray<T>,
C: FixedSizeArray<T>,
S: FixedSizeArray<T>,
pub fn new(array: A) -> Chunks<T, A, C, S>ⓘNotable traits for Chunks<T, A, C, S>
impl<T, A, C, S> Iterator for Chunks<T, A, C, S> where
A: FixedSizeArray<T>,
C: FixedSizeArray<T>,
S: FixedSizeArray<T>, type Item = Chunk<T, C, S>;
[src]
Notable traits for Chunks<T, A, C, S>
impl<T, A, C, S> Iterator for Chunks<T, A, C, S> where
A: FixedSizeArray<T>,
C: FixedSizeArray<T>,
S: FixedSizeArray<T>, type Item = Chunk<T, C, S>;
Creates a new instance of Chunks
iterator.
Panics
- If chunk size is 0.
- If stump size is not equal to
consumed_array_length % chunk_array_length
.
Note
Though currently this function panics if chunk size is 0 and/or stump size is not valid, this behavior will be changed to perform these checks at compile time, when this will become possible.
Trait Implementations
impl<T, A, C, S> Clone for Chunks<T, A, C, S> where
A: FixedSizeArray<T>,
C: FixedSizeArray<T>,
S: FixedSizeArray<T>,
T: Clone,
[src]
A: FixedSizeArray<T>,
C: FixedSizeArray<T>,
S: FixedSizeArray<T>,
T: Clone,
fn clone(&self) -> Self
[src]
pub fn clone_from(&mut self, source: &Self)
1.0.0[src]
impl<T, A, C, S> Debug for Chunks<T, A, C, S> where
A: FixedSizeArray<T>,
C: FixedSizeArray<T>,
S: FixedSizeArray<T>,
T: Debug,
[src]
A: FixedSizeArray<T>,
C: FixedSizeArray<T>,
S: FixedSizeArray<T>,
T: Debug,
impl<T, A, C, S> DoubleEndedIterator for Chunks<T, A, C, S> where
A: FixedSizeArray<T>,
C: FixedSizeArray<T>,
S: FixedSizeArray<T>,
[src]
A: FixedSizeArray<T>,
C: FixedSizeArray<T>,
S: FixedSizeArray<T>,
fn next_back(&mut self) -> Option<Self::Item>
[src]
pub fn advance_back_by(&mut self, n: usize) -> Result<(), usize>
[src]
pub fn nth_back(&mut self, n: usize) -> Option<Self::Item>
1.37.0[src]
pub fn try_rfold<B, F, R>(&mut self, init: B, f: F) -> R where
F: FnMut(B, Self::Item) -> R,
R: Try<Ok = B>,
1.27.0[src]
F: FnMut(B, Self::Item) -> R,
R: Try<Ok = B>,
pub fn rfold<B, F>(self, init: B, f: F) -> B where
F: FnMut(B, Self::Item) -> B,
1.27.0[src]
F: FnMut(B, Self::Item) -> B,
pub fn rfind<P>(&mut self, predicate: P) -> Option<Self::Item> where
P: FnMut(&Self::Item) -> bool,
1.27.0[src]
P: FnMut(&Self::Item) -> bool,
impl<T, A, C, S> Eq for Chunks<T, A, C, S> where
A: FixedSizeArray<T>,
C: FixedSizeArray<T>,
S: FixedSizeArray<T>,
T: Eq,
[src]
A: FixedSizeArray<T>,
C: FixedSizeArray<T>,
S: FixedSizeArray<T>,
T: Eq,
impl<T, A, C, S> Iterator for Chunks<T, A, C, S> where
A: FixedSizeArray<T>,
C: FixedSizeArray<T>,
S: FixedSizeArray<T>,
[src]
A: FixedSizeArray<T>,
C: FixedSizeArray<T>,
S: FixedSizeArray<T>,
type Item = Chunk<T, C, S>
The type of the elements being iterated over.
fn next(&mut self) -> Option<Self::Item>
[src]
fn size_hint(&self) -> (usize, Option<usize>)
[src]
fn count(self) -> usize
[src]
fn last(self) -> Option<Self::Item>
[src]
fn nth(&mut self, nth: usize) -> Option<Self::Item>
[src]
pub fn advance_by(&mut self, n: usize) -> Result<(), usize>
[src]
pub fn step_by(self, step: usize) -> StepBy<Self>
1.28.0[src]
pub fn chain<U>(self, other: U) -> Chain<Self, <U as IntoIterator>::IntoIter> where
U: IntoIterator<Item = Self::Item>,
1.0.0[src]
U: IntoIterator<Item = Self::Item>,
pub fn zip<U>(self, other: U) -> Zip<Self, <U as IntoIterator>::IntoIter> where
U: IntoIterator,
1.0.0[src]
U: IntoIterator,
pub fn intersperse(self, separator: Self::Item) -> Intersperse<Self> where
Self::Item: Clone,
[src]
Self::Item: Clone,
pub fn intersperse_with<G>(self, separator: G) -> IntersperseWith<Self, G> where
G: FnMut() -> Self::Item,
[src]
G: FnMut() -> Self::Item,
pub fn map<B, F>(self, f: F) -> Map<Self, F> where
F: FnMut(Self::Item) -> B,
1.0.0[src]
F: FnMut(Self::Item) -> B,
pub fn for_each<F>(self, f: F) where
F: FnMut(Self::Item),
1.21.0[src]
F: FnMut(Self::Item),
pub fn filter<P>(self, predicate: P) -> Filter<Self, P> where
P: FnMut(&Self::Item) -> bool,
1.0.0[src]
P: FnMut(&Self::Item) -> bool,
pub fn filter_map<B, F>(self, f: F) -> FilterMap<Self, F> where
F: FnMut(Self::Item) -> Option<B>,
1.0.0[src]
F: FnMut(Self::Item) -> Option<B>,
pub fn enumerate(self) -> Enumerate<Self>
1.0.0[src]
pub fn peekable(self) -> Peekable<Self>
1.0.0[src]
pub fn skip_while<P>(self, predicate: P) -> SkipWhile<Self, P> where
P: FnMut(&Self::Item) -> bool,
1.0.0[src]
P: FnMut(&Self::Item) -> bool,
pub fn take_while<P>(self, predicate: P) -> TakeWhile<Self, P> where
P: FnMut(&Self::Item) -> bool,
1.0.0[src]
P: FnMut(&Self::Item) -> bool,
pub fn map_while<B, P>(self, predicate: P) -> MapWhile<Self, P> where
P: FnMut(Self::Item) -> Option<B>,
[src]
P: FnMut(Self::Item) -> Option<B>,
pub fn skip(self, n: usize) -> Skip<Self>
1.0.0[src]
pub fn take(self, n: usize) -> Take<Self>
1.0.0[src]
pub fn scan<St, B, F>(self, initial_state: St, f: F) -> Scan<Self, St, F> where
F: FnMut(&mut St, Self::Item) -> Option<B>,
1.0.0[src]
F: FnMut(&mut St, Self::Item) -> Option<B>,
pub fn flat_map<U, F>(self, f: F) -> FlatMap<Self, U, F> where
F: FnMut(Self::Item) -> U,
U: IntoIterator,
1.0.0[src]
F: FnMut(Self::Item) -> U,
U: IntoIterator,
pub fn flatten(self) -> Flatten<Self> where
Self::Item: IntoIterator,
1.29.0[src]
Self::Item: IntoIterator,
pub fn fuse(self) -> Fuse<Self>
1.0.0[src]
pub fn inspect<F>(self, f: F) -> Inspect<Self, F> where
F: FnMut(&Self::Item),
1.0.0[src]
F: FnMut(&Self::Item),
pub fn by_ref(&mut self) -> &mut Self
1.0.0[src]
#[must_use =
"if you really need to exhaust the iterator, consider `.for_each(drop)` instead"]pub fn collect<B>(self) -> B where
B: FromIterator<Self::Item>,
1.0.0[src]
B: FromIterator<Self::Item>,
pub fn partition<B, F>(self, f: F) -> (B, B) where
F: FnMut(&Self::Item) -> bool,
B: Default + Extend<Self::Item>,
1.0.0[src]
F: FnMut(&Self::Item) -> bool,
B: Default + Extend<Self::Item>,
pub fn partition_in_place<'a, T, P>(self, predicate: P) -> usize where
Self: DoubleEndedIterator<Item = &'a mut T>,
T: 'a,
P: FnMut(&T) -> bool,
[src]
Self: DoubleEndedIterator<Item = &'a mut T>,
T: 'a,
P: FnMut(&T) -> bool,
pub fn is_partitioned<P>(self, predicate: P) -> bool where
P: FnMut(Self::Item) -> bool,
[src]
P: FnMut(Self::Item) -> bool,
pub fn try_fold<B, F, R>(&mut self, init: B, f: F) -> R where
F: FnMut(B, Self::Item) -> R,
R: Try<Ok = B>,
1.27.0[src]
F: FnMut(B, Self::Item) -> R,
R: Try<Ok = B>,
pub fn try_for_each<F, R>(&mut self, f: F) -> R where
F: FnMut(Self::Item) -> R,
R: Try<Ok = ()>,
1.27.0[src]
F: FnMut(Self::Item) -> R,
R: Try<Ok = ()>,
pub fn fold<B, F>(self, init: B, f: F) -> B where
F: FnMut(B, Self::Item) -> B,
1.0.0[src]
F: FnMut(B, Self::Item) -> B,
pub fn reduce<F>(self, f: F) -> Option<Self::Item> where
F: FnMut(Self::Item, Self::Item) -> Self::Item,
1.51.0[src]
F: FnMut(Self::Item, Self::Item) -> Self::Item,
pub fn all<F>(&mut self, f: F) -> bool where
F: FnMut(Self::Item) -> bool,
1.0.0[src]
F: FnMut(Self::Item) -> bool,
pub fn any<F>(&mut self, f: F) -> bool where
F: FnMut(Self::Item) -> bool,
1.0.0[src]
F: FnMut(Self::Item) -> bool,
pub fn find<P>(&mut self, predicate: P) -> Option<Self::Item> where
P: FnMut(&Self::Item) -> bool,
1.0.0[src]
P: FnMut(&Self::Item) -> bool,
pub fn find_map<B, F>(&mut self, f: F) -> Option<B> where
F: FnMut(Self::Item) -> Option<B>,
1.30.0[src]
F: FnMut(Self::Item) -> Option<B>,
pub 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]
&mut self,
f: F
) -> Result<Option<Self::Item>, <R as Try>::Error> where
F: FnMut(&Self::Item) -> R,
R: Try<Ok = bool>,
pub fn position<P>(&mut self, predicate: P) -> Option<usize> where
P: FnMut(Self::Item) -> bool,
1.0.0[src]
P: FnMut(Self::Item) -> bool,
pub fn rposition<P>(&mut self, predicate: P) -> Option<usize> where
Self: ExactSizeIterator + DoubleEndedIterator,
P: FnMut(Self::Item) -> bool,
1.0.0[src]
Self: ExactSizeIterator + DoubleEndedIterator,
P: FnMut(Self::Item) -> bool,
pub fn max(self) -> Option<Self::Item> where
Self::Item: Ord,
1.0.0[src]
Self::Item: Ord,
pub fn min(self) -> Option<Self::Item> where
Self::Item: Ord,
1.0.0[src]
Self::Item: Ord,
pub fn max_by_key<B, F>(self, f: F) -> Option<Self::Item> where
F: FnMut(&Self::Item) -> B,
B: Ord,
1.6.0[src]
F: FnMut(&Self::Item) -> B,
B: Ord,
pub fn max_by<F>(self, compare: F) -> Option<Self::Item> where
F: FnMut(&Self::Item, &Self::Item) -> Ordering,
1.15.0[src]
F: FnMut(&Self::Item, &Self::Item) -> Ordering,
pub fn min_by_key<B, F>(self, f: F) -> Option<Self::Item> where
F: FnMut(&Self::Item) -> B,
B: Ord,
1.6.0[src]
F: FnMut(&Self::Item) -> B,
B: Ord,
pub fn min_by<F>(self, compare: F) -> Option<Self::Item> where
F: FnMut(&Self::Item, &Self::Item) -> Ordering,
1.15.0[src]
F: FnMut(&Self::Item, &Self::Item) -> Ordering,
pub fn rev(self) -> Rev<Self> where
Self: DoubleEndedIterator,
1.0.0[src]
Self: DoubleEndedIterator,
pub fn unzip<A, B, FromA, FromB>(self) -> (FromA, FromB) where
Self: Iterator<Item = (A, B)>,
FromA: Default + Extend<A>,
FromB: Default + Extend<B>,
1.0.0[src]
Self: Iterator<Item = (A, B)>,
FromA: Default + Extend<A>,
FromB: Default + Extend<B>,
pub fn copied<'a, T>(self) -> Copied<Self> where
Self: Iterator<Item = &'a T>,
T: 'a + Copy,
1.36.0[src]
Self: Iterator<Item = &'a T>,
T: 'a + Copy,
pub fn cloned<'a, T>(self) -> Cloned<Self> where
Self: Iterator<Item = &'a T>,
T: 'a + Clone,
1.0.0[src]
Self: Iterator<Item = &'a T>,
T: 'a + Clone,
pub fn cycle(self) -> Cycle<Self> where
Self: Clone,
1.0.0[src]
Self: Clone,
pub fn sum<S>(self) -> S where
S: Sum<Self::Item>,
1.11.0[src]
S: Sum<Self::Item>,
pub fn product<P>(self) -> P where
P: Product<Self::Item>,
1.11.0[src]
P: Product<Self::Item>,
pub fn cmp<I>(self, other: I) -> Ordering where
I: IntoIterator<Item = Self::Item>,
Self::Item: Ord,
1.5.0[src]
I: IntoIterator<Item = Self::Item>,
Self::Item: Ord,
pub fn cmp_by<I, F>(self, other: I, cmp: F) -> Ordering where
I: IntoIterator,
F: FnMut(Self::Item, <I as IntoIterator>::Item) -> Ordering,
[src]
I: IntoIterator,
F: FnMut(Self::Item, <I as IntoIterator>::Item) -> Ordering,
pub fn partial_cmp<I>(self, other: I) -> Option<Ordering> where
I: IntoIterator,
Self::Item: PartialOrd<<I as IntoIterator>::Item>,
1.5.0[src]
I: IntoIterator,
Self::Item: PartialOrd<<I as IntoIterator>::Item>,
pub fn partial_cmp_by<I, F>(self, other: I, partial_cmp: F) -> Option<Ordering> where
I: IntoIterator,
F: FnMut(Self::Item, <I as IntoIterator>::Item) -> Option<Ordering>,
[src]
I: IntoIterator,
F: FnMut(Self::Item, <I as IntoIterator>::Item) -> Option<Ordering>,
pub fn eq<I>(self, other: I) -> bool where
I: IntoIterator,
Self::Item: PartialEq<<I as IntoIterator>::Item>,
1.5.0[src]
I: IntoIterator,
Self::Item: PartialEq<<I as IntoIterator>::Item>,
pub fn eq_by<I, F>(self, other: I, eq: F) -> bool where
I: IntoIterator,
F: FnMut(Self::Item, <I as IntoIterator>::Item) -> bool,
[src]
I: IntoIterator,
F: FnMut(Self::Item, <I as IntoIterator>::Item) -> bool,
pub fn ne<I>(self, other: I) -> bool where
I: IntoIterator,
Self::Item: PartialEq<<I as IntoIterator>::Item>,
1.5.0[src]
I: IntoIterator,
Self::Item: PartialEq<<I as IntoIterator>::Item>,
pub fn lt<I>(self, other: I) -> bool where
I: IntoIterator,
Self::Item: PartialOrd<<I as IntoIterator>::Item>,
1.5.0[src]
I: IntoIterator,
Self::Item: PartialOrd<<I as IntoIterator>::Item>,
pub fn le<I>(self, other: I) -> bool where
I: IntoIterator,
Self::Item: PartialOrd<<I as IntoIterator>::Item>,
1.5.0[src]
I: IntoIterator,
Self::Item: PartialOrd<<I as IntoIterator>::Item>,
pub fn gt<I>(self, other: I) -> bool where
I: IntoIterator,
Self::Item: PartialOrd<<I as IntoIterator>::Item>,
1.5.0[src]
I: IntoIterator,
Self::Item: PartialOrd<<I as IntoIterator>::Item>,
pub fn ge<I>(self, other: I) -> bool where
I: IntoIterator,
Self::Item: PartialOrd<<I as IntoIterator>::Item>,
1.5.0[src]
I: IntoIterator,
Self::Item: PartialOrd<<I as IntoIterator>::Item>,
pub fn is_sorted(self) -> bool where
Self::Item: PartialOrd<Self::Item>,
[src]
Self::Item: PartialOrd<Self::Item>,
pub fn is_sorted_by<F>(self, compare: F) -> bool where
F: FnMut(&Self::Item, &Self::Item) -> Option<Ordering>,
[src]
F: FnMut(&Self::Item, &Self::Item) -> Option<Ordering>,
pub fn is_sorted_by_key<F, K>(self, f: F) -> bool where
F: FnMut(Self::Item) -> K,
K: PartialOrd<K>,
[src]
F: FnMut(Self::Item) -> K,
K: PartialOrd<K>,
impl<T, A, C, S> PartialEq<Chunks<T, A, C, S>> for Chunks<T, A, C, S> where
A: FixedSizeArray<T>,
C: FixedSizeArray<T>,
S: FixedSizeArray<T>,
T: PartialEq,
[src]
A: FixedSizeArray<T>,
C: FixedSizeArray<T>,
S: FixedSizeArray<T>,
T: PartialEq,
Auto Trait Implementations
impl<T, A, C, S> Send for Chunks<T, A, C, S> where
A: Send,
C: Send,
S: Send,
T: Send,
A: Send,
C: Send,
S: Send,
T: Send,
impl<T, A, C, S> Sync for Chunks<T, A, C, S> where
A: Sync,
C: Sync,
S: Sync,
T: Sync,
A: Sync,
C: Sync,
S: Sync,
T: Sync,
impl<T, A, C, S> Unpin for Chunks<T, A, C, S> where
A: Unpin,
C: Unpin,
S: Unpin,
T: Unpin,
A: Unpin,
C: Unpin,
S: Unpin,
T: Unpin,
Blanket Implementations
impl<T> Any for T where
T: 'static + ?Sized,
[src]
T: 'static + ?Sized,
impl<T> Borrow<T> for T where
T: ?Sized,
[src]
T: ?Sized,
impl<T> BorrowMut<T> for T where
T: ?Sized,
[src]
T: ?Sized,
pub fn borrow_mut(&mut self) -> &mut T
[src]
impl<T> From<T> for T
[src]
impl<T, U> Into<U> for T where
U: From<T>,
[src]
U: From<T>,
impl<I> IntoIterator for I where
I: Iterator,
[src]
I: Iterator,
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?
pub fn into_iter(self) -> I
[src]
impl<T, U> TryFrom<U> for T where
U: Into<T>,
[src]
U: Into<T>,
type Error = Infallible
The type returned in the event of a conversion error.
pub 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]
U: TryFrom<T>,