Struct StepBy 

pub struct StepBy<T, N = [()]>
where
    T: Bulk,
    N: Length<Elem = ()> + ?Sized,
{ /* private fields */ }

A bulk that steps by a custom amount.

This struct is created by the step_by method on Bulk. See its documentation for more.

Trait Implementations

impl<T, N> Bulk for StepBy<T, N>

where T: Bulk<Item>, N: Length<Elem = ()> + ?Sized,

type MinLength = <<T as Bulk>::MinLength as Length>::DivCeil<N>

type MaxLength = <<T as Bulk>::MaxLength as Length>::DivCeil<N>

fn len(&self) -> usize

Returns the exact length of the bulk.

fn for_each<F>(self, f: F)

where Self: Sized, F: FnMut(Self::Item),

Calls a closure on each element of a bulk.

fn try_for_each<F, R>(self, f: F) -> R

where Self: Sized, F: FnMut(Self::Item) -> R, R: Try<Output = (), Residual>,

A bulk method that applies a fallible function to each item in the bulk, stopping at the first error and returning that error.

type Length = Self::Length

fn length(&self) -> Value<Self::Length>

fn is_empty(&self) -> bool

Returns true if the iterator is empty.

fn first(self) -> Option<Self::Item>

where Self::Item:, Self: Sized,

Returns the first value, and discards the rest of the bulk.

fn last(self) -> Option<Self::Item>

where Self::Item:, Self: Sized,

Returns the last value, and discards the rest of the bulk.

fn nth<L>(self, n: L) -> Option<Self::Item>

where Self: Sized, Self::Item:, L: LengthValue,

Returns the n-th value, and discards the rest of the bulk.

fn many<NN, const N: usize>(self, n: NN) -> [Option<Self::Item>; N]

where Self: Sized, Self::Item:, NN: IntoBulk<Item = usize, IntoBulk: Bulk + StaticBulk<Array<()> = [(); N]>>,

fn fold<B, F>(self, init: B, f: F) -> B

where Self: Sized, B:, F: FnMut(B, Self::Item) -> B,

Folds every element into an accumulator by applying an operation, returning the final result.

fn try_fold<B, F, R>(self, init: B, f: F) -> R

where B:, Self: Sized, Self::Item:, F: FnMut(B, Self::Item) -> R, R: Try<Output = B, Residual>,

fn reduce<F>(self, f: F) -> Option<Self::Item>

where Self: Sized, Self::Item:, F: FnMut(Self::Item, Self::Item) -> Self::Item,

fn try_reduce<F, R>( self, f: F, ) -> <R::Residual as Residual<Option<R::Output>>>::TryType

where Self: Sized, Self::Item:, F: FnMut(Self::Item, Self::Item) -> R, R: Try<Output = Self::Item, Residual: Residual<Option<Self::Item>, TryType: Try>>,

fn step_by<L>(self, step: L) -> StepBy<Self, L::Length<()>>

where Self: Sized, L: LengthValue,

Creates a bulk starting at the same point, but stepping by the given amount at each iteration.

fn chain<U>(self, other: U) -> Chain<Self, U::IntoBulk>

where Self: Sized, U: IntoBulk<Item = Self::Item>,

Takes two bulks and creates a new bulk over both in sequence.

fn zip<U>( self, other: U, ) -> Zip<Self, <<U as IntoContained>::IntoContained as IntoBulk>::IntoBulk>

where Self: Sized, U: IntoContainedBy<Self>,

‘Zips up’ two bulks or iterators into a single bulk of pairs. One of them must be a bulk.

fn intersperse(self, separator: Self::Item) -> Intersperse<Self>

where Self: Sized, Self::Item: Clone,

Creates a new bulk which places a copy of separator between adjacent items of the original bulk.

fn intersperse_with<G>(self, separator: G) -> IntersperseWith<Self, G>

where Self: Sized, G: FnMut() -> Self::Item,

Creates a new bulk which places an item generated by separator between adjacent items of the original bulk.

fn map<B, F>(self, f: F) -> Map<Self, F>

where Self: Sized, F: FnMut(Self::Item) -> B,

Takes a closure and creates a bulk which calls that closure on each element.

fn enumerate(self) -> Enumerate<Self>

where Self: Sized,

