Struct FreeAlt 

pub struct FreeAlt<F, A>
where
    F: HKT + 'static,
    A: 'static,
{ /* private fields */ }

Free Alternative Functor — build alternative computations as data.

FreeAlt<F, A> represents a choice among zero or more applicative computations, each built from FreeAp<F, A>. This gives a free Alternative instance for any functor F.

FreeAlt f a ≅ [FreeAp f a]

An empty list represents zero (failure), a single element is a single computation, and multiple elements represent alt (choice).

Interpretation

retract collapses the structure into F’s own Alternative, combining branches with F::alt and handling empty lists with F::zero.

Implementations

impl<F, A> FreeAlt<F, A>

where F: HKT + 'static, A: 'static,

pub fn pure(a: A) -> FreeAlt<F, A>

Wrap a pure value.

pub fn lift_f(fa: <F as HKT>::Of<A>) -> FreeAlt<F, A>

where A: Clone, <F as HKT>::Of<A>: 'static,

Lift a single effect into the free alternative.

pub fn zero() -> FreeAlt<F, A>

The empty alternative (zero / failure).

pub fn alt(self, other: FreeAlt<F, A>) -> FreeAlt<F, A>

Combine two alternatives (choice).

pub fn fmap<B>(self, f: impl Fn(A) -> B + 'static) -> FreeAlt<F, B>

where B: 'static,

Map a function over all branches.

pub fn retract(self) -> <F as HKT>::Of<A>

where F: Alternative,

Interpret by collapsing into F’s own Alternative.

Requires F: Alternative.

pub fn count_alternatives(&self) -> usize

Count the total number of alternative branches.

pub fn count_effects(&self) -> usize

Count the total number of effects across all branches.