From 6a19cdaf812d4c7b36fc803e7cf8265b8ec5c56d Mon Sep 17 00:00:00 2001
From: timofey <tim@ongoteam.yaconnect.com>
Date: Mon, 24 Apr 2023 22:45:43 +0000
Subject: [PATCH] MonadFailAny + MonadFailOver + Context::Fallible

---
 src/core.rs                     |  2 ++
 src/func.rs                     | 20 ++++++++++++
 src/func/classes/composition.rs |  8 +++++
 src/func/classes/result.rs      | 56 +++++++++++++++++++++++++++++++++
 src/testing.rs                  |  2 ++
 src/testing/counted.rs          |  2 ++
 src/testing/traced.rs           |  2 ++
 7 files changed, 92 insertions(+)

diff --git a/src/core.rs b/src/core.rs
index 04341e3..95c3af2 100644
--- a/src/core.rs
+++ b/src/core.rs
@@ -32,6 +32,8 @@ pub trait Context {
     /// Type to provide for [Monad]ic representation of computation, mostly that of resolution ([`Resolution`]).
     type T: Monad;
 
+    type Fallible: MonadFailOver<Self::T>;
+
     type D: Diagnostic<Self::T>;
 
     /// Type to represent resolution errors mainly arising in [`Resolver::resolve`].
diff --git a/src/func.rs b/src/func.rs
index 438c1fa..35c15a4 100644
--- a/src/func.rs
+++ b/src/func.rs
@@ -232,3 +232,23 @@ pub trait LocalFunctor: WeakFunctor {
     where
         Self: 'a;
 }
+
+pub trait MonadFailAny {
+    type W<E>: MonadFail<E>;
+}
+
+pub trait MonadFailOver<T: Monad>: MonadFailAny {
+    fn unstuff<'a, A: 'a, E: 'a>(
+        wa: <Self::W<E> as WeakFunctor>::F<'a, A>,
+    ) -> <T as WeakFunctor>::F<'a, Result<A, E>>
+    where
+        Self: 'a,
+        T: 'a;
+
+    fn stuff<'a, A: 'a, E: 'a>(
+        fa: <T as WeakFunctor>::F<'a, Result<A, E>>,
+    ) -> <Self::W<E> as WeakFunctor>::F<'a, A>
+    where
+        Self: 'a,
+        T: 'a;
+}
diff --git a/src/func/classes/composition.rs b/src/func/classes/composition.rs
index 181d01f..54d9683 100644
--- a/src/func/classes/composition.rs
+++ b/src/func/classes/composition.rs
@@ -121,6 +121,14 @@ impl<U: Monad, V: Monad + LocalFunctor> Monad for CompositionClass<U, V> {
     }
 }
 
+impl<E, U: Monad, V: MonadFail<E> + LocalFunctor> MonadFail<E> for CompositionClass<U, V> {
+    fn fail<'a, A: 'a>(e: E) -> Self::F<'a, A>
+    where
+        Self: 'a {
+        U::pure(V::fail(e))
+    }
+}
+
 impl<U: LocalFunctor + Functor, V: LocalFunctor> LocalFunctor for CompositionClass<U, V> {
     fn unstuff<'a, A: 'a, B: 'a>(state: Self::F<'a, IState<A, B>>) -> IState<A, Self::F<'a, B>>
     where
diff --git a/src/func/classes/result.rs b/src/func/classes/result.rs
index b3fd327..854c407 100644
--- a/src/func/classes/result.rs
+++ b/src/func/classes/result.rs
@@ -157,3 +157,59 @@ impl<E> MonadFail<E> for ResultClass<E> {
         Err(e)
     }
 }
+
+pub struct ResultFailAny;
+
+impl MonadFailAny for ResultFailAny {
+    type W<E> = ResultClass<E>;
+}
+
+impl MonadFailOver<classes::solo::SoloClass> for ResultFailAny {
+    fn unstuff<'a, A: 'a, E: 'a>(
+        wa: <Self::W<E> as WeakFunctor>::F<'a, A>,
+    ) -> <classes::solo::SoloClass as WeakFunctor>::F<'a, Result<A, E>>
+    where
+        Self: 'a,
+        classes::solo::SoloClass: 'a,
+    {
+        wa
+    }
+
+    fn stuff<'a, A: 'a, E: 'a>(
+        fa: <classes::solo::SoloClass as WeakFunctor>::F<'a, Result<A, E>>,
+    ) -> <Self::W<E> as WeakFunctor>::F<'a, A>
+    where
+        Self: 'a,
+        classes::solo::SoloClass: 'a,
+    {
+        fa
+    }
+}
+
+pub struct ResultFailOver<T: Monad>(T);
+
+impl<T: Monad> MonadFailAny for ResultFailOver<T> {
+    type W<E> = super::composition::CompositionClass<T, ResultClass<E>>;
+}
+
+impl<T: Monad> MonadFailOver<T> for ResultFailOver<T> {
+    fn unstuff<'a, A: 'a, E: 'a>(
+        wa: <Self::W<E> as WeakFunctor>::F<'a, A>,
+    ) -> <T as WeakFunctor>::F<'a, Result<A, E>>
+    where
+        Self: 'a,
+        T: 'a,
+    {
+        wa
+    }
+
+    fn stuff<'a, A: 'a, E: 'a>(
+        fa: <T as WeakFunctor>::F<'a, Result<A, E>>,
+    ) -> <Self::W<E> as WeakFunctor>::F<'a, A>
+    where
+        Self: 'a,
+        T: 'a,
+    {
+        fa
+    }
+}
diff --git a/src/testing.rs b/src/testing.rs
index 5d2ea0b..3bb4133 100644
--- a/src/testing.rs
+++ b/src/testing.rs
@@ -68,6 +68,8 @@ impl<'a> Error for TestLookupError<'a> {}
 impl Context for TestContextPlain {
     type T = classes::solo::SoloClass;
 
+    type Fallible = classes::result::ResultFailAny;
+
     type D = NoDiagnostic;
 
     type LookupError<'a> = TestLookupError<'a>;
diff --git a/src/testing/counted.rs b/src/testing/counted.rs
index e4ab7ba..66379a3 100644
--- a/src/testing/counted.rs
+++ b/src/testing/counted.rs
@@ -10,6 +10,8 @@ pub struct TestContextCounted;
 impl Context for TestContextCounted {
     type T = CountedClass;
 
+    type Fallible = classes::result::ResultFailOver<Self::T>;
+
     type D = NoDiagnostic;
 
     type LookupError<'a> = TestLookupError<'a>;
diff --git a/src/testing/traced.rs b/src/testing/traced.rs
index 34cfe95..550306d 100644
--- a/src/testing/traced.rs
+++ b/src/testing/traced.rs
@@ -8,6 +8,8 @@ pub struct TestContextTraced;
 impl Context for TestContextTraced {
     type T = TracedClass;
 
+    type Fallible = classes::result::ResultFailOver<Self::T>;
+
     type D = TracedDiagnostic;
 
     type LookupError<'a> = TestLookupError<'a>;