Creates a bulk which gives the current index together with its values.

fn enumerate_from<U>(self, initial_count: U) -> EnumerateFrom<Self, U>

where Self: Sized, U: Step + Copy,

Creates a bulk which gives the current index counting from a given initial index together with its values.

fn skip<L>(self, n: L) -> Skip<Self, L::Length<()>>

where Self: Sized, L: LengthValue,

Creates a bulk that skips the first n elements.

fn take<L>(self, n: L) -> Take<Self, L::Length<()>>

where Self: Sized, L: LengthValue,

Creates a bulk for the first n elements, or fewer if the underlying bulk/iterator is shorter.

fn flat_map<U, F>(self, f: F) -> FlatMap<Self, F>

where Self: Sized, U: IntoBulk<IntoBulk: StaticBulk>, F: FnMut(Self::Item) -> U,

Creates a bulk that works like map, but flattens nested structure.

fn flatten(self) -> Flatten<Self>

where Self: Sized, Self::Item: IntoBulk<IntoBulk: StaticBulk>,

Creates a bulk that flattens nested structure.

fn map_windows<F, R, const N: usize>(self, f: F) -> MapWindows<Self, F, N>

where Self: Sized, F: FnMut(&[Self::Item; N]) -> R,

Calls the given function f for each contiguous window of size N over self and returns a bulk of the outputs of f. The windows during mapping will overlap.

fn inspect<F>(self, f: F) -> Inspect<Self, F>

where Self: Sized, F: FnMut(&Self::Item),

Does something with each element of a bulk, passing the value on.

fn mutate<F>(self, f: F) -> Mutate<Self, F>

where Self: Sized, F: FnMut(&mut Self::Item),

Mutates with each element of a bulk, passing the value on.

fn collect<C, A>(self) -> C

where Self: Sized, C: FromBulk<A>, A: CollectionAdapter<Elem = Self::Item> + CollectionStrategy<Self, C> + ?Sized,

Transforms a bulk into a collection.

fn try_collect<C, A>( self, ) -> <<Self::Item as Try>::Residual as Residual<C>>::TryType

where Self: Sized, C: FromBulk<A>, A: CollectionAdapter<Elem = <Self::Item as Try>::Output> + TryCollectionAdapter<Self, C> + ?Sized, Self::Item: Try<Residual: Residual<C, TryType: Try>>,

Fallibly transforms a bulk into a collection, short circuiting if a failure is encountered.

fn collect_array( self, ) -> <Self as StaticBulk>::Array<<Self as IntoIterator>::Item>

where Self: StaticBulk,

Transforms a statically sized bulk into an array. The bulk must implement StaticBulk.

fn try_collect_array( self, ) -> <<Self::Item as Try>::Residual as Residual<Self::Array<<Self::Item as Try>::Output>>>::TryType

where Self: StaticBulk<Item: Try<Residual: Residual<(), TryType: Try> + Residual<Self::Array<<Self::Item as Try>::Output>, TryType: Try>, Output>> + Bulk,

Fallibly transforms a statically sized bulk into an array, short circuiting if a failure is encountered. The bulk must implement StaticBulk.

fn copied<'a, T>(self) -> Copied<Self>

where T: Copy + 'a, Self: Sized + Bulk<Item = &'a T>,

Creates a bulk which copies all of its elements.

fn cloned<'a, T>(self) -> Cloned<Self>

where T: Clone + 'a, Self: Sized + Bulk<Item = &'a T>,

Creates a bulk which clones all of its elements.

fn array_chunks<const N: usize>(self) -> ArrayChunks<Self, N>

where Self: Sized,

Returns a bulk of N elements of the bulk at a time.

fn split_at<L>(self, n: L) -> (Self::Left, Self::Right)

where Self: SplitBulk<L> + Sized, L: LengthValue,

Splits a bulk in two at a specified index.

fn rsplit_at<L>(self, n: L) -> (Self::Left, Self::Right)

where Self: SplitBulk<SaturatingSub<<<Self as Bulk>::Length as Length>::Value, L>> + Sized, L: LengthValue,

Splits a bulk in two at a specified reversed index.

fn each_ref<'a>(&'a self) -> Self::EachRef<'a>

where Self: RandomAccessBulk + 'a,

