Enum CommonFold 

pub enum CommonFold<L> {
    Count(CountFold<L>),
    FilterCount(FilterCountFold<L>),
    SumI64(SumI64Fold<L>),
    Any(AnyFold<L>),
}

Enum-dispatch fold for common patterns that would otherwise use Box<dyn Fold>.

This is intentionally limited to a few hot, allocation-free cases so callers can avoid vtable dispatch in heterogeneous fold collections.

Variants

Count(CountFold<L>)

Count every entry.

FilterCount(FilterCountFold<L>)

Count entries matching a predicate.

SumI64(SumI64Fold<L>)

Sum projected i64 values.

Any(AnyFold<L>)

Return whether any entry matches the predicate.

Implementations

impl<L> CommonFold<L>

pub fn count() -> Self

Create a counting common fold.

pub fn filter_count(predicate: fn(&L) -> bool) -> Self

Create a filtered-count common fold.

pub fn sum_i64(project: fn(&L) -> i64) -> Self

Create an i64 summation common fold.

pub fn any(predicate: fn(&L) -> bool) -> Self

Create an existential common fold.

pub fn try_step( &self, state: CommonFoldState, entry: &L, context: &FoldContext, ) -> Result<CommonFoldState, FoldFailure>

Process a single entry and return an error if the state shape is invalid.

Trait Implementations

impl<L: Clone> Clone for CommonFold<L>

fn clone(&self) -> CommonFold<L>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<L> Debug for CommonFold<L>

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

Formats the value using the given formatter.

impl<L> Fold<L, CommonFoldState> for CommonFold<L>

fn step( &self, state: CommonFoldState, entry: &L, context: &FoldContext, ) -> CommonFoldState

Panics

Panics if state does not match the variant expected by self. Use TryFold::try_step to handle the mismatch as an error instead.

fn initial(&self, _context: &FoldContext) -> CommonFoldState

Get the initial state before any entries are processed.

fn finalize(&self, state: S, _context: &FoldContext) -> S

Finalize the state after all entries are processed.

fn derive<'a, I>(&self, entries: I, context: &FoldContext) -> FoldOutcome<S>

where Self: Sized, I: IntoIterator<Item = &'a L>, L: 'a,

Derive state from an iterator of entries.

fn derive_filtered<'a, I, F>( &self, entries: I, context: &FoldContext, filter: F, ) -> FoldOutcome<S>

where Self: Sized, I: IntoIterator<Item = &'a L>, L: 'a, F: Fn(&L) -> bool,

Derive state with a filter.

impl<L> TryFold<L, CommonFoldState> for CommonFold<L>

fn try_step( &self, state: CommonFoldState, entry: &L, context: &FoldContext, ) -> Result<CommonFoldState, FoldFailure>

Process a single entry and return an error instead of panicking.