Enum Free 

pub enum Free<F, A>
where
    F: HKT,
{
    Pure(A),
    Roll(Box<<F as HKT>::Of<Free<F, A>>>),
}

Free Monad — builds a monadic computation as a data structure.

Free<F, A> represents a program where F describes the available effects and A is the result type. Programs are built with pure and lift_f, composed with chain, and interpreted with fold_map using a natural transformation into any target monad.

Pure(a)              — a finished computation returning a
Roll(F<Free<F, A>>)  — one layer of effect wrapping a continuation

Variants

Pure(A)

A pure value — the computation is finished.

Roll(Box<<F as HKT>::Of<Free<F, A>>>)

A layer of effect F wrapping a continuation.

Implementations

impl<F, A> Free<F, A>

where F: HKT,

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

Wrap a pure value into the free monad.

impl<F, A> Free<F, A>

where F: HKT + Functor,

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

Lift a single effect F<A> into the free monad.

pub fn fmap<B>(self, f: impl Fn(A) -> B) -> Free<F, B>

Map a function over the result of this computation.

pub fn chain<B>(self, f: impl Fn(A) -> Free<F, B>) -> Free<F, B>

Monadic bind — sequence this computation with a function that produces the next computation.

pub fn fold_map<M, NT>(self) -> <M as HKT>::Of<A>

where M: Applicative + Chain, NT: NaturalTransformation<F, M>,

Interpret this free monad into a target monad M using a natural transformation NT: F ~> M.

This is the core interpreter: it collapses the free structure by translating each F effect into M and sequencing with M::chain.