Struct Day 

pub struct Day<F, G, A, B, C>
where
    F: HKT,
    G: HKT,
{ /* private fields */ }

Day Convolution — combines two functors F and G into a single computation.

Day<F, G, A, B, C> ≅ (F B, G C, B → C → A)

Stores an F value, a G value, and a combining function. The intermediate types B and C are visible in the type signature (Rust lacks first-class existential types, same as Lan and Coyoneda).

Key properties

• Functor in A: fmap composes onto the combining function, no bounds on F or G needed.
• Interpretation: run_day uses two natural transformations (one for F, one for G) to interpret into a target Applicative.

Implementations

impl<F, G, A, B, C> Day<F, G, A, B, C>

where F: HKT + 'static, G: HKT + 'static, A: 'static, B: Clone + 'static, C: Clone + 'static,

pub fn new( f_val: <F as HKT>::Of<B>, g_val: <G as HKT>::Of<C>, combine: impl Fn(B, C) -> A + 'static, ) -> Day<F, G, A, B, C>

Construct a Day from two functor values and a combining function.

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

where D: 'static,

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

pub fn run_day<M, NF, NG>(self) -> <M as HKT>::Of<A>

where M: Applicative, NF: NaturalTransformation<F, M>, NG: NaturalTransformation<G, M>,

Interpret this Day value into a target applicative M using two natural transformations: NF: F ~> M and NG: G ~> M.