Trait generic_array::functional::FunctionalSequence

source ·
pub trait FunctionalSequence<T>: GenericSequence<T> {
    // Provided methods
    fn map<U, F>(self, f: F) -> MappedSequence<Self, T, U>
       where Self: MappedGenericSequence<T, U>,
             F: FnMut(Self::Item) -> U { ... }
    fn zip<B, Rhs, U, F>(self, rhs: Rhs, f: F) -> MappedSequence<Self, T, U>
       where Self: MappedGenericSequence<T, U>,
             Rhs: MappedGenericSequence<B, U, Mapped = MappedSequence<Self, T, U>> + GenericSequence<B, Length = Self::Length>,
             F: FnMut(Self::Item, Rhs::Item) -> U { ... }
    fn fold<U, F>(self, init: U, f: F) -> U
       where F: FnMut(U, Self::Item) -> U { ... }
}
Expand description

Defines functional programming methods for generic sequences

Provided Methods§

source

fn map<U, F>(self, f: F) -> MappedSequence<Self, T, U>
where Self: MappedGenericSequence<T, U>, F: FnMut(Self::Item) -> U,

Maps a GenericSequence to another GenericSequence.

If the mapping function panics, any already initialized elements in the new sequence will be dropped, AND any unused elements in the source sequence will also be dropped.

source

fn zip<B, Rhs, U, F>(self, rhs: Rhs, f: F) -> MappedSequence<Self, T, U>
where Self: MappedGenericSequence<T, U>, Rhs: MappedGenericSequence<B, U, Mapped = MappedSequence<Self, T, U>> + GenericSequence<B, Length = Self::Length>, F: FnMut(Self::Item, Rhs::Item) -> U,

Combines two GenericSequence instances and iterates through both of them, initializing a new GenericSequence with the result of the zipped mapping function.

If the mapping function panics, any already initialized elements in the new sequence will be dropped, AND any unused elements in the source sequences will also be dropped.

WARNING: If using the alloc crate feature, mixing stack-allocated GenericArray<T, N> and heap-allocated Box<GenericArray<T, N>> within zip should be done with care or avoided.

For copy-types, it could be easy to accidentally move the array out of the Box when zipping with a stack-allocated array, which could cause a stack-overflow if the array is sufficiently large. However, that being said, the second where clause ensuring they map to the same sequence type will catch common errors, such as:

fn test() {
    let stack = arr![1, 2, 3, 4];
    let heap = box_arr![5, 6, 7, 8];
    let mixed = stack.zip(heap, |a, b| a + b);
    //                --- ^^^^ expected struct `GenericArray`, found struct `Box`
}
source

fn fold<U, F>(self, init: U, f: F) -> U
where F: FnMut(U, Self::Item) -> U,

Folds (or reduces) a sequence of data into a single value.

If the fold function panics, any unused elements will be dropped.

Object Safety§

This trait is not object safe.

Implementations on Foreign Types§

source§

impl<'a, T, S: GenericSequence<T>> FunctionalSequence<T> for &'a S

source§

impl<'a, T, S: GenericSequence<T>> FunctionalSequence<T> for &'a mut S

source§

impl<T, N: ArrayLength> FunctionalSequence<T> for Box<GenericArray<T, N>>
where Self: GenericSequence<T, Item = T, Length = N>,

Available on crate feature alloc only.

Implementors§

source§

impl<T, N: ArrayLength> FunctionalSequence<T> for GenericArray<T, N>
where Self: GenericSequence<T, Item = T, Length = N>,