ToEq

src/func/instances/composition.rs

@@ -187,13 +187,11 @@ mod composition_tests {
 
     type T = CompositionInstance<OptionInstance, ResultInstance<i32>>;
 
-    impl<'a> tests::Eqr<'a> for T {
+    impl<'a> tests::ToEq<'a> for T {
-        fn eqr<A: 'a + Send + PartialEq + std::fmt::Debug>(
+        type Eq<A: 'a + Send + PartialEq + std::fmt::Debug> = Self::F<A>;
-            name: &'a str,
+
-            left: Self::F<A>,
+        fn to_eq<A: 'a + Send + PartialEq + std::fmt::Debug>(fa: Self::F<A>) -> Self::Eq<A> {
-            right: Self::F<A>,
+            fa
-        ) -> tests::R {
-            tests::eqr(name, left, right)
         }
     }
 
@@ -234,6 +232,11 @@ mod composition_tests {
         test_suite::fail_functor_follows_laws::<T, _>().unwrap();
     }
 
+    #[test]
+    fn local_follows_laws() {
+        test_suite::local_follows_laws::<T>().unwrap();
+    }
+
     #[test]
     fn select_second() {
         type T = CompositionInstance<TryFutureInstance<i32>, ResultInstance<i32>>;

src/func/instances/effect.rs

@@ -221,17 +221,11 @@ mod effect_tests {
 
     type T = EffectInstance<TestEffect>;
 
-    impl<'a> tests::Eqr<'a> for T {
+    impl<'a> tests::ToEq<'a> for T {
-        fn eqr<A: 'a + Send + PartialEq + std::fmt::Debug>(
+        type Eq<A: 'a + Send + PartialEq + std::fmt::Debug> = (A, Arc<TestEffect>);
-            name: &'a str,
+
-            left: Self::F<A>,
+        fn to_eq<A: 'a + Send + PartialEq + std::fmt::Debug>(fa: Self::F<A>) -> Self::Eq<A> {
-            right: Self::F<A>,
+            (fa.value, fa.effect.simplify())
-        ) -> tests::R {
-            tests::eqr(
-                name,
-                (left.value, left.effect.simplify()),
-                (right.value, right.effect.simplify()),
-            )
         }
     }
 

src/func/instances/future.rs

@@ -141,23 +141,17 @@ impl<'a> SharedFunctor<'a> for FutureInstance {
 mod future_tests {
     use std::sync::Arc;
 
-    use crate::func::{applicative_select::Selected, tests::Eqr, ApplicativeSelect};
+    use crate::func::{applicative_select::Selected, ApplicativeSelect};
 
     use super::{test_suite, tests, FutureInstance};
 
     type T = FutureInstance;
 
-    impl<'a> Eqr<'a> for T {
+    impl<'a> tests::ToEq<'a> for T {
-        fn eqr<A: 'a + Send + PartialEq + std::fmt::Debug>(
+        type Eq<A: 'a + Send + PartialEq + std::fmt::Debug> = A;
-            name: &'a str,
+
-            left: Self::F<A>,
+        fn to_eq<A: 'a + Send + PartialEq + std::fmt::Debug>(fa: Self::F<A>) -> Self::Eq<A> {
-            right: Self::F<A>,
+            futures::executor::block_on(fa)
-        ) -> tests::R {
-            tests::eqr(
-                name,
-                futures::executor::block_on(left),
-                futures::executor::block_on(right),
-            )
         }
     }
 

src/func/instances/lazy.rs

@@ -111,13 +111,11 @@ mod lazy_tests {
 
     type T = LazyInstance;
 
-    impl<'a> tests::Eqr<'a> for T {
+    impl<'a> tests::ToEq<'a> for T {
-        fn eqr<A: 'a + Send + PartialEq + std::fmt::Debug>(
+        type Eq<A: 'a + Send + PartialEq + std::fmt::Debug> = A;
-            name: &'a str,
+
-            left: Self::F<A>,
+        fn to_eq<A: 'a + Send + PartialEq + std::fmt::Debug>(fa: Self::F<A>) -> Self::Eq<A> {
-            right: Self::F<A>,
+            fa()
-        ) -> tests::R {
-            tests::eqr(name, left(), right())
         }
     }
 

src/func/instances/option.rs

@@ -146,13 +146,11 @@ mod option_tests {
 
     use super::OptionInstance as T;
 
-    impl<'a> tests::Eqr<'a> for T {
+    impl<'a> tests::ToEq<'a> for T {
-        fn eqr<A: 'a + Send + PartialEq + std::fmt::Debug>(
+        type Eq<A: 'a + Send + PartialEq + std::fmt::Debug> = Self::F<A>;
-            name: &'a str,
+
-            left: Self::F<A>,
+        fn to_eq<A: 'a + Send + PartialEq + std::fmt::Debug>(fa: Self::F<A>) -> Self::Eq<A> {
-            right: Self::F<A>,
+            fa
-        ) -> tests::R {
-            tests::eqr(name, left, right)
         }
     }
 
@@ -207,4 +205,9 @@ mod option_tests {
     fn fail_follows_laws() {
         test_suite::fail_functor_follows_laws::<T, _>().unwrap();
     }
+
+    #[test]
+    fn local_follows_laws() {
+        test_suite::local_follows_laws::<T>().unwrap();
+    }
 }

src/func/instances/result.rs

@@ -254,13 +254,11 @@ mod result_tests {
 
     type T = ResultInstance<i32>;
 
-    impl<'a> tests::Eqr<'a> for T {
+    impl<'a> tests::ToEq<'a> for T {
-        fn eqr<A: 'a + Send + PartialEq + std::fmt::Debug>(
+        type Eq<A: 'a + Send + PartialEq + std::fmt::Debug> = Self::F<A>;
-            name: &'a str,
+
-            left: Self::F<A>,
+        fn to_eq<A: 'a + Send + PartialEq + std::fmt::Debug>(fa: Self::F<A>) -> Self::Eq<A> {
-            right: Self::F<A>,
+            fa
-        ) -> tests::R {
-            tests::eqr(name, left, right)
         }
     }
 

src/func/instances/solo.rs

@@ -125,13 +125,11 @@ mod solo_tests {
 
     type T = SoloInstance;
 
-    impl<'a> tests::Eqr<'a> for T {
+    impl<'a> tests::ToEq<'a> for T {
-        fn eqr<A: 'a + Send + PartialEq + std::fmt::Debug>(
+        type Eq<A: 'a + Send + PartialEq + std::fmt::Debug> = Self::F<A>;
-            name: &'a str,
+
-            left: Self::F<A>,
+        fn to_eq<A: 'a + Send + PartialEq + std::fmt::Debug>(fa: Self::F<A>) -> Self::Eq<A> {
-            right: Self::F<A>,
+            fa
-        ) -> tests::R {
-            tests::eqr(name, left, right)
         }
     }
 
@@ -152,4 +150,9 @@ mod solo_tests {
     fn shared_follows_laws() {
         test_suite::shared_follows_laws::<T>().unwrap();
     }
+
+    #[test]
+    fn local_follows_laws() {
+        test_suite::local_follows_laws::<T>().unwrap();
+    }
 }

src/func/instances/stackless.rs

@@ -270,13 +270,11 @@ mod stackless_test {
 
     use super::StacklessInstance as T;
 
-    impl<'a> tests::Eqr<'a> for T {
+    impl<'a> tests::ToEq<'a> for T {
-        fn eqr<A: 'a + Send + PartialEq + std::fmt::Debug>(
+        type Eq<A: 'a + Send + PartialEq + std::fmt::Debug> = A;
-            name: &'a str,
+
-            left: Self::F<A>,
+        fn to_eq<A: 'a + Send + PartialEq + std::fmt::Debug>(fa: Self::F<A>) -> Self::Eq<A> {
-            right: Self::F<A>,
+            fa.evaluate()
-        ) -> tests::R {
-            tests::eqr(name, left.evaluate(), right.evaluate())
         }
     }
 

src/func/instances/tryfuture.rs

@@ -207,23 +207,17 @@ impl<'a> MonadFailAny<'a> for FutureFailAny {
 mod tryfuture_tests {
     use std::sync::Arc;
 
-    use crate::func::{applicative_select::Selected, tests::Eqr, ApplicativeSelect};
+    use crate::func::{applicative_select::Selected, ApplicativeSelect};
 
     use super::{test_suite, tests, TryFutureInstance};
 
     type T = TryFutureInstance<i32>;
 
-    impl<'a> Eqr<'a> for T {
+    impl<'a> tests::ToEq<'a> for T {
-        fn eqr<A: 'a + Send + PartialEq + std::fmt::Debug>(
+        type Eq<A: 'a + Send + PartialEq + std::fmt::Debug> = Result<A, i32>;
-            name: &'a str,
+
-            left: Self::F<A>,
+        fn to_eq<A: 'a + Send + PartialEq + std::fmt::Debug>(fa: Self::F<A>) -> Self::Eq<A> {
-            right: Self::F<A>,
+            futures::executor::block_on(fa)
-        ) -> tests::R {
-            tests::eqr(
-                name,
-                futures::executor::block_on(left),
-                futures::executor::block_on(right),
-            )
         }
     }
 

src/func/tests.rs

@@ -40,6 +40,22 @@ pub trait Eqr<'a>: WeakFunctor<'a> {
     ) -> R;
 }
 
+pub trait ToEq<'a>: WeakFunctor<'a> {
+    type Eq<A: 'a + Send + PartialEq + Debug>: PartialEq + Debug;
+
+    fn to_eq<A: 'a + Send + PartialEq + Debug>(fa: Self::F<A>) -> Self::Eq<A>;
+}
+
+impl<'a, T: ToEq<'a>> Eqr<'a> for T {
+    fn eqr<A: 'a + Send + PartialEq + Debug>(
+        name: &'a str,
+        left: Self::F<A>,
+        right: Self::F<A>,
+    ) -> R {
+        eqr(name, Self::to_eq(left), Self::to_eq(right))
+    }
+}
+
 pub fn eqr<T: PartialEq + Debug>(name: &str, left: T, right: T) -> R {
     if left == right {
         TestResults {