generic tests + CopyFunctor

src/copy_func.rs

@@ -0,0 +1,141 @@
+use super::func::*;
+
+pub trait CopyWeakFunctor {
+    type CF<A: Copy>;
+}
+
+pub trait CopyFunctor: CopyWeakFunctor {
+    fn copy_fmap<A: Copy, B: Copy, F: Fn(A) -> B>(f: F, fa: Self::CF<A>) -> Self::CF<B>;
+
+    fn copy_replace<A: Copy, B: Copy>(fa: Self::CF<A>, b: B) -> Self::CF<B> {
+        Self::copy_fmap(|_| b, fa)
+    }
+
+    fn copy_void<A: Copy>(fa: Self::CF<A>) -> Self::CF<()> {
+        Self::copy_replace(fa, ())
+    }
+}
+
+impl<T: WeakFunctor> CopyWeakFunctor for T {
+    type CF<A: Copy> = T::F<A>;
+}
+
+impl<T: Functor> CopyFunctor for T {
+    fn copy_fmap<A: Copy, B: Copy, F: Fn(A) -> B>(f: F, fa: Self::CF<A>) -> Self::CF<B> {
+        Self::fmap(f, fa)
+    }
+
+    fn copy_replace<A: Copy, B: Copy>(fa: Self::CF<A>, b: B) -> Self::CF<B> {
+        Self::replace(fa, b)
+    }
+
+    fn copy_void<A: Copy>(fa: Self::CF<A>) -> Self::CF<()> {
+        Self::void(fa)
+    }
+}
+
+pub trait CopyApplicativeSeq: CopyFunctor {
+    fn copy_seq<A: Copy, B: Copy, F: Copy + Fn(A) -> B>(
+        ff: Self::CF<F>,
+        fa: Self::CF<A>,
+    ) -> Self::CF<B>;
+
+    fn _copy_la2<A: Copy, B: Copy, C: Copy, F: Copy + Fn(A, B) -> C>(
+        f: F,
+        fa: Self::CF<A>,
+        fb: Self::CF<B>,
+    ) -> Self::CF<C> {
+        Self::copy_seq(Self::copy_fmap(|a| move |b| f(a, b), fa), fb)
+    }
+}
+
+impl<T: ApplicativeSeq> CopyApplicativeSeq for T {
+    fn copy_seq<A: Copy, B: Copy, F: Copy + Fn(A) -> B>(
+        ff: Self::CF<F>,
+        fa: Self::CF<A>,
+    ) -> Self::CF<B> {
+        Self::seq(ff, fa)
+    }
+}
+
+pub trait CopyApplicativeLA2: CopyFunctor {
+    fn copy_la2<A: Copy, B: Copy, C: Copy, F: Fn(A, B) -> C>(
+        f: F,
+        fa: Self::CF<A>,
+        fb: Self::CF<B>,
+    ) -> Self::CF<C>;
+
+    fn _copy_seq<A: Copy, B: Copy, F: Copy + Fn(A) -> B>(
+        ff: Self::CF<F>,
+        fa: Self::CF<A>,
+    ) -> Self::CF<B> {
+        Self::copy_la2(|f, a| f(a), ff, fa)
+    }
+}
+
+impl<T: ApplicativeLA2> CopyApplicativeLA2 for T {
+    fn copy_la2<A: Copy, B: Copy, C: Copy, F: Fn(A, B) -> C>(
+        f: F,
+        fa: Self::CF<A>,
+        fb: Self::CF<B>,
+    ) -> Self::CF<C> {
+        Self::la2(f, fa, fb)
+    }
+}
+
+pub trait CopyApplicative: CopyFunctor + CopyApplicativeSeq + CopyApplicativeLA2 {
+    fn copy_pure<A: Copy>(a: A) -> Self::CF<A>;
+
+    fn copy_discard_first<A: Copy, B: Copy>(fa: Self::CF<A>, fb: Self::CF<B>) -> Self::CF<B> {
+        Self::copy_seq(Self::copy_replace(fa, |b| b), fb)
+    }
+
+    fn copy_discard_second<A: Copy, B: Copy>(fa: Self::CF<A>, fb: Self::CF<B>) -> Self::CF<A> {
+        Self::copy_la2(|a, _| a, fa, fb)
+    }
+}
+
+impl<T: Applicative> CopyApplicative for T {
+    fn copy_pure<A: Copy>(a: A) -> Self::CF<A> {
+        Self::pure(a)
+    }
+
+    fn copy_discard_first<A: Copy, B: Copy>(fa: Self::CF<A>, fb: Self::CF<B>) -> Self::CF<B> {
+        Self::discard_first(fa, fb)
+    }
+
+    fn copy_discard_second<A: Copy, B: Copy>(fa: Self::CF<A>, fb: Self::CF<B>) -> Self::CF<A> {
+        Self::discard_second(fa, fb)
+    }
+}
+
+pub trait CopyMonad: CopyApplicative {
+    fn copy_bind<A: Copy, B: Copy, F: FnOnce(A) -> Self::CF<B>>(
+        fa: Self::CF<A>,
+        f: F,
+    ) -> Self::CF<B>;
+
+    fn copy_join<A: Copy>(ffa: Self::CF<Self::CF<A>>) -> Self::CF<A>
+    where
+        Self::CF<A>: Copy,
+    {
+        // ugly
+        Self::copy_bind(ffa, |fa| fa)
+    }
+}
+
+impl<T: Monad> CopyMonad for T {
+    fn copy_bind<A: Copy, B: Copy, F: FnOnce(A) -> Self::CF<B>>(
+        fa: Self::CF<A>,
+        f: F,
+    ) -> Self::CF<B> {
+        T::bind(fa, f)
+    }
+
+    fn copy_join<A: Copy>(ffa: Self::CF<Self::CF<A>>) -> Self::CF<A>
+    where
+        Self::CF<A>: Copy,
+    {
+        T::join(ffa)
+    }
+}

