Enum Freer 

pub enum Freer<F, A>
where
    F: HKT + 'static,
    A: 'static,
{
    Pure(A),
    Impure(Box<dyn FreerStep<F, A>>),
}

Freer Monad — a free monad that does not require F: Functor.

Freer<F, A> stores a computation as a tree of effect steps, each containing ∃B. (F B, B → Freer F A). The existential B is erased via a dyn-safe trait, deferring the Functor requirement to fold_map.

Pure(a)       — a finished computation
Impure(step)  — an effect step with continuation

When to use Freer vs Free

• Use Free<F, A> when F: Functor — simpler, no overhead.
• Use Freer<F, A> when F is NOT a functor, or when you want to build computations without the functor constraint.

Variants

Pure(A)

A pure value — the computation is finished.

Impure(Box<dyn FreerStep<F, A>>)

An effect step with erased intermediate type.

Implementations

impl<F, A> Freer<F, A>

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

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

Wrap a pure value into the freer monad.

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

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

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

No F: Functor required.

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

where B: 'static,

Map a function over the result of this computation.

No F: Functor required. Implemented via chain.

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

where B: 'static,

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

No F: Functor required. The closure is shared via Rc across deferred chain layers.

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

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

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

This requires F: Functor (to lower each step) and M: Applicative + Chain (for the target monad operations).