fn each_mut<'a>(&'a mut self) -> Self::EachMut<'a>

where Self: InplaceBulk + 'a,

fn get<'a, L>(&'a self, i: L) -> Option<&'a Self::ItemPointee>

where Self: RandomAccessBulk + 'a, L: LengthValue,

fn get_mut<'a, L>(&'a mut self, i: L) -> Option<&'a mut Self::ItemPointee>

where Self: InplaceBulk + 'a, L: LengthValue,

fn try_get<'a, L>(&'a self, i: L) -> Result<&'a Self::ItemPointee, OutOfRange>

where Self: RandomAccessBulk + 'a, L: LengthValue,

fn try_get_mut<'a, L>( &'a mut self, i: L, ) -> Result<&'a mut Self::ItemPointee, OutOfRange>

where Self: InplaceBulk + 'a, L: LengthValue,

fn get_many<'a, NN, const N: usize>( &'a self, i: NN, ) -> [Option<&'a <Self as RandomAccessBulk>::ItemPointee>; N]

where Self: RandomAccessBulk + 'a, NN: IntoBulk<Item = usize, IntoBulk: Bulk + StaticBulk<Array<()> = [(); N]>>,

fn get_many_mut<'a, NN, const N: usize>( &'a mut self, i: NN, ) -> [Option<&'a mut <Self as RandomAccessBulk>::ItemPointee>; N]

where Self: InplaceBulk + 'a, NN: IntoBulk<Item = usize, IntoBulk: Bulk + StaticBulk<Array<()> = [(); N]>>,

fn swap_inplace<L, R>(&mut self, lhs: L, rhs: R)

where Self: InplaceBulk, L: LengthValue, R: LengthValue,

fn try_swap_inplace<L, R>(&mut self, lhs: L, rhs: R) -> Result<(), OutOfRange>

where Self: InplaceBulk, L: LengthValue, R: LengthValue,

impl<T, N> Clone for StepBy<T, N>

where T: Bulk + Clone, N: Length<Elem = ()> + ?Sized + Clone,

fn clone(&self) -> StepBy<T, N>

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<T, N> Debug for StepBy<T, N>

where T: Bulk + Debug, N: Length<Elem = ()> + ?Sized + Debug,

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

Formats the value using the given formatter.

impl<T, N> InplaceBulk for StepBy<T, N>

where T: InplaceBulk<Item>, N: Length<Elem = (), Metadata> + ?Sized,

type EachMut<'a> = StepBy<<T as InplaceBulk>::EachMut<'a>, N> where Self::ItemPointee: 'a, Self: 'a

fn each_mut<'a>(_: &'a mut Self) -> Self::EachMut<'a>

where Self::ItemPointee: 'a, Self: 'a,

impl<T, N> IntoIterator for StepBy<T, N>

where T: Bulk, N: Length<Elem = ()> + ?Sized,

type Item = <T as IntoIterator>::Item

The type of the elements being iterated over.

type IntoIter = StepBy<<T as IntoIterator>::IntoIter>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

impl<T, N> RandomAccessBulk for StepBy<T, N>

where T: RandomAccessBulk<Item>, N: Length<Elem = (), Metadata> + ?Sized,

type ItemPointee = <T as RandomAccessBulk>::ItemPointee

type EachRef<'a> = StepBy<<T as RandomAccessBulk>::EachRef<'a>, N> where Self::ItemPointee: 'a, Self: 'a

fn each_ref<'a>(_: &'a Self) -> Self::EachRef<'a>

where Self::ItemPointee: 'a, Self: 'a,

impl<T, N, NN, M, L> SplitBulk<M> for StepBy<T, N>

where T: SplitBulk<L, Item, Left: Bulk, Right: Bulk>, N: Length<Elem = (), Value = NN> + ?Sized, NN: LengthValue<Metadata = <N as Pointee>::Metadata, Length<()> = N, SaturatingMul<M> = L>, M: LengthValue, L: LengthValue,

type Left = StepBy<<T as SplitBulk<L>>::Left, N>

type Right = StepBy<<T as SplitBulk<L>>::Right, N>

fn split_at(_: Self, m: M) -> (Self::Left, Self::Right)

where Self: Sized,

Splits a bulk in two at a specified index.