Struct Major 

pub struct Major<P: ?Sized, U> { /* private fields */ }

Stage-major slice composition with explicit scratch storage.

Major keeps ordinary scalar process() semantics but changes block() and inplace() to process the pipeline in chunks through an explicit intermediate buffer. Each stage sees a contiguous scratch slice before the next stage runs.

Use this when:

• stages have useful block() implementations that should see long slices
• stage-major traversal is better for cache behavior than sample-by-sample traversal
• an intermediate type change makes plain inplace composition impossible
• preserving SIMD/autovectorization opportunities across slice stages matters

Avoid it when:

• stages are tiny and re-entering them per scratch chunk costs more than it saves
• the intermediate buffer would be large or awkward to materialize
• Minor already fits because the hot working set is tiny and per-sample stage locality dominates

In short: Major preserves stage-wise slice processing and pays for that with explicit scratch.

Implementations

impl<P, U> Major<P, U>

pub const fn new(inner: P) -> Self

Create a Major wrapper around an existing composition.

pub fn into_inner(self) -> P

Consume the wrapper and return the inner composition.

pub fn inner(&self) -> &P

Borrow the wrapped composition.

Trait Implementations

impl<P: Clone + ?Sized, U: Clone> Clone for Major<P, U>

fn clone(&self) -> Major<P, U>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<P: Copy + ?Sized, U: Copy> Copy for Major<P, U>

impl<P: Debug + ?Sized, U: Debug> Debug for Major<P, U>

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

Formats the value using the given formatter.

impl<P: Default + ?Sized, U: Default> Default for Major<P, U>

fn default() -> Major<P, U>

Returns the “default value” for a type.

impl<X: Copy, U: Copy + Default, C0, C1, S0, S1, const N: usize> SplitInplace<X, (S0, S1)> for Major<(C0, C1), [U; N]>

where C0: SplitProcess<X, U, S0>, C1: SplitProcess<U, X, S1>,

fn inplace(&self, state: &mut (S0, S1), xy: &mut [X])

See also Inplace::inplace

impl<X: Copy, U: Copy + Default, Y, C0, C1, S0, S1, const N: usize> SplitProcess<X, Y, (S0, S1)> for Major<(C0, C1), [U; N]>

where C0: SplitProcess<X, U, S0>, C1: SplitProcess<U, Y, S1>,

fn process(&self, state: &mut (S0, S1), x: X) -> Y

Process an input into an output

fn block(&self, state: &mut (S0, S1), x: &[X], y: &mut [Y])

Process a block of inputs