Struct ByLane 

pub struct ByLane<C>(/* private fields */);

Explicit lane-major view interpretation for parallel compositions.

Scalar process() is the same as Parallel: each lane is processed by its matching branch. The difference is in view processing: under View<_, _, LaneMajor, _>, each branch sees one long contiguous lane slice rather than strided frame-major data.

Use this when branches represent lanes and view locality matters. This is often the right choice for SIMD-friendly per-lane kernels or when each branch has a useful slice-processing specialization. Do not use it as a semantic transpose: it only changes how typed views are interpreted and never allocates or physically moves data.

Implementations

impl<C> ByLane<C>

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

Create a ByLane wrapper around an existing composition.

pub fn into_inner(self) -> C

Consume the wrapper and return the inner composition.

Trait Implementations

impl<C: Clone> Clone for ByLane<C>

fn clone(&self) -> ByLane<C>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<C: Copy> Copy for ByLane<C>

impl<C: Debug> Debug for ByLane<C>

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

Formats the value using the given formatter.

impl<C: Default> Default for ByLane<C>

fn default() -> ByLane<C>

Returns the “default value” for a type.

impl<X, C, S> SplitInplace<X, S> for ByLane<C>

where X: Copy, Self: SplitProcess<X, X, S>,

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

See also Inplace::inplace

impl<X: Copy, Y, C0, C1, S0, S1> SplitProcess<[X; 2], [Y; 2], (S0, S1)> for ByLane<(C0, C1)>

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

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

Process an input into an output

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

Process a block of inputs

impl<X: Copy, Y, C, S, const N: usize> SplitProcess<[X; N], [Y; N], [S; N]> for ByLane<[C; N]>

where C: SplitProcess<X, Y, S>,

fn process(&self, state: &mut [S; N], x: [X; N]) -> [Y; N]

Process an input into an output

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

Process a block of inputs

impl<'a, X: Copy, C0, C1, S0, S1> SplitViewInplace<ViewMut<'a, X, LaneMajor, 2>, (S0, S1)> for ByLane<(C0, C1)>

where C0: SplitInplace<X, S0>, C1: SplitInplace<X, S1>,

fn inplace_view(&self, state: &mut (S0, S1), xy: ViewMut<'a, X, LaneMajor, 2>)

Process one typed view in place.

impl<'a, X: Copy, C, S, const N: usize> SplitViewInplace<ViewMut<'a, X, LaneMajor, N>, [S; N]> for ByLane<[C; N]>

where C: SplitInplace<X, S>,

fn inplace_view(&self, state: &mut [S; N], xy: ViewMut<'a, X, LaneMajor, N>)

Process one typed view in place.

impl<'a, 'b, X: Copy, Y, C0, C1, S0, S1> SplitViewProcess<View<'a, X, LaneMajor, 2>, ViewMut<'b, Y, LaneMajor, 2>, (S0, S1)> for ByLane<(C0, C1)>

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

fn process_view( &self, state: &mut (S0, S1), x: View<'a, X, LaneMajor, 2>, y: ViewMut<'b, Y, LaneMajor, 2>, )

Process one typed input view into one typed output view.

impl<'a, 'b, X: Copy, Y, C, S, const N: usize> SplitViewProcess<View<'a, X, LaneMajor, N>, ViewMut<'b, Y, LaneMajor, N>, [S; N]> for ByLane<[C; N]>

where C: SplitProcess<X, Y, S>,

fn process_view( &self, state: &mut [S; N], x: View<'a, X, LaneMajor, N>, y: ViewMut<'b, Y, LaneMajor, N>, )

Process one typed input view into one typed output view.