Data-generic programming support in CGP

Cargo.toml

@@ -20,6 +20,7 @@ members = [
     "crates/cgp-error-eyre",
     "crates/cgp-error-std",
     "crates/cgp-handler",
+    "crates/cgp-dispatch",
     "crates/cgp-run",
     "crates/cgp-runtime",
     "crates/cgp-inner",
@@ -49,6 +50,7 @@ cgp-field                   = { path = "./crates/cgp-field" }
 cgp-error                   = { path = "./crates/cgp-error" }
 cgp-error-extra             = { path = "./crates/cgp-error-extra" }
 cgp-handler                 = { path = "./crates/cgp-handler" }
+cgp-dispatch                = { path = "./crates/cgp-dispatch" }
 cgp-run                     = { path = "./crates/cgp-run" }
 cgp-runtime                 = { path = "./crates/cgp-runtime" }
 cgp-inner                   = { path = "./crates/cgp-inner" }

crates/cgp-core/src/prelude.rs

@@ -1,3 +1,5 @@
+pub use core::marker::PhantomData;
+
 pub use cgp_async::{async_trait, Async, MaybeSend, MaybeSync};
 pub use cgp_component::{
     CanUseComponent, DelegateComponent, HasCgpProvider, IsProviderFor, UseContext, UseDelegate,
@@ -8,12 +10,15 @@ pub use cgp_error::{
     HasErrorType,
 };
 pub use cgp_field::{
-    Char, Cons, Either, Field, FieldGetter, FromFields, HasField, HasFieldMut, HasFields,
-    HasFieldsRef, Index, MutFieldGetter, Nil, ToFields, ToFieldsRef, UseField, Void,
+    BuildField, Char, Cons, Either, ExtractField, Field, FieldGetter, FinalizeBuild,
+    FinalizeExtract, FromFields, FromVariant, HasBuilder, HasExtractor, HasExtractorRef, HasField,
+    HasFieldMut, HasFields, HasFieldsRef, Index, IntoBuilder, IsNothing, IsPresent, IsVoid,
+    MapType, MutFieldGetter, Nil, TakeField, ToFields, ToFieldsRef, UseField, Void,
 };
 pub use cgp_macro::{
     cgp_auto_getter, cgp_component, cgp_context, cgp_getter, cgp_new_provider, cgp_preset,
     cgp_provider, cgp_type, check_components, delegate_and_check_components, delegate_components,
-    product, re_export_imports, replace_with, symbol, HasField, HasFields, Product, Sum,
+    product, re_export_imports, replace_with, symbol, BuildField, ExtractField, FromVariant,
+    HasField, HasFields, Product, Sum,
 };
 pub use cgp_type::{HasType, ProvideType, UseType};

crates/cgp-dispatch/Cargo.toml

@@ -0,0 +1,14 @@
+[package]
+name         = "cgp-dispatch"
+version      = "0.4.1"
+edition      = { workspace = true }
+license      = { workspace = true }
+repository   = { workspace = true }
+authors      = { workspace = true }
+rust-version = { workspace = true }
+keywords     = { workspace = true }
+description  = "Generalized handler interfaces for functional programming"
+
+[dependencies]
+cgp-core    = { version = "0.4.1" }
+cgp-handler = { version = "0.4.1" }

crates/cgp-dispatch/src/lib.rs

@@ -0,0 +1,5 @@
+#![no_std]
+
+mod providers;
+
+pub use providers::*;

crates/cgp-dispatch/src/providers/build_handlers.rs

@@ -0,0 +1,162 @@
+use cgp_core::prelude::*;
+use cgp_handler::{Computer, ComputerComponent, TryComputer, TryComputerComponent};
+
+pub struct BuildWithHandlers<Output, Handlers>(pub PhantomData<(Output, Handlers)>);
+
+#[cgp_provider]
+impl<Context, Code, Input, Output, Builder, Handlers> Computer<Context, Code, Input>
+    for BuildWithHandlers<Output, Handlers>
+where
+    Output: HasBuilder<Builder = Builder>,
+    Handlers: BuilderComputer<Context, Code, Input, Builder>,
+    Handlers::Output: FinalizeBuild<Output = Output>,
+{
+    type Output = Output;
+
+    fn compute(context: &Context, code: PhantomData<Code>, input: Input) -> Self::Output {
+        Handlers::build(context, code, input, Output::builder()).finalize_build()
+    }
+}
+
+#[cgp_provider]
+impl<Context, Code, Input, Output, Builder, Handlers> TryComputer<Context, Code, Input>
+    for BuildWithHandlers<Output, Handlers>
+where
+    Context: HasErrorType,
+    Output: HasBuilder<Builder = Builder>,
+    Handlers: TryBuilderComputer<Context, Code, Input, Builder>,
+    Handlers::Output: FinalizeBuild<Output = Output>,
+{
+    type Output = Output;
+
+    fn try_compute(
+        context: &Context,
+        code: PhantomData<Code>,
+        input: Input,
+    ) -> Result<Self::Output, Context::Error> {
+        Ok(Handlers::try_build(context, code, input, Output::builder())?.finalize_build())
+    }
+}
+
+pub trait BuilderComputer<Context, Code, Input, Builder> {
+    type Output;
+
+    fn build(
+        context: &Context,
+        code: PhantomData<Code>,
+        input: Input,
+        builder: Builder,
+    ) -> Self::Output;
+}
+
+pub trait TryBuilderComputer<Context, Code, Input, Builder>
+where
+    Context: HasErrorType,
+{
+    type Output;
+
+    fn try_build(
+        context: &Context,
+        code: PhantomData<Code>,
+        input: Input,
+        builder: Builder,
+    ) -> Result<Self::Output, Context::Error>;
+}
+
+impl<
+        Context,
+        Code,
+        Input,
+        Builder,
+        NextBuilder,
+        Output,
+        CurrentHandler,
+        NextHandler,
+        RestHandlers,
+    > BuilderComputer<Context, Code, Input, Builder>
+    for Cons<CurrentHandler, Cons<NextHandler, RestHandlers>>
+where
+    CurrentHandler: BuilderComputer<Context, Code, Input, Builder, Output = NextBuilder>,
+    Cons<NextHandler, RestHandlers>:
+        BuilderComputer<Context, Code, Input, NextBuilder, Output = Output>,
+    Input: Clone,
+{
+    type Output = Output;
+
+    fn build(
+        context: &Context,
+        code: PhantomData<Code>,
+        input: Input,
+        builder: Builder,
+    ) -> Self::Output {
+        let next_builder = CurrentHandler::build(context, code, input.clone(), builder);
+        Cons::build(context, code, input, next_builder)
+    }
+}
+
+impl<
+        Context,
+        Code,
+        Input,
+        Builder,
+        NextBuilder,
+        Output,
+        CurrentHandler,
+        NextHandler,
+        RestHandlers,
+    > TryBuilderComputer<Context, Code, Input, Builder>
+    for Cons<CurrentHandler, Cons<NextHandler, RestHandlers>>
+where
+    Context: HasErrorType,
+    CurrentHandler: TryBuilderComputer<Context, Code, Input, Builder, Output = NextBuilder>,
+    Cons<NextHandler, RestHandlers>:
+        TryBuilderComputer<Context, Code, Input, NextBuilder, Output = Output>,
+    Input: Clone,
+{
+    type Output = Output;
+
+    fn try_build(
+        context: &Context,
+        code: PhantomData<Code>,
+        input: Input,
+        builder: Builder,
+    ) -> Result<Self::Output, Context::Error> {
+        let next_builder = CurrentHandler::try_build(context, code, input.clone(), builder)?;
+        Cons::try_build(context, code, input, next_builder)
+    }
+}
+
+impl<Context, Code, Input, Builder, Handler, Output> BuilderComputer<Context, Code, Input, Builder>
+    for Cons<Handler, Nil>
+where
+    Handler: BuilderComputer<Context, Code, Input, Builder, Output = Output>,
+{
+    type Output = Output;
+
+    fn build(
+        context: &Context,
+        code: PhantomData<Code>,
+        input: Input,
+        builder: Builder,
+    ) -> Self::Output {
+        Handler::build(context, code, input, builder)
+    }
+}
+
+impl<Context, Code, Input, Builder, Handler, Output>
+    TryBuilderComputer<Context, Code, Input, Builder> for Cons<Handler, Nil>
+where
+    Context: HasErrorType,
+    Handler: TryBuilderComputer<Context, Code, Input, Builder, Output = Output>,
+{
+    type Output = Output;
+
+    fn try_build(
+        context: &Context,
+        code: PhantomData<Code>,
+        input: Input,
+        builder: Builder,
+    ) -> Result<Self::Output, Context::Error> {
+        Handler::try_build(context, code, input, builder)
+    }
+}

crates/cgp-dispatch/src/providers/builders/build_field.rs

@@ -0,0 +1,45 @@
+use cgp_core::prelude::*;
+use cgp_handler::{Computer, TryComputer};
+
+use crate::{BuilderComputer, TryBuilderComputer};
+
+pub struct HandleAndBuildField<Tag, Provider = UseContext>(pub PhantomData<(Tag, Provider)>);
+
+impl<Context, Code, Input, Tag, Value, Provider, Output, Builder>
+    BuilderComputer<Context, Code, Input, Builder> for HandleAndBuildField<Tag, Provider>
+where
+    Provider: Computer<Context, Code, Input, Output = Value>,
+    Builder: BuildField<Tag, Value = Value, Output = Output>,
+{
+    type Output = Output;
+
+    fn build(
+        context: &Context,
+        code: PhantomData<Code>,
+        input: Input,
+        builder: Builder,
+    ) -> Self::Output {
+        let value = Provider::compute(context, code, input);
+        builder.build_field(PhantomData::<Tag>, value)
+    }
+}
+
+impl<Context, Code, Input, Tag, Value, Provider, Output, Builder>
+    TryBuilderComputer<Context, Code, Input, Builder> for HandleAndBuildField<Tag, Provider>
+where
+    Context: HasErrorType,
+    Provider: TryComputer<Context, Code, Input, Output = Value>,
+    Builder: BuildField<Tag, Value = Value, Output = Output>,
+{
+    type Output = Output;
+
+    fn try_build(
+        context: &Context,
+        code: PhantomData<Code>,
+        input: Input,
+        builder: Builder,
+    ) -> Result<Self::Output, Context::Error> {
+        let value = Provider::try_compute(context, code, input)?;
+        Ok(builder.build_field(PhantomData::<Tag>, value))
+    }
+}

crates/cgp-dispatch/src/providers/builders/handle_and_build.rs

@@ -0,0 +1,46 @@
+use cgp_core::field::CanBuildFrom;
+use cgp_core::prelude::*;
+use cgp_handler::{Computer, TryComputer};
+
+use crate::{BuilderComputer, TryBuilderComputer};
+
+pub struct HandleAndBuild<Provider = UseContext>(pub PhantomData<Provider>);
+
+impl<Context, Code, Input, Builder, Provider, Output> BuilderComputer<Context, Code, Input, Builder>
+    for HandleAndBuild<Provider>
+where
+    Provider: Computer<Context, Code, Input>,
+    Builder: CanBuildFrom<Provider::Output, Output = Output>,
+{
+    type Output = Output;
+
+    fn build(
+        context: &Context,
+        code: PhantomData<Code>,
+        input: Input,
+        builder: Builder,
+    ) -> Self::Output {
+        let output = Provider::compute(context, code, input);
+        builder.build_from(output)
+    }
+}
+
+impl<Context, Code, Input, Builder, Provider, Output>
+    TryBuilderComputer<Context, Code, Input, Builder> for HandleAndBuild<Provider>
+where
+    Context: HasErrorType,
+    Provider: TryComputer<Context, Code, Input>,
+    Builder: CanBuildFrom<Provider::Output, Output = Output>,
+{
+    type Output = Output;
+
+    fn try_build(
+        context: &Context,
+        code: PhantomData<Code>,
+        input: Input,
+        builder: Builder,
+    ) -> Result<Self::Output, Context::Error> {
+        let output = Provider::try_compute(context, code, input)?;
+        Ok(builder.build_from(output))
+    }
+}

crates/cgp-dispatch/src/providers/builders/mod.rs

@@ -0,0 +1,5 @@
+mod build_field;
+mod handle_and_build;
+
+pub use build_field::*;
+pub use handle_and_build::*;