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

//! Implementation of [`Monad`] for [`Option<A>`].
//!
//! If any of the input values are [`None`], you can expect the output to be [`None`] as well.
//! That includes
//! [`OptionInstance::replace`] and [`OptionInstance::discard_first`]/[`OptionInstance::discard_second`],
//! even if the value of the option would be ignored.
//!
//! For [`Result<A, E>`] alternative see [`result`].
//!
//! For values that are never [`None`], see [`solo`].
//!
//! [`result`]: super::result
//! [`solo`]: super::solo

use crate::func::class_prelude::*;
#[derive(SharedFunctorAny)]
pub struct OptionInstance;

impl WeakFunctorAny for OptionInstance {
    type FAny<'a, A: 'a> = Option<A>;
}

impl<'a> Functor<'a> for OptionInstance {
    fn fmap<A: 'a, B: 'a>(fa: Self::F<A>, f: impl 'a + FnOnce(A) -> B) -> Self::F<B> {
        fa.map(f)
    }

    fn replace<A: 'a, B: 'a>(fa: Self::F<A>, b: B) -> Self::F<B> {
        fa?;
        Self::pure(b)
    }

    fn void<A: 'a>(fa: Self::F<A>) -> Self::F<()> {
        fa?;
        Self::pure(())
    }
}

impl<'a> Pure<'a> for OptionInstance {
    fn pure<A: 'a>(a: A) -> Self::F<A> {
        Some(a)
    }
}

impl<'a> ApplicativeSeq<'a> for OptionInstance {
    fn seq<A: 'a, B: 'a>(ff: Self::F<impl 'a + FnOnce(A) -> B>, fa: Self::F<A>) -> Self::F<B> {
        Self::pure(ff?(fa?))
    }
}

impl<'a> ApplicativeLA2<'a> for OptionInstance {
    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> {
        Self::pure(f(fa?, fb?))
    }
}

impl<'a> ApplicativeTuple<'a> for OptionInstance {
    fn tuple<A: 'a, B: 'a>((fa, fb): (Self::F<A>, Self::F<B>)) -> Self::F<(A, B)> {
        Self::pure((fa?, fb?))
    }
}

impl<'a> ApplicativeSelect<'a> for OptionInstance {}

impl<'a> Applicative<'a> for OptionInstance {
    fn discard_first<A: 'a, B: 'a>(fa: Self::F<A>, fb: Self::F<B>) -> Self::F<B> {
        fa?;
        fb
    }

    fn discard_second<A: 'a, B: 'a>(fa: Self::F<A>, fb: Self::F<B>) -> Self::F<A> {
        fb?;
        fa
    }
}

impl<'a> Monad<'a> for OptionInstance {
    fn bind<A: 'a, B: 'a>(fa: Self::F<A>, f: impl 'a + FnOnce(A) -> Self::F<B>) -> Self::F<B> {
        f(fa?)
    }

    fn iterate<B: 'a>(mut f: impl Iterative<'a, T = Self, B = B>) -> Self::F<B> {
        loop {
            match f.next()? {
                ControlFlow::Continue(next_f) => f = next_f,
                ControlFlow::Break(b) => return Self::pure(b),
            }
        }
    }

    fn join<A: 'a>(ffa: Self::F<Self::F<A>>) -> Self::F<A> {
        ffa?
    }
}

impl<'a> LocalFunctor<'a> for OptionInstance {
    fn unstuff<A: 'a, B: 'a>(state: Self::F<ControlFlow<B, A>>) -> ControlFlow<Self::F<B>, A> {
        match state {
            Some(ControlFlow::Continue(a)) => ControlFlow::Continue(a),
            Some(ControlFlow::Break(b)) => ControlFlow::Break(Some(b)),
            None => ControlFlow::Break(None),
        }
    }

    fn stuff<A: 'a, T: Pure<'a>>(fa: Self::F<T::F<A>>) -> T::F<Self::F<A>> {
        match fa {
            Some(ua) => T::fmap(ua, Some),
            None => T::pure(None),
        }
    }
}

impl<'a> Fail<'a, ()> for OptionInstance {
    fn fail<A: 'a>(_e: ()) -> Self::F<A> {
        None
    }
}

#[cfg(test)]
mod option_tests {
    use super::{test_suite, tests, Functor};

    use super::OptionInstance as T;

    impl<'a> tests::Eqr<'a> for T {
        fn eqr<A: PartialEq + std::fmt::Debug + 'a>(
            name: &'a str,
            left: Self::F<A>,
            right: Self::F<A>,
        ) -> tests::R {
            tests::eqr(name, left, right)
        }
    }

    impl<'a> test_suite::FunctorTestSuite<'a> for T {
        fn sample<A: 'a, F: FnMut(&'a dyn Fn(A) -> Self::F<A>)>(mut f: F) {
            f(&|_| None);
            f(&|a| Some(a));
        }
    }

    #[test]
    fn fmap_f_none_is_none() {
        assert_eq!(T::fmap(None, |_: ()| ()), None);
    }

    #[test]
    fn fmap_f_some_a_is_some_f_a() {
        assert_eq!(T::fmap(Some(2), |x| x * x), Some(4));
    }

    #[test]
    fn replace_none_b_is_none() {
        assert_eq!(T::replace(None::<i32>, 1), None);
        assert_eq!(T::void(None::<i32>), None);
    }

    #[test]
    fn replace_some_a_b_is_some_b() {
        assert_eq!(T::replace(Some(1), 2), Some(2));
        assert_eq!(T::void(Some(1)), Some(()));
    }

    #[test]
    fn monad_follows_laws() {
        test_suite::monad_follows_laws::<T>().unwrap();
    }
}