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 try_map<U, F, E>(self, f: F) -> Result<MappedSequence<Self, T, U>, E>
where Self: MappedGenericSequence<T, U>,
MappedSequence<Self, T, U>: FromFallibleIterator<U>,
F: FnMut(Self::Item) -> Result<U, E> { ... }
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 { ... }
fn try_fold<U, E, F>(self, init: U, f: F) -> Result<U, E>
where F: FnMut(U, Self::Item) -> Result<U, E> { ... }
}Expand description
Defines functional programming methods for generic sequences
Source
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
Tries to map a GenericSequence to another GenericSequence, returning a Result.
If the mapping function errors or 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
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
Folds (or reduces) a sequence of data into a single value.
If the fold function panics, any unused elements will be dropped.
Source
Folds (or reduces) a sequence of data into a single value, returning a Result.
If the fold function errors or panics, any unused elements will be dropped.
This trait is not dyn compatible.
In older versions of Rust, dyn compatibility was called "object safety", so this trait is not object safe.
Available on crate feature alloc only.