Add full monad transformer support for monadic composition of CGP handlers

crates/cgp-error/src/contexts/error_only.rs

@@ -0,0 +1,16 @@
+use core::fmt::Debug;
+use core::marker::PhantomData;
+
+use crate::HasErrorType;
+
+pub struct ErrorOnly<E>(pub PhantomData<E>);
+
+impl<E> Default for ErrorOnly<E> {
+    fn default() -> Self {
+        Self(PhantomData)
+    }
+}
+
+impl<E: Debug> HasErrorType for ErrorOnly<E> {
+    type Error = E;
+}

crates/cgp-error/src/contexts/mod.rs

@@ -0,0 +1,3 @@
+mod error_only;
+
+pub use error_only::*;

crates/cgp-error/src/lib.rs

@@ -1,9 +1,7 @@
 #![no_std]
 
+mod contexts;
 mod traits;
 
-pub use traits::{
-    CanRaiseAsyncError, CanRaiseError, CanWrapAsyncError, CanWrapError, ErrorOf, ErrorRaiser,
-    ErrorRaiserComponent, ErrorTypeProvider, ErrorTypeProviderComponent, ErrorWrapper,
-    ErrorWrapperComponent, HasAsyncErrorType, HasErrorType,
-};
+pub use contexts::*;
+pub use traits::*;

crates/cgp-handler/src/providers/compose.rs

@@ -0,0 +1,62 @@
+use cgp_core::prelude::*;
+
+use crate::{
+    Computer, ComputerComponent, Handler, HandlerComponent, TryComputer, TryComputerComponent,
+};
+
+pub struct ComposeHandlers<ProviderA, ProviderB>(pub PhantomData<(ProviderA, ProviderB)>);
+
+#[cgp_provider]
+impl<Context, Code, Input, ProviderA, ProviderB> Computer<Context, Code, Input>
+    for ComposeHandlers<ProviderA, ProviderB>
+where
+    ProviderA: Computer<Context, Code, Input>,
+    ProviderB: Computer<Context, Code, ProviderA::Output>,
+{
+    type Output = ProviderB::Output;
+
+    fn compute(context: &Context, code: PhantomData<Code>, input: Input) -> Self::Output {
+        let intermediary = ProviderA::compute(context, code, input);
+        ProviderB::compute(context, code, intermediary)
+    }
+}
+
+#[cgp_provider]
+impl<Context, Code, Input, ProviderA, ProviderB> TryComputer<Context, Code, Input>
+    for ComposeHandlers<ProviderA, ProviderB>
+where
+    Context: HasErrorType,
+    ProviderA: TryComputer<Context, Code, Input>,
+    ProviderB: TryComputer<Context, Code, ProviderA::Output>,
+{
+    type Output = ProviderB::Output;
+
+    fn try_compute(
+        context: &Context,
+        code: PhantomData<Code>,
+        input: Input,
+    ) -> Result<Self::Output, Context::Error> {
+        let intermediary = ProviderA::try_compute(context, code, input)?;
+        ProviderB::try_compute(context, code, intermediary)
+    }
+}
+
+#[cgp_provider]
+impl<Context, Code: Send, Input: Send, ProviderA, ProviderB> Handler<Context, Code, Input>
+    for ComposeHandlers<ProviderA, ProviderB>
+where
+    Context: HasAsyncErrorType,
+    ProviderA: Handler<Context, Code, Input>,
+    ProviderB: Handler<Context, Code, ProviderA::Output>,
+{
+    type Output = ProviderB::Output;
+
+    async fn handle(
+        context: &Context,
+        code: PhantomData<Code>,
+        input: Input,
+    ) -> Result<Self::Output, Context::Error> {
+        let intermediary = ProviderA::handle(context, code, input).await?;
+        ProviderB::handle(context, code, intermediary).await
+    }
+}

crates/cgp-handler/src/providers/mod.rs

@@ -1,11 +1,15 @@
+mod compose;
 mod field;
 mod pipe;
 mod promote;
 mod promote_ref;
 mod return_input;
+mod try_promote;
 
+pub use compose::*;
 pub use field::*;
 pub use pipe::*;
 pub use promote::*;
 pub use promote_ref::*;
 pub use return_input::*;
+pub use try_promote::*;

