Trait FunctionalSequence

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 { ... }
}

Defines functional programming methods for generic sequences

Provided Methods

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.

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`
}

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.

Dyn Compatibility

This trait is not dyn compatible.

In older versions of Rust, dyn compatibility was called "object safety", so this trait is not object safe.

Implementations on Foreign Types

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

where &'a S: GenericSequence<T>,

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

where &'a mut S: GenericSequence<T>,

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

impl<T, N: ArrayLength> FunctionalSequence<T> for GenericArray<T, N>

where Self: GenericSequence<T, Item = T, Length = N>,