src/func.rs

@@ -1,6 +1,8 @@
-pub trait Functor {
+pub trait WeakFunctor {
-    type F<T>;
+    type F<A>;
+}
 
+pub trait Functor: WeakFunctor {
     fn fmap<A, B, F: FnOnce(A) -> B>(f: F, fa: Self::F<A>) -> Self::F<B>;
 
     fn replace<A, B>(fa: Self::F<A>, b: B) -> Self::F<B> {
@@ -14,28 +16,18 @@ pub trait Functor {
 
 pub trait ApplicativeSeq: Functor {
     fn seq<A, B, F: FnOnce(A) -> B>(ff: Self::F<F>, fa: Self::F<A>) -> Self::F<B>;
+    fn _la2<A, B, C, F: FnOnce(A, B) -> C>(f: F, fa: Self::F<A>, fb: Self::F<B>) -> Self::F<C> {
+        Self::seq(Self::fmap(|a| |b| f(a, b), fa), fb)
+    }
 }
 
 pub trait ApplicativeLA2: Functor {
     fn la2<A, B, C, F: FnOnce(A, B) -> C>(f: F, fa: Self::F<A>, fb: Self::F<B>) -> Self::F<C>;
-}
+    fn _seq<A, B, F: FnOnce(A) -> B>(ff: Self::F<F>, fa: Self::F<A>) -> Self::F<B> {
-
-pub trait ApplicativeSeqOnly: ApplicativeSeq {}
-
-pub trait ApplicativeLA2Only: ApplicativeLA2 {}
-
-impl<T: ApplicativeLA2Only> ApplicativeSeq for T {
-    fn seq<A, B, F: FnOnce(A) -> B>(ff: Self::F<F>, fa: Self::F<A>) -> Self::F<B> {
         Self::la2(|f, a| f(a), ff, fa)
     }
 }
 
-impl<T: ApplicativeSeqOnly> ApplicativeLA2 for T {
-    fn la2<A, B, C, F: FnOnce(A, B) -> C>(f: F, fa: Self::F<A>, fb: Self::F<B>) -> Self::F<C> {
-        Self::seq(Self::fmap(|a| |b| f(a, b), fa), fb)
-    }
-}
-
 pub trait Applicative: Functor + ApplicativeSeq + ApplicativeLA2 {
     fn pure<A>(a: A) -> Self::F<A>;
 
@@ -56,80 +48,75 @@ pub trait Monad: Applicative {
     }
 }
 
-pub struct OptionClass;
-
-impl Functor for OptionClass {
-    type F<T> = Option<T>;
-
-    fn fmap<A, B, F: FnOnce(A) -> B>(f: F, fa: Self::F<A>) -> Self::F<B> {
-        match fa {
-            Some(a) => Some(f(a)),
-            None => None,
-        }
-    }
-
-    fn replace<A, B>(fa: Self::F<A>, b: B) -> Self::F<B> {
-        match fa {
-            Some(_) => Some(b),
-            None => None,
-        }
-    }
-}
-
-impl ApplicativeSeq for OptionClass {
-    fn seq<A, B, F: FnOnce(A) -> B>(ff: Self::F<F>, fa: Self::F<A>) -> Self::F<B> {
-        match (ff, fa) {
-            (Some(f), Some(a)) => Some(f(a)),
-            _ => None,
-        }
-    }
-}
-
-impl ApplicativeLA2 for OptionClass {
-    fn la2<A, B, C, F: FnOnce(A, B) -> C>(f: F, fa: Self::F<A>, fb: Self::F<B>) -> Self::F<C> {
-        match (fa, fb) {
-            (Some(a), Some(b)) => Some(f(a, b)),
-            _ => None,
-        }
-    }
-}
-
-impl Applicative for OptionClass {
-    fn pure<A>(a: A) -> Self::F<A> {
-        Some(a)
-    }
-
-    fn discard_first<A, B>(fa: Self::F<A>, fb: Self::F<B>) -> Self::F<B> {
-        match fa {
-            Some(_) => fb,
-            None => None,
-        }
-    }
-}
-
-impl Monad for OptionClass {
-    fn bind<A, B, F: FnOnce(A) -> Self::F<B>>(fa: Self::F<A>, f: F) -> Self::F<B> {
-        match fa {
-            Some(a) => f(a),
-            None => None,
-        }
-    }
-}
-
 #[cfg(test)]
-mod tests {
+pub mod tests {
     use super::*;
     use core::fmt::Debug;
+    use std::ops::{Add, AddAssign};
 
-    pub fn make_none<T>(_: Option<T>) -> Option<T> {
+    pub struct TestResults(usize, usize, Result<(), String>);
-        None
+
+    pub type R = TestResults;
+
+    impl R {
+        pub fn unwrap(self) {
+            match self {
+                TestResults(success, total, Err(e)) => panic!("failed:\n{success}/{total}\n{e}\n"),
+                _ => (),
+            };
+        }
     }
 
-    pub fn fmap_respects_identity<T: Functor, A, FA0: Fn() -> T::F<A>>(fa0: FA0)
+    fn eqr<T: PartialEq + Debug>(name: &str, left: T, right: T) -> R {
+        if left == right {
+            TestResults(1, 1, Ok(()))
+        } else {
+            TestResults(0, 1, Err(format!("{name}: {:?} != {:?}", left, right)))
+        }
+    }
+
+    impl Default for R {
+        fn default() -> Self {
+            Self(0, 0, Ok(()))
+        }
+    }
+
+    impl Add for R {
+        type Output = R;
+
+        fn add(self, rhs: Self) -> Self::Output {
+            Self(
+                self.0 + rhs.0,
+                self.1 + rhs.1,
+                match (self.2, rhs.2) {
+                    (Err(le), Err(re)) => Err(le + "\n" + re.as_str()),
+                    (e, Ok(_)) => e,
+                    (Ok(_), e) => e,
+                },
+            )
+        }
+    }
+
+    impl AddAssign<R> for R {
+        fn add_assign(&mut self, rhs: R) {
+            self.0 += rhs.0;
+            self.1 += rhs.1;
+            match (&mut self.2, rhs.2) {
+                (Err(ref mut le), Err(re)) => {
+                    *le += "\n";
+                    *le += re.as_str()
+                }
+                (_, Ok(_)) => {}
+                (lr, Err(re)) => *lr = Err(re),
+            }
+        }
+    }
+
+    pub fn fmap_respects_identity<T: Functor, A, FA0: Fn() -> T::F<A>>(fa0: FA0) -> R
     where
         T::F<A>: Debug + PartialEq,
     {
-        assert_eq!(T::fmap(|a| a, fa0()), fa0());
+        eqr("identity: fmap id == id", T::fmap(|a| a, fa0()), fa0())
     }
 
     pub fn fmap_respects_composition<
@@ -144,17 +131,26 @@ mod tests {
         f: F,
         g: G,
         fa0: FA0,
-    ) where
+    ) -> R
+    where
         T::F<C>: Debug + PartialEq,
     {
-        assert_eq!(T::fmap(|a| f(g(a)), fa0()), T::fmap(f, T::fmap(g, fa0())));
+        eqr(
+            "composition: fmap (f . g) == fmap f . fmap g",
+            T::fmap(|a| f(g(a)), fa0()),
+            T::fmap(f, T::fmap(g, fa0())),
+        )
     }
 
-    pub fn seq_respects_identity<T: Applicative, A, FA0: Fn() -> T::F<A>>(fa0: FA0)
+    pub fn seq_respects_identity<T: Applicative, A, FA0: Fn() -> T::F<A>>(fa0: FA0) -> R
     where
         T::F<A>: Debug + PartialEq,
     {
-        assert_eq!(T::seq(T::pure(|a| a), fa0()), fa0());
+        eqr(
+            "identity: pure id <*> v = v",
+            T::seq(T::pure(|a| a), fa0()),
+            fa0(),
+        )
     }
 
     pub fn seq_respects_composition<
@@ -171,28 +167,35 @@ mod tests {
         ff0: FF0,
         fg0: FG0,
         fa0: FA0,
-    ) where
+    ) -> R
+    where
         T::F<C>: Debug + PartialEq,
     {
-        assert_eq!(
+        eqr(
+            "composition: pure (.) <*> u <*> v <*> w = u <*> (v <*> w)",
             T::seq(
                 T::seq(
                     T::seq(T::pure(|f: F| |g: G| move |a| f(g(a))), ff0()),
-                    fg0()
+                    fg0(),
                 ),
-                fa0()
+                fa0(),
             ),
-            T::seq(ff0(), T::seq(fg0(), fa0()))
+            T::seq(ff0(), T::seq(fg0(), fa0())),
-        );
+        )
     }
 
     pub fn seq_is_homomorphic<T: Applicative, A, B, A0: Fn() -> A, F: Copy + Fn(A) -> B>(
         f: F,
         a0: A0,
-    ) where
+    ) -> R
+    where
         T::F<B>: Debug + PartialEq,
     {
-        assert_eq!(T::seq(T::pure(f), T::pure(a0())), T::pure(f(a0())));
+        eqr(
+            "homomorphism: pure f <*> pure x = pure (f x)",
+            T::seq(T::pure(f), T::pure(a0())),
+            T::pure(f(a0())),
+        )
     }
 
     pub fn seq_respects_interchange<
@@ -205,13 +208,15 @@ mod tests {
     >(
         ff0: FF0,
         a0: A0,
-    ) where
+    ) -> R
+    where
         T::F<B>: Debug + PartialEq,
     {
-        assert_eq!(
+        eqr(
+            "interchange: u <*> pure y = pure ($ y) <*> u",
             T::seq(ff0(), T::pure(a0())),
-            T::seq(T::pure(|f: F| f(a0())), ff0())
+            T::seq(T::pure(|f: F| f(a0())), ff0()),
-        );
+        )
     }
 
     pub fn seq_can_be_expressed_via_la2<
@@ -224,10 +229,15 @@ mod tests {
     >(
         ff0: FF0,
         fa0: FA0,
-    ) where
+    ) -> R
+    where
         T::F<B>: Debug + PartialEq,
     {
-        assert_eq!(T::seq(ff0(), fa0()), T::la2(|f, a| f(a), ff0(), fa0()));
+        eqr(
+            "seq via la2: (<*>) = liftA2 id",
+            T::seq(ff0(), fa0()),
+            T::la2(|f, a| f(a), ff0(), fa0()),
+        )
     }
 
     pub fn fmap_can_be_expressed_via_seq<
@@ -239,10 +249,15 @@ mod tests {
     >(
         f: F,
         fa0: FA0,
-    ) where
+    ) -> R
+    where
         T::F<B>: Debug + PartialEq,
     {
-        assert_eq!(T::fmap(f, fa0()), T::seq(T::pure(f), fa0()));
+        eqr(
+            "fmap via seq: fmap f x = pure f <*> x",
+            T::fmap(f, fa0()),
+            T::seq(T::pure(f), fa0()),
+        )
     }
 
     pub fn discard_can_be_expressed_via_seq_or_la2<
@@ -254,33 +269,44 @@ mod tests {
     >(
         fa0: FA0,
         fb0: FB0,
-    ) where
+    ) -> R
+    where
         T::F<B>: Debug + PartialEq,
     {
-        assert_eq!(
+        eqr(
+            "discard via seq: u *> v = (id <$ u) <*> v",
             T::discard_first(fa0(), fb0()),
-            T::seq(T::replace(fa0(), |b| b), fb0())
+            T::seq(T::replace(fa0(), |b| b), fb0()),
-        );
+        ) + eqr(
-        assert_eq!(
+            "discard via la2: u <* v = liftA2 const u v",
             T::discard_second(fb0(), fa0()),
-            T::la2(|b, _| b, fb0(), fa0())
+            T::la2(|b, _| b, fb0(), fa0()),
-        );
+        )
     }
 
     pub fn bind_respects_left_identity<T: Monad, A, B, F: Copy + Fn(A) -> T::F<B>, A0: Fn() -> A>(
         f: F,
         a0: A0,
-    ) where
+    ) -> R
+    where
         T::F<B>: Debug + PartialEq,
     {
-        assert_eq!(T::bind(T::pure(a0()), f), f(a0()));
+        eqr(
+            "left identity: pure a >>= k = k a",
+            T::bind(T::pure(a0()), f),
+            f(a0()),
+        )
     }
 
-    pub fn bind_respects_right_identity<T: Monad, A, FA0: Fn() -> T::F<A>>(fa0: FA0)
+    pub fn bind_respects_right_identity<T: Monad, A, FA0: Fn() -> T::F<A>>(fa0: FA0) -> R
     where
         T::F<A>: Debug + PartialEq,
     {
-        assert_eq!(T::bind(fa0(), T::pure), fa0());
+        eqr(
+            "right identity: m >>= bind = m",
+            T::bind(fa0(), T::pure),
+            fa0(),
+        )
     }
 
     pub fn bind_is_associative<
@@ -295,13 +321,15 @@ mod tests {
         f: F,
         g: G,
         fa0: FA0,
-    ) where
+    ) -> R
+    where
         T::F<C>: Debug + PartialEq,
     {
-        assert_eq!(
+        eqr(
+            r"associativity: m >>= (\x -> k x >>= h) = (m >>= k) >>= h",
             T::bind(fa0(), |a| T::bind(g(a), f)),
-            T::bind(T::bind(fa0(), g), f)
+            T::bind(T::bind(fa0(), g), f),
-        );
+        )
     }
 
     pub fn seq_can_be_expressed_via_bind<
@@ -314,13 +342,15 @@ mod tests {
     >(
         ff0: FF0,
         fa0: FA0,
-    ) where
+    ) -> R
+    where
         T::F<B>: Debug + PartialEq,
     {
-        assert_eq!(
+        eqr(
+            r"seq via bind: m1 <*> m2 = m1 >>= (\x1 -> m2 >>= (\x2 -> pure (x1 x2)))",
             T::seq(ff0(), fa0()),
-            T::bind(ff0(), |f| T::bind(fa0(), |a| T::pure(f(a))))
+            T::bind(ff0(), |f| T::bind(fa0(), |a| T::pure(f(a)))),
-        );
+        )
     }
 
     pub fn fmap_can_be_expressed_via_bind<
@@ -332,195 +362,115 @@ mod tests {
     >(
         f: F,
         fa0: FA0,
-    ) where
+    ) -> R
+    where
         T::F<B>: Debug + PartialEq,
     {
-        assert_eq!(T::fmap(f, fa0()), T::bind(fa0(), |a| T::pure(f(a))));
+        eqr(
+            "fmap via bind: fmap f xs  =  xs >>= return . f",
+            T::fmap(f, fa0()),
+            T::bind(fa0(), |a| T::pure(f(a))),
+        )
     }
 }
 
 #[cfg(test)]
-mod option_tests {
+pub mod test_suite {
-    use crate::func::tests;
+    use std::fmt::Debug;
 
-    use super::{tests::make_none, Functor, OptionClass as T};
+    use super::tests::*;
+    use super::*;
 
-    #[test]
+    pub trait FunctorTestSuite: WeakFunctor {
-    fn fmap_f_none_is_none() {
+        fn sample<A>() -> Vec<Box<dyn Fn(A) -> Self::F<A>>>;
-        assert_eq!(T::fmap(|_: ()| (), None), None);
     }
 
-    #[test]
+    pub fn functor_follows_laws<T: Functor + FunctorTestSuite>() -> R
-    fn fmap_f_some_a_is_some_f_a() {
+    where
-        assert_eq!(T::fmap(|x| x * x, Some(2)), Some(4));
+        T::F<i32>: Debug + PartialEq,
+    {
+        let mut res = R::default();
+        for pa in T::sample::<_>() {
+            res += fmap_respects_identity::<T, _, _>(|| pa(2));
+        }
+        for pa in T::sample::<_>() {
+            res += fmap_respects_composition::<T, _, _, _, _, _, _>(|x| x + 5, |x| x + 3, || pa(2));
+        }
+        res
     }
 
-    #[test]
+    pub fn applicative_follows_laws<T: Applicative + FunctorTestSuite>() -> R
-    fn fmap_respects_identity() {
+    where
-        tests::fmap_respects_identity::<T, _, _>(|| None::<i32>);
+        T::F<i32>: Debug + PartialEq,
-        tests::fmap_respects_identity::<T, _, _>(|| Some(1));
+    {
+        let mut res = functor_follows_laws::<T>();
+        for pa in T::sample::<_>() {
+            res += seq_respects_identity::<T, _, _>(|| pa(2));
         }
-
+        for pa in T::sample::<_>() {
-    #[test]
+            for pg in T::sample::<_>() {
-    fn fmap_respects_composition() {
+                for pf in T::sample::<_>() {
-        tests::fmap_respects_composition::<T, _, _, _, _, _, _>(
+                    res += seq_respects_composition::<T, _, _, _, _, _, _, _, _>(
-            |x| x + 5,
+                        || pf(|x| x + 5),
-            |x| x + 3,
+                        || pg(|x| x + 3),
-            || None::<i32>,
+                        || pa(2),
-        );
-        tests::fmap_respects_composition::<T, _, _, _, _, _, _>(|x| x + 5, |x| x + 3, || Some(2));
-    }
-
-    #[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 seq_respects_identity() {
-        tests::seq_respects_identity::<T, _, _>(|| None::<i32>);
-        tests::seq_respects_identity::<T, _, _>(|| Some(1));
-    }
-
-    #[test]
-    fn seq_respects_composition() {
-        tests::seq_respects_composition::<T, _, _, _, _, _, _, _, _>(
-            || Some(|x| x + 5),
-            || Some(|x| x + 3),
-            || Some(2),
-        );
-        tests::seq_respects_composition::<T, _, _, _, _, _, _, _, _>(
-            || tests::make_none(Some(|x| x + 5)),
-            || Some(|x| x + 3),
-            || Some(2),
-        );
-        tests::seq_respects_composition::<T, _, _, _, _, _, _, _, _>(
-            || Some(|x| x + 5),
-            || tests::make_none(Some(|x| x + 3)),
-            || Some(2),
-        );
-        tests::seq_respects_composition::<T, _, _, _, _, _, _, _, _>(
-            || Some(|x| x + 5),
-            || Some(|x| x + 3),
-            || None::<i32>,
-        );
-        tests::seq_respects_composition::<T, _, _, _, _, _, _, _, _>(
-            || tests::make_none(Some(|x| x + 5)),
-            || tests::make_none(Some(|x| x + 3)),
-            || None::<i32>,
                     );
                 }
-
+            }
-    #[test]
+        }
-    fn seq_is_homomorphic() {
+        res += seq_is_homomorphic::<T, _, _, _, _>(|x| x + 3, || 2);
-        tests::seq_is_homomorphic::<T, _, _, _, _>(|x| x + 3, || 2);
+        for pf in T::sample::<_>() {
+            res += seq_respects_interchange::<T, _, _, _, _, _>(|| pf(|x| x + 3), || 2);
+        }
+        for pa in T::sample::<_>() {
+            for pf in T::sample::<_>() {
+                res += seq_can_be_expressed_via_la2::<T, _, _, _, _, _>(|| pf(|x| x + 3), || pa(2));
+            }
+        }
+        for pa in T::sample::<_>() {
+            res += fmap_can_be_expressed_via_seq::<T, _, _, _, _>(|x| x + 3, || pa(2));
+        }
+        for pa in T::sample::<_>() {
+            for pb in T::sample::<_>() {
+                res += discard_can_be_expressed_via_seq_or_la2::<T, _, _, _, _>(|| pa(2), || pb(2));
+            }
+        }
+        res
     }
 
-    #[test]
+    pub fn monad_follows_laws<T: Monad + FunctorTestSuite>() -> R
-    fn seq_respects_interchange() {
+    where
-        tests::seq_respects_interchange::<T, _, _, _, _, _>(|| Some(|x| x + 3), || 2);
+        T::F<i32>: Debug + PartialEq,
-        tests::seq_respects_interchange::<T, _, _, _, _, _>(|| make_none(Some(|x| x + 3)), || 2);
+    {
+        let mut res = applicative_follows_laws::<T>();
+        for pa in T::sample::<_>() {
+            res += bind_respects_left_identity::<T, _, _, _, _>(|x| pa(x + 3), || 2);
         }
-
+        for pa in T::sample::<_>() {
-    #[test]
+            res += bind_respects_right_identity::<T, _, _>(|| pa(2));
-    fn seq_can_be_expressed_via_la2() {
+        }
-        tests::seq_can_be_expressed_via_la2::<T, _, _, _, _, _>(|| Some(|x| x + 3), || Some(2));
+        for pa in T::sample::<_>() {
-        tests::seq_can_be_expressed_via_la2::<T, _, _, _, _, _>(
+            for pg in T::sample::<_>() {
-            || make_none(Some(|x| x + 3)),
+                for pf in T::sample::<_>() {
-            || Some(2),
+                    res += bind_is_associative::<T, _, _, _, _, _, _>(
-        );
+                        |x| pf(x + 5),
-        tests::seq_can_be_expressed_via_la2::<T, _, _, _, _, _>(|| Some(|x| x + 3), || None::<i32>);
+                        |x| pg(x + 3),
-        tests::seq_can_be_expressed_via_la2::<T, _, _, _, _, _>(
+                        || pa(2),
-            || make_none(Some(|x| x + 3)),
-            || None::<i32>,
                     );
                 }
-
-    #[test]
-    fn fmap_can_be_expressed_via_seq() {
-        tests::fmap_can_be_expressed_via_seq::<T, _, _, _, _>(|x| x + 3, || Some(2));
-        tests::fmap_can_be_expressed_via_seq::<T, _, _, _, _>(|x| x + 3, || None::<i32>);
             }
-
+        }
-    #[test]
+        for pa in T::sample::<_>() {
-    fn discard_can_be_expressed_via_seq_or_la2() {
+            for pf in T::sample::<_>() {
-        tests::discard_can_be_expressed_via_seq_or_la2::<T, _, _, _, _>(|| Some(2), || Some(3));
+                res += seq_can_be_expressed_via_bind::<T, _, _, _, _, _>(
-        tests::discard_can_be_expressed_via_seq_or_la2::<T, _, _, _, _>(|| Some(2), || None::<i32>);
+                    || pf(|x| x + 3),
-        tests::discard_can_be_expressed_via_seq_or_la2::<T, _, _, _, _>(|| None::<i32>, || Some(3));
+                    || pa(2),
-        tests::discard_can_be_expressed_via_seq_or_la2::<T, _, _, _, _>(
-            || None::<i32>,
-            || None::<i32>,
                 );
             }
-
-    #[test]
-    fn bind_respects_left_identity() {
-        tests::bind_respects_left_identity::<T, _, _, _, _>(|x| Some(x + 3), || 2);
-        tests::bind_respects_left_identity::<T, _, _, _, _>(|_| None::<i32>, || 2);
         }
-
+        for pa in T::sample::<_>() {
-    #[test]
+            res += fmap_can_be_expressed_via_bind::<T, _, _, _, _>(|x| x + 3, || pa(2));
-    fn bind_respects_right_identity() {
-        tests::bind_respects_right_identity::<T, _, _>(|| Some(1));
-        tests::bind_respects_right_identity::<T, _, _>(|| None::<i32>);
         }
-
+        res
-    #[test]
-    fn bind_is_associative() {
-        tests::bind_is_associative::<T, _, _, _, _, _, _>(
-            |x| Some(x + 5),
-            |x| Some(x + 3),
-            || Some(2),
-        );
-        tests::bind_is_associative::<T, _, _, _, _, _, _>(
-            |_| None::<i32>,
-            |x| Some(x + 3),
-            || Some(2),
-        );
-        tests::bind_is_associative::<T, _, _, _, _, _, _>(
-            |x| Some(x + 5),
-            |_| None::<i32>,
-            || Some(2),
-        );
-        tests::bind_is_associative::<T, _, _, _, _, _, _>(
-            |x| Some(x + 5),
-            |x| Some(x + 3),
-            || None::<i32>,
-        );
-        tests::bind_is_associative::<T, _, _, _, _, _, _>(
-            |_| None::<i32>,
-            |_| None::<i32>,
-            || None::<i32>,
-        );
-    }
-
-    #[test]
-    fn seq_can_be_expressed_via_bind() {
-        tests::seq_can_be_expressed_via_bind::<T, _, _, _, _, _>(|| Some(|x| x + 3), || Some(2));
-        tests::seq_can_be_expressed_via_bind::<T, _, _, _, _, _>(
-            || Some(|x| x + 3),
-            || None::<i32>,
-        );
-        tests::seq_can_be_expressed_via_bind::<T, _, _, _, _, _>(
-            || make_none(Some(|x| x + 3)),
-            || Some(2),
-        );
-        tests::seq_can_be_expressed_via_bind::<T, _, _, _, _, _>(
-            || make_none(Some(|x| x + 3)),
-            || None::<i32>,
-        );
-    }
-
-    #[test]
-    fn fmap_can_be_expressed_via_bind() {
-        tests::fmap_can_be_expressed_via_bind::<T, _, _, _, _>(|x| x + 3, || Some(2));
-        tests::fmap_can_be_expressed_via_bind::<T, _, _, _, _>(|x| x + 3, || None::<i32>);
     }
 }

src/lib.rs

@@ -1,2 +1,4 @@
 pub mod core;
 pub mod func;
+pub mod optionclass;
+pub mod copy_func;

src/optionclass.rs

@@ -0,0 +1,117 @@
+use crate::func::*;
+
+pub struct OptionClass;
+
+impl WeakFunctor for OptionClass {
+    type F<A> = Option<A>;
+}
+
+impl Functor for OptionClass {
+    fn fmap<A, B, F: FnOnce(A) -> B>(f: F, fa: Self::F<A>) -> Self::F<B> {
+        match fa {
+            Some(a) => Some(f(a)),
+            None => None,
+        }
+    }
+
+    fn replace<A, B>(fa: Self::F<A>, b: B) -> Self::F<B> {
+        match fa {
+            Some(_) => Some(b),
+            None => None,
+        }
+    }
+}
+
+impl ApplicativeSeq for OptionClass {
+    fn seq<A, B, F: FnOnce(A) -> B>(ff: Self::F<F>, fa: Self::F<A>) -> Self::F<B> {
+        match (ff, fa) {
+            (Some(f), Some(a)) => Some(f(a)),
+            _ => None,
+        }
+    }
+}
+
+impl ApplicativeLA2 for OptionClass {
+    fn la2<A, B, C, F: FnOnce(A, B) -> C>(f: F, fa: Self::F<A>, fb: Self::F<B>) -> Self::F<C> {
+        match (fa, fb) {
+            (Some(a), Some(b)) => Some(f(a, b)),
+            _ => None,
+        }
+    }
+}
+
+impl Applicative for OptionClass {
+    fn pure<A>(a: A) -> Self::F<A> {
+        Some(a)
+    }
+
+    fn discard_first<A, B>(fa: Self::F<A>, fb: Self::F<B>) -> Self::F<B> {
+        match fa {
+            Some(_) => fb,
+            None => None,
+        }
+    }
+
+    fn discard_second<A, B>(fa: Self::F<A>, fb: Self::F<B>) -> Self::F<A> {
+        match fb {
+            Some(_) => fa,
+            None => None,
+        }
+    }
+}
+
+impl Monad for OptionClass {
+    fn bind<A, B, F: FnOnce(A) -> Self::F<B>>(fa: Self::F<A>, f: F) -> Self::F<B> {
+        match fa {
+            Some(a) => f(a),
+            None => None,
+        }
+    }
+
+    fn join<A>(ffa: Self::F<Self::F<A>>) -> Self::F<A> {
+        match ffa {
+            Some(Some(a)) => Some(a),
+            _ => None,
+        }
+    }
+}
+
+#[cfg(test)]
+mod option_tests {
+    use super::test_suite;
+
+    use super::{Functor, OptionClass as T};
+
+    impl test_suite::FunctorTestSuite for T {
+        fn sample<A>() -> Vec<Box<dyn Fn(A) -> Self::F<A>>> {
+            vec![Box::new(|_| None), Box::new(|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(|x| x * x, Some(2)), 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();
+    }
+}