crates/cgp-handler/src/providers/pipe.rs

@@ -2,186 +2,29 @@ use core::marker::PhantomData;
 
 use cgp_core::prelude::*;
 
-use crate::components::*;
+use crate::ComposeHandlers;
 
 pub struct PipeHandlers<Providers>(pub PhantomData<Providers>);
 
-#[cgp_provider]
-impl<Context, Tag, Input, Output, Providers> Computer<Context, Tag, Input>
-    for PipeHandlers<Providers>
-where
-    Providers: PipeComputer<Context, Tag, Input, Output = Output>,
-{
-    type Output = Output;
-
-    fn compute(context: &Context, tag: PhantomData<Tag>, input: Input) -> Output {
-        Providers::compute(context, tag, input)
-    }
-}
-
-#[cgp_provider]
-impl<Context, Tag, Input, Output, Providers> TryComputer<Context, Tag, Input>
-    for PipeHandlers<Providers>
-where
-    Context: HasErrorType,
-    Providers: PipeTryComputer<Context, Tag, Input, Output = Output>,
-{
-    type Output = Output;
-
-    fn try_compute(
-        context: &Context,
-        tag: PhantomData<Tag>,
-        input: Input,
-    ) -> Result<Output, Context::Error> {
-        Providers::try_compute(context, tag, input)
-    }
-}
-
-#[cgp_provider]
-impl<Context, Code, Input, Output, Providers> Handler<Context, Code, Input>
-    for PipeHandlers<Providers>
-where
-    Context: HasAsyncErrorType,
-    Providers: PipeHandler<Context, Code, Input, Output = Output>,
-    Code: Send,
-    Input: Send,
-    Output: Send,
-{
-    type Output = Output;
-
-    async fn handle(
-        context: &Context,
-        tag: PhantomData<Code>,
-        input: Input,
-    ) -> Result<Output, Context::Error> {
-        Providers::handle(context, tag, input).await
-    }
-}
-
-trait PipeComputer<Context, Code, Input> {
-    type Output;
-
-    fn compute(context: &Context, _code: PhantomData<Code>, input: Input) -> Self::Output;
-}
-
-impl<Context, Tag, Input, Output, CurrentProvider, RestProviders> PipeComputer<Context, Tag, Input>
-    for Cons<CurrentProvider, RestProviders>
-where
-    CurrentProvider: Computer<Context, Tag, Input>,
-    RestProviders: PipeComputer<Context, Tag, CurrentProvider::Output, Output = Output>,
-{
-    type Output = Output;
-
-    fn compute(context: &Context, tag: PhantomData<Tag>, input: Input) -> Output {
-        let intermediate = CurrentProvider::compute(context, tag, input);
-        RestProviders::compute(context, tag, intermediate)
-    }
-}
-
-impl<Context, Code, Input> PipeComputer<Context, Code, Input> for Nil {
-    type Output = Input;
-
-    fn compute(_context: &Context, _code: PhantomData<Code>, input: Input) -> Input {
-        input
+delegate_components! {
+    <Component, Provider, Providers: ComposeProviders<Provider = Provider>>
+    PipeHandlers<Providers> {
+        Component: Provider,
     }
 }
 
-trait PipeTryComputer<Context, Code, Input>
-where
-    Context: HasErrorType,
-{
-    type Output;
-
-    fn try_compute(
-        context: &Context,
-        _code: PhantomData<Code>,
-        input: Input,
-    ) -> Result<Self::Output, Context::Error>;
-}
-
-impl<Context, Tag, Input, Output, CurrentProvider, RestProviders>
-    PipeTryComputer<Context, Tag, Input> for Cons<CurrentProvider, RestProviders>
-where
-    Context: HasErrorType,
-    CurrentProvider: TryComputer<Context, Tag, Input>,
-    RestProviders: PipeTryComputer<Context, Tag, CurrentProvider::Output, Output = Output>,
-{
-    type Output = Output;
-
-    fn try_compute(
-        context: &Context,
-        tag: PhantomData<Tag>,
-        input: Input,
-    ) -> Result<Output, Context::Error> {
-        let intermediate = CurrentProvider::try_compute(context, tag, input)?;
-        RestProviders::try_compute(context, tag, intermediate)
-    }
+trait ComposeProviders {
+    type Provider;
 }
 
-impl<Context, Code, Input> PipeTryComputer<Context, Code, Input> for Nil
+impl<ProviderA, ProviderB, RestProviders, OutProviders> ComposeProviders
+    for Cons<ProviderA, Cons<ProviderB, RestProviders>>
 where
-    Context: HasErrorType,
+    Cons<ProviderB, RestProviders>: ComposeProviders<Provider = OutProviders>,
 {
-    type Output = Input;
-
-    fn try_compute(
-        _context: &Context,
-        _code: PhantomData<Code>,
-        input: Input,
-    ) -> Result<Input, Context::Error> {
-        Ok(input)
-    }
+    type Provider = ComposeHandlers<ProviderA, OutProviders>;
 }
 
-#[async_trait]
-trait PipeHandler<Context, Code, Input>
-where
-    Context: HasAsyncErrorType,
-{
-    type Output;
-
-    async fn handle(
-        context: &Context,
-        _code: PhantomData<Code>,
-        input: Input,
-    ) -> Result<Self::Output, Context::Error>;
-}
-
-impl<Context, Code, Input, Output, CurrentProvider, RestProviders> PipeHandler<Context, Code, Input>
-    for Cons<CurrentProvider, RestProviders>
-where
-    Context: HasAsyncErrorType,
-    CurrentProvider: Handler<Context, Code, Input>,
-    RestProviders: PipeHandler<Context, Code, CurrentProvider::Output, Output = Output>,
-    Code: Send,
-    Input: Send,
-    Output: Send,
-{
-    type Output = Output;
-
-    async fn handle(
-        context: &Context,
-        tag: PhantomData<Code>,
-        input: Input,
-    ) -> Result<Output, Context::Error> {
-        let intermediate = CurrentProvider::handle(context, tag, input).await?;
-        RestProviders::handle(context, tag, intermediate).await
-    }
-}
-
-impl<Context, Code, Input> PipeHandler<Context, Code, Input> for Nil
-where
-    Context: HasAsyncErrorType,
-    Code: Send,
-    Input: Send,
-{
-    type Output = Input;
-
-    async fn handle(
-        _context: &Context,
-        _code: PhantomData<Code>,
-        input: Input,
-    ) -> Result<Input, Context::Error> {
-        Ok(input)
-    }
+impl<Provider> ComposeProviders for Cons<Provider, Nil> {
+    type Provider = Provider;
 }

crates/cgp-handler/src/providers/promote.rs

@@ -7,8 +7,6 @@ use crate::{
 
 pub struct Promote<Provider>(pub PhantomData<Provider>);
 
-pub struct TryPromote<Provider>(pub PhantomData<Provider>);
-
 pub type Promote2<Provider> = Promote<Promote<Provider>>;
 
 pub type Promote3<Provider> = Promote<Promote2<Provider>>;
@@ -61,43 +59,3 @@ where
         Ok(Provider::compute(context, code, input))
     }
 }
-
-#[cgp_provider]
-impl<Context, Code, Input, Output, Error, Provider> Handler<Context, Code, Input>
-    for TryPromote<Provider>
-where
-    Context: CanRaiseAsyncError<Error>,
-    Provider: Computer<Context, Code, Input, Output = Result<Output, Error>>,
-    Code: Send,
-    Input: Send,
-    Output: Send,
-    Error: Send,
-{
-    type Output = Output;
-
-    async fn handle(
-        context: &Context,
-        tag: PhantomData<Code>,
-        input: Input,
-    ) -> Result<Output, Context::Error> {
-        Provider::compute(context, tag, input).map_err(Context::raise_error)
-    }
-}
-
-#[cgp_provider]
-impl<Context, Code, Input, Output, Error, Provider> TryComputer<Context, Code, Input>
-    for TryPromote<Provider>
-where
-    Context: CanRaiseError<Error>,
-    Provider: Computer<Context, Code, Input, Output = Result<Output, Error>>,
-{
-    type Output = Output;
-
-    fn try_compute(
-        context: &Context,
-        tag: PhantomData<Code>,
-        input: Input,
-    ) -> Result<Output, Context::Error> {
-        Provider::compute(context, tag, input).map_err(Context::raise_error)
-    }
-}