Struct Map 

pub struct Map<I, F>
where
    I: Bulk,
    F: FnMut<(I::Item,)>,
{ /* private fields */ }

A bulk that maps the values of bulk with f.

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

Notes about side effects

The map iterator implements DoubleEndedIterator, meaning that you can also map backwards:

use bulks::*;
 
let v: [i32; 3] = [1, 2, 3].into_bulk().map(|x| x + 1).rev().collect();

assert_eq!(v, [4, 3, 2]);

But if your closure has state, iterating backwards may act in a way you do not expect. Let’s go through an example. First, in the forward direction:

use bulks::*;
 
let mut c = 0;

for pair in ['a', 'b', 'c'].into_bulk()
    .map(|letter| { c += 1; (letter, c) })
{
    println!("{pair:?}");
}

This will print ('a', 1), ('b', 2), ('c', 3).

Now consider this twist where we add a call to rev. This version will print ('c', 1), ('b', 2), ('a', 3). Note that the letters are reversed, but the values of the counter still go in order. This is because map() is still being called lazily on each item, but we are popping items off the back of the array now, instead of shifting them from the front.

use bulks::*;
 
let mut c = 0;

for pair in ['a', 'b', 'c'].into_bulk()
    .map(|letter| { c += 1; (letter, c) })
    .rev()
{
    println!("{pair:?}");
}

Trait Implementations

impl<I, F> Bulk for Map<I, F>

where I: Bulk<Item>, F: FnMut<(I::Item,)>,

type MinLength = <I as Bulk>::MinLength

type MaxLength = <I as Bulk>::MaxLength

fn len(&self) -> usize

Returns the exact length of the bulk.

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 for_each<FF>(self, f: FF)

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

Calls a closure on each element of a bulk.

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

where Self: Sized, FF: 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 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 rev(self) -> Rev<Self>

where Self: Sized + DoubleEndedBulk,

Reverses a bulks’s direction.

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.

impl<I, F> Clone for Map<I, F>

where I: Bulk + Clone, F: FnMut<(I::Item,)> + Clone,

fn clone(&self) -> Map<I, F>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<I, F> Debug for Map<I, F>

where I: Bulk + Debug, F: FnMut<(I::Item,)>,

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

Formats the value using the given formatter.

impl<I, F> DoubleEndedBulk for Map<I, F>

where I: DoubleEndedBulk<Item>, F: FnMut<(I::Item,)>,

fn rev_for_each<FF>(self, f: FF)

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

Calls a closure on each element of a bulk in reverse.

fn try_rev_for_each<FF, R>(self, f: FF) -> R

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

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

impl<I, F> IntoIterator for Map<I, F>

where I: Bulk, F: FnMut<(I::Item,)>,

type Item = <F as FnOnce(<I as IntoIterator>::Item)>::Output

The type of the elements being iterated over.

type IntoIter = Map<<I as IntoIterator>::IntoIter, F>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

impl<I, F, L> SplitBulk<L> for Map<I, F>

where I: SplitBulk<L, Item, Left: Bulk, Right: Bulk>, F: FnMut<(I::Item,)> + Clone, L: LengthValue,

type Left = Map<<I as SplitBulk<L>>::Left, F>

type Right = Map<<I as SplitBulk<L>>::Right, F>

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

where Self: Sized,

Splits a bulk in two at a specified index.