Struct Lan 

pub struct Lan<G, H, A, B>
where
    G: HKT,
    H: HKT,
{ /* private fields */ }

Left Kan Extension — Lan G H A ≅ ∃B. (G B → A, H B).

Encodes a value H B together with a way to extract A from G B. The intermediate type B is visible in Rust (unlike Haskell’s existential) because Rust lacks first-class existential types.

Key properties

• Functor in A: fmap composes onto the extract function, no bounds needed.
• Specialisation: Lan<IdentityF, F, A, B> is isomorphic to Coyoneda<F, A>.
• Lower: Given a natural transformation H ~> G, collapse to A.

Implementations

impl<G, H, A, B> Lan<G, H, A, B>

where G: HKT + 'static, H: HKT + 'static, A: 'static, B: 'static,

pub fn new( source: <H as HKT>::Of<B>, f: impl Fn(<G as HKT>::Of<B>) -> A + 'static, ) -> Lan<G, H, A, B>

Construct a Lan from a source value and an extract function.

pub fn fmap<C>(self, f: impl Fn(A) -> C + 'static) -> Lan<G, H, C, B>

where C: 'static,

Map a function over the result type. No bounds on G or H required.

pub fn lower<NT>(self) -> A

where NT: NaturalTransformation<H, G>,

Collapse the Lan using a natural transformation NT: H ~> G.

Applies the nat-trans to the source, then extracts the result.

impl<H, A, B> Lan<IdentityF, H, A, B>

where H: HKT + 'static, A: 'static, B: 'static, <H as HKT>::Of<B>: 'static,

When G = IdentityF, Lan<IdentityF, H, A, B> is isomorphic to Coyoneda<H, A, B>.

pub fn to_coyoneda(self) -> Coyoneda<H, A, B>

Convert to Coyoneda<H, A, B>.

Lan<IdentityF, H, A, B> ≅ (B → A, H B) = Coyoneda<H, A, B>