radn-rs/src/func/instances/effect.rs

//! [Monad] for passing and combining metadata related to the evaluation of values.
//!
//! For "either"/"sum" wrapping, see [`result`].
//!
//! For no extra data, see [`solo`].
//!
//! [`result`]: super::result
//! [`solo`]: super::solo

use crate::func::class_prelude::*;

/// Metadata type.
pub trait Effect {
    /// Used in [`Pure::pure`].
    fn e_pure() -> Self;

    /// Used in [`ApplicativeLA2::la2`] and other [`Applicative`] methods.
    fn e_seq(el: Self, er: Self) -> Self;

    /// Used in [`Monad::bind`] and other [`Monad`] methods.
    fn e_after(self, effect: Self) -> Self;
}

/// Value and related metadata.
#[derive(Clone)]
pub struct WithEffect<A, E> {
    pub value: A,
    pub effect: E,
}

impl<A, E: Effect> WithEffect<A, E> {
    fn e_after(self, effect: E) -> Self {
        WithEffect {
            value: self.value,
            effect: self.effect.e_after(effect),
        }
    }
}

#[derive(SharedFunctorAny)]
pub struct EffectInstance<E>(E);

impl<E> WeakFunctorAny for EffectInstance<E> {
    type FAny<'a, A: 'a> = WithEffect<A, E>
    where
        Self: 'a;
}

impl<'a, E: 'a> Functor<'a> for EffectInstance<E> {
    fn fmap<A: 'a, B: 'a>(fa: Self::F<A>, f: impl 'a + FnOnce(A) -> B) -> Self::F<B> {
        WithEffect {
            value: f(fa.value),
            effect: fa.effect,
        }
    }

    fn replace<A: 'a, B: 'a>(fa: Self::F<A>, b: B) -> Self::F<B> {
        drop(fa.value);
        WithEffect {
            value: b,
            effect: fa.effect,
        }
    }
}

impl<'a, E: 'a + Effect> Pure<'a> for EffectInstance<E> {
    fn pure<A: 'a>(a: A) -> Self::F<A> {
        WithEffect {
            value: a,
            effect: E::e_pure(),
        }
    }
}

impl<'a, E: 'a + Effect> ApplicativeSeq<'a> for EffectInstance<E> {
    fn seq<A: 'a, B: 'a>(ff: Self::F<impl 'a + FnOnce(A) -> B>, fa: Self::F<A>) -> Self::F<B> {
        WithEffect {
            value: (ff.value)(fa.value),
            effect: E::e_seq(ff.effect, fa.effect),
        }
    }
}

impl<'a, E: 'a + Effect> ApplicativeLA2<'a> for EffectInstance<E> {
    fn la2<A: 'a, B: 'a, C: 'a>(
        fa: Self::F<A>,
        fb: Self::F<B>,
        f: impl 'a + FnOnce(A, B) -> C,
    ) -> Self::F<C> {
        WithEffect {
            value: f(fa.value, fb.value),
            effect: E::e_seq(fa.effect, fb.effect),
        }
    }
}

impl<'a, E: 'a + Effect> ApplicativeTuple<'a> for EffectInstance<E> {
    fn tuple<A: 'a, B: 'a>((fa, fb): (Self::F<A>, Self::F<B>)) -> Self::F<(A, B)> {
        WithEffect {
            value: (fa.value, fb.value),
            effect: E::e_seq(fa.effect, fb.effect),
        }
    }
}

impl<'a, E: 'a + Effect> ApplicativeSelect<'a> for EffectInstance<E> {}

impl<'a, E: 'a + Effect> Applicative<'a> for EffectInstance<E> {
    fn discard_first<A: 'a, B: 'a>(fa: Self::F<A>, fb: Self::F<B>) -> Self::F<B> {
        drop(fa.value);
        WithEffect {
            value: fb.value,
            effect: E::e_seq(fa.effect, fb.effect),
        }
    }

    fn discard_second<A: 'a, B: 'a>(fa: Self::F<A>, fb: Self::F<B>) -> Self::F<A> {
        drop(fb.value);
        WithEffect {
            value: fa.value,
            effect: E::e_seq(fa.effect, fb.effect),
        }
    }
}

impl<'a, E: 'a + Effect> Monad<'a> for EffectInstance<E> {
    fn bind<A: 'a, B: 'a>(fa: Self::F<A>, f: impl 'a + FnOnce(A) -> Self::F<B>) -> Self::F<B> {
        f(fa.value).e_after(fa.effect)
    }

    fn iterate<B: 'a>(mut f: impl Iterative<'a, T = Self, B = B>) -> Self::F<B> {
        let mut effect = E::e_pure();
        loop {
            let fa = f.next();
            effect = fa.effect.e_after(effect);
            match fa.value {
                ControlFlow::Continue(next_f) => f = next_f,
                ControlFlow::Break(b) => return WithEffect { value: b, effect },
            }
        }
    }

    fn join<A: 'a>(ffa: Self::F<Self::F<A>>) -> Self::F<A> {
        ffa.value.e_after(ffa.effect)
    }
}

impl<'a, E: 'a> LocalFunctor<'a> for EffectInstance<E> {
    fn stuff<A: 'a, T: Pure<'a>>(fa: Self::F<T::F<A>>) -> T::F<Self::F<A>> {
        T::fmap(fa.value, |a| WithEffect {
            value: a,
            effect: fa.effect,
        })
    }
}