Struct SequentialStrategy 

pub struct SequentialStrategy;

A sequential execution strategy.

This strategy executes all operations on the current thread without any parallelism. It is useful for:

• Debugging and testing (deterministic execution)
• no_std environments where threading is unavailable
• Small workloads where parallelism overhead exceeds benefits
• Comparing sequential vs parallel performance

Examples

use commonware_parallel::{Strategy, Sequential};

let strategy = Sequential;
let data = vec![1, 2, 3, 4, 5];

let sum = strategy.fold(&data, || 0, |a, &b| a + b, |a, b| a + b);
assert_eq!(sum, 15);

Trait Implementations

impl Clone for Sequential

fn clone(&self) -> Sequential

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Sequential

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

Formats the value using the given formatter.

impl Default for Sequential

fn default() -> Sequential

Returns the “default value” for a type.

impl Strategy for Sequential

Available on neither commonware_stability_DELTA nor commonware_stability_EPSILON nor commonware_stability_GAMMA nor commonware_stability_RESERVED.

fn manual(&self) -> Manual<Sequential>

Returns a strategy wrapper for manually partitioned work.

fn spawn<F, T>( &self, _len: usize, f: F, ) -> impl Future<Output = T> + Send + 'static

where F: FnOnce(Sequential) -> T + Send + 'static, T: Send + 'static,

Submit one CPU-bound job to this strategy, running it inline on the calling task when it is measured cheaper than the round trip of offloading it to the pool.

fn run<R, SEQ, PAR>(&self, _len: usize, serial: SEQ, _parallel: PAR) -> R

where R: Send, SEQ: FnOnce() -> R + Send, PAR: FnOnce() -> R + Send,

Runs either a serial or parallel body.

fn try_run<R, E, SEQ, PAR>( &self, _len: usize, serial: SEQ, _parallel: PAR, ) -> Result<R, E>

where R: Send, E: Send, SEQ: FnOnce() -> Result<R, E> + Send, PAR: FnOnce() -> Result<R, E> + Send,

Like run, but for fallible work.

fn fold_init<I, INIT, T, R, ID, F, RD>( &self, iter: I, init: INIT, identity: ID, fold_op: F, _reduce_op: RD, ) -> R

where I: IntoIterator + Send, <I as IntoIterator>::IntoIter: Send, <I as IntoIterator>::Item: Send, INIT: Fn() -> T + Send + Sync, T: Send, R: Send, ID: Fn() -> R + Send + Sync, F: Fn(R, &mut T, <I as IntoIterator>::Item) -> R + Send + Sync, RD: Fn(R, R) -> R + Send + Sync,

Reduces a collection to a single value with per-partition initialization.

fn try_fold<I, R, E, ID, F, RD>( &self, iter: I, identity: ID, fold_op: F, _reduce_op: RD, ) -> Result<R, E>

where I: IntoIterator + Send, <I as IntoIterator>::IntoIter: Send, <I as IntoIterator>::Item: Send, R: Send, E: Send, ID: Fn() -> R + Send + Sync, F: Fn(R, <I as IntoIterator>::Item) -> Result<R, E> + Send + Sync, RD: Fn(R, R) -> R + Send + Sync,

Reduces a collection to a single value using a fallible fold operation.

fn join<A, B, RA, RB>(&self, a: A, b: B) -> (RA, RB)

where A: FnOnce() -> RA + Send, B: FnOnce() -> RB + Send, RA: Send, RB: Send,

Executes two closures, potentially in parallel, and returns both results.

fn sort_by<T, C>(&self, items: &mut [T], compare: C)

where T: Send, C: Fn(&T, &T) -> Ordering + Send + Sync,

Sorts a slice with a comparator, preserving the order of equal elements.

fn fold<I, R, ID, F, RD>( &self, iter: I, identity: ID, fold_op: F, reduce_op: RD, ) -> R

where I: IntoIterator + Send, <I as IntoIterator>::IntoIter: Send, <I as IntoIterator>::Item: Send, R: Send, ID: Fn() -> R + Send + Sync, F: Fn(R, <I as IntoIterator>::Item) -> R + Send + Sync, RD: Fn(R, R) -> R + Send + Sync,

Reduces a collection to a single value using fold and reduce operations.

fn map_collect_vec<I, F, T>(&self, iter: I, map_op: F) -> Vec<T>

where I: IntoIterator + Send, <I as IntoIterator>::IntoIter: Send, <I as IntoIterator>::Item: Send, F: Fn(<I as IntoIterator>::Item) -> T + Send + Sync, T: Send,

Maps each element and collects results into a Vec.

fn try_map_collect_vec<I, F, T, E>( &self, iter: I, map_op: F, ) -> Result<Vec<T>, E>

where I: IntoIterator + Send, <I as IntoIterator>::IntoIter: Send, <I as IntoIterator>::Item: Send, F: Fn(<I as IntoIterator>::Item) -> Result<T, E> + Send + Sync, T: Send, E: Send,

Maps each element with a fallible operation and collects results into a Vec.

fn map_init_collect_vec<I, INIT, T, F, R>( &self, iter: I, init: INIT, map_op: F, ) -> Vec<R>

where I: IntoIterator + Send, <I as IntoIterator>::IntoIter: Send, <I as IntoIterator>::Item: Send, INIT: Fn() -> T + Send + Sync, T: Send, F: Fn(&mut T, <I as IntoIterator>::Item) -> R + Send + Sync, R: Send,

Maps each element with per-partition state and collects results into a Vec.

fn map_init_collect_vec_with_multiplier<I, INIT, T, F, R>( &self, iter: I, _multiplier: usize, init: INIT, map_op: F, ) -> Vec<R>

where I: IntoIterator + Send, <I as IntoIterator>::IntoIter: Send, <I as IntoIterator>::Item: Send, INIT: Fn() -> T + Send + Sync, T: Send, F: Fn(&mut T, <I as IntoIterator>::Item) -> R + Send + Sync, R: Send,

Maps each element with per-partition state and a per-item work multiplier.

fn map_collect_vec_with_multiplier<I, F, R>( &self, iter: I, multiplier: usize, map_op: F, ) -> Vec<R>

where I: IntoIterator + Send, <I as IntoIterator>::IntoIter: Send, <I as IntoIterator>::Item: Send, F: Fn(<I as IntoIterator>::Item) -> R + Send + Sync, R: Send,

Maps each element with a per-item work multiplier.

fn map_partition_collect_vec<I, F, K, U>( &self, iter: I, map_op: F, ) -> (Vec<U>, Vec<K>)

where I: IntoIterator + Send, <I as IntoIterator>::IntoIter: Send, <I as IntoIterator>::Item: Send, F: Fn(<I as IntoIterator>::Item) -> (K, Option<U>) + Send + Sync, K: Send, U: Send,

Maps each element, filtering out None results and tracking their keys.