contextgeneric · soareschen · Mar 26, 2026 · Mar 3, 2026 · Mar 3, 2026 · Mar 3, 2026
diff --git a/Cargo.lock b/Cargo.lock
diff --git a/crates/cgp-component/src/lib.rs b/crates/cgp-component/src/lib.rs
@@ -5,8 +5,13 @@
    CGP component implementation.
 */
 
+mod namespaces;
 mod traits;
 mod types;
 
+pub use namespaces::DefaultNamespace;
 pub use traits::{CanUseComponent, DelegateComponent, IsProviderFor};
-pub use types::{UseContext, UseDelegate, UseFields, WithContext, WithProvider};
+pub use types::{
+    ConcatPath, PathCons, PathNil, RedirectLookup, UseContext, UseDefault, UseDelegate, UseFields,
+    WithContext, WithProvider,
+};
diff --git a/crates/cgp-component/src/namespaces.rs b/crates/cgp-component/src/namespaces.rs
@@ -0,0 +1,3 @@
+pub trait DefaultNamespace<Components> {
+    type Provider;
+}
diff --git a/crates/cgp-component/src/types/mod.rs b/crates/cgp-component/src/types/mod.rs
@@ -1,9 +1,15 @@
+mod path;
+mod redirect_lookup;
 mod use_context;
+mod use_default;
 mod use_delegate;
 mod use_fields;
 mod with_provider;
 
+pub use path::{ConcatPath, PathCons, PathNil};
+pub use redirect_lookup::RedirectLookup;
 pub use use_context::{UseContext, WithContext};
+pub use use_default::UseDefault;
 pub use use_delegate::UseDelegate;
 pub use use_fields::UseFields;
 pub use with_provider::WithProvider;
diff --git a/crates/cgp-component/src/types/path.rs b/crates/cgp-component/src/types/path.rs
@@ -0,0 +1,20 @@
+use core::marker::PhantomData;
+
+pub struct PathCons<Head: ?Sized, Tail: ?Sized>(pub PhantomData<Head>, pub PhantomData<Tail>);
+
+pub struct PathNil;
+
+pub trait ConcatPath<Other: ?Sized> {
+    type Output: ?Sized;
+}
+
+impl<Head: ?Sized, Tail: ?Sized, Other: ?Sized> ConcatPath<Other> for PathCons<Head, Tail>
+where
+    Tail: ConcatPath<Other>,
+{
+    type Output = PathCons<Head, <Tail as ConcatPath<Other>>::Output>;
+}
+
+impl<Other: ?Sized> ConcatPath<Other> for PathNil {
+    type Output = Other;
+}
diff --git a/crates/cgp-component/src/types/redirect_lookup.rs b/crates/cgp-component/src/types/redirect_lookup.rs
@@ -0,0 +1,3 @@
+use core::marker::PhantomData;
+
+pub struct RedirectLookup<Key, Components>(pub PhantomData<(Key, Components)>);
diff --git a/crates/cgp-component/src/types/use_default.rs b/crates/cgp-component/src/types/use_default.rs
@@ -0,0 +1 @@
+pub struct UseDefault;
diff --git a/crates/cgp-core/src/prelude.rs b/crates/cgp-core/src/prelude.rs
@@ -2,8 +2,8 @@ pub use core::marker::PhantomData;
 
 pub use cgp_async_macro::async_trait;
 pub use cgp_component::{
-    CanUseComponent, DelegateComponent, IsProviderFor, UseContext, UseDelegate, UseFields,
-    WithContext, WithProvider,
+    CanUseComponent, ConcatPath, DefaultNamespace, DelegateComponent, IsProviderFor, PathCons,
+    PathNil, RedirectLookup, UseContext, UseDelegate, UseFields, WithContext, WithProvider,
 };
 pub use cgp_error::{CanRaiseError, CanWrapError, HasErrorType};
 pub use cgp_field::impls::{IsMut, IsNothing, IsPresent, IsRef, IsVoid, UseField};

diff --git a/crates/cgp-error/Cargo.toml b/crates/cgp-error/Cargo.toml
@@ -15,3 +15,4 @@ description  = """
 cgp-component       = { workspace = true }
 cgp-macro           = { workspace = true }
 cgp-type            = { workspace = true }
+cgp-field           = { workspace = true }
diff --git a/crates/cgp-error/src/traits/can_raise_error.rs b/crates/cgp-error/src/traits/can_raise_error.rs
@@ -1,4 +1,4 @@
-use cgp_component::{DelegateComponent, IsProviderFor, UseContext, UseDelegate};
+use cgp_component::*;
 use cgp_macro::cgp_component;
 
 use crate::traits::has_error_type::HasErrorType;

diff --git a/crates/cgp-error/src/traits/can_wrap_error.rs b/crates/cgp-error/src/traits/can_wrap_error.rs
@@ -1,4 +1,4 @@
-use cgp_component::{DelegateComponent, IsProviderFor, UseContext, UseDelegate};
+use cgp_component::*;
 use cgp_macro::cgp_component;
 
 use crate::traits::HasErrorType;

diff --git a/crates/cgp-error/src/traits/has_error_type.rs b/crates/cgp-error/src/traits/has_error_type.rs
@@ -1,6 +1,10 @@
 use core::fmt::Debug;
 
-use cgp_component::{DelegateComponent, IsProviderFor, UseContext, WithProvider};
+use cgp_component::{
+    DefaultNamespace, DelegateComponent, IsProviderFor, PathCons, PathNil, RedirectLookup,
+    UseContext, WithProvider,
+};
+use cgp_field::types::*;
 use cgp_macro::cgp_type;
 use cgp_type::{TypeProvider, UseType};
 
@@ -24,6 +28,7 @@ use cgp_type::{TypeProvider, UseType};
    <https://patterns.contextgeneric.dev/error-handling.html>
 */
 #[cgp_type]
+#[use_namespace(cgp.core.error)]
 pub trait HasErrorType {
     type Error: Debug;
 }

diff --git a/crates/cgp-field/src/traits/append_product.rs b/crates/cgp-field/src/traits/append_product.rs
@@ -0,0 +1,16 @@
+use crate::types::{Cons, Nil};
+
+pub trait AppendProduct<Item: ?Sized> {
+    type Output;
+}
+
+impl<Item> AppendProduct<Item> for Nil {
+    type Output = Cons<Item, Nil>;
+}
+
+impl<Head, Tail, Item> AppendProduct<Item> for Cons<Head, Tail>
+where
+    Tail: AppendProduct<Item>,
+{
+    type Output = Cons<Head, Tail::Output>;
+}
diff --git a/crates/cgp-field/src/traits/concat_product.rs b/crates/cgp-field/src/traits/concat_product.rs
@@ -0,0 +1,16 @@
+use crate::types::{Cons, Nil};
+
+pub trait ConcatProduct<Items> {
+    type Output;
+}
+
+impl<Items> ConcatProduct<Items> for Nil {
+    type Output = Items;
+}
+
+impl<Head, Tail, Items> ConcatProduct<Items> for Cons<Head, Tail>
+where
+    Tail: ConcatProduct<Items>,
+{
+    type Output = Cons<Head, Tail::Output>;
+}
diff --git a/crates/cgp-field/src/traits/mod.rs b/crates/cgp-field/src/traits/mod.rs
@@ -1,4 +1,6 @@
+mod append_product;
 mod build_field;
+mod concat_product;
 mod extract_field;
 mod from_fields;
 mod from_variant;
@@ -18,7 +20,9 @@ mod to_fields;
 mod transform_map;
 mod update_field;
 
+pub use append_product::*;
 pub use build_field::*;
+pub use concat_product::*;
 pub use extract_field::*;
 pub use from_fields::*;
 pub use from_variant::*;

diff --git a/crates/cgp-macro-lib/src/attributes/mod.rs b/crates/cgp-macro-lib/src/attributes/mod.rs
@@ -0,0 +1,3 @@
+mod use_namespace;
+
+pub use use_namespace::*;
diff --git a/crates/cgp-macro-lib/src/attributes/use_namespace.rs b/crates/cgp-macro-lib/src/attributes/use_namespace.rs
@@ -0,0 +1,26 @@
+use syn::Ident;
+use syn::parse::{Parse, ParseStream};
+use syn::punctuated::Punctuated;
+use syn::token::{Colon, Dot};
+
+use crate::parse::PathType;
+
+pub struct UseNamespaceAttribute {
+    pub namespace: Ident,
+    pub path: Punctuated<PathType, Dot>,
+}
+
+impl Parse for UseNamespaceAttribute {
+    fn parse(input: ParseStream) -> syn::Result<Self> {
+        let namespace = if input.peek2(Colon) {
+            let namespace = input.parse()?;
+            let _: Colon = input.parse()?;
+            namespace
+        } else {
+            Ident::new("DefaultNamespace", input.span())
+        };
+
+        let path = Punctuated::parse_separated_nonempty(input)?;
+        Ok(UseNamespaceAttribute { namespace, path })
+    }
+}
diff --git a/crates/cgp-macro-lib/src/cgp_fn/bounds.rs b/crates/cgp-macro-lib/src/cgp_fn/bounds.rs
@@ -13,7 +13,7 @@ pub fn build_implicit_args_bounds(
     let mut constraints: Punctuated<TypeParamBound, Plus> = Punctuated::new();
 
     for arg in implicit_args {
-        let field_symbol = symbol_from_string(&arg.field_name.to_string());
+        let field_symbol = symbol_from_string(&arg.field_name.to_string())?;
 
         let constraint = derive_getter_constraint(
             &arg.field_type,

diff --git a/crates/cgp-macro-lib/src/cgp_fn/fn_body.rs b/crates/cgp-macro-lib/src/cgp_fn/fn_body.rs
@@ -16,7 +16,7 @@ pub fn inject_implicit_arg(arg: &ImplicitArgField, body: &mut Block) -> syn::Res
     let field_name = &arg.field_name;
     let arg_type = &arg.arg_type;
 
-    let field_symbol = symbol_from_string(&field_name.to_string());
+    let field_symbol = symbol_from_string(&field_name.to_string())?;
 
     let call_expr = if arg.field_mut.is_none() {
         quote! {

diff --git a/crates/cgp-macro-lib/src/delegate_components/attributes.rs b/crates/cgp-macro-lib/src/delegate_components/attributes.rs
@@ -0,0 +1,48 @@
+use syn::{Attribute, Ident, Meta};
+
+pub fn parse_delegate_attributes(attributes: Vec<Attribute>) -> syn::Result<DelegateAttributes> {
+    let mut parsed_attributes = DelegateAttributes::default();
+
+    for attribute in attributes.iter() {
+        if let Some(ident) = attribute.path().get_ident() {
+            if ident == "use_namespace" {
+                if parsed_attributes.use_namespace.is_some() {
+                    return Err(syn::Error::new_spanned(
+                        attribute,
+                        "Multiple #[use_namespace] attributes are not allowed",
+                    ));
+                }
+
+                if let Meta::Path(_) = attribute.meta {
+                    parsed_attributes.use_namespace =
+                        Some(DelegateNamespaceAttribute { namespace: None });
+                } else {
+                    let namespace = attribute.parse_args::<Option<Ident>>()?;
+                    parsed_attributes.use_namespace =
+                        Some(DelegateNamespaceAttribute { namespace });
+                }
+            } else {
+                return Err(syn::Error::new_spanned(
+                    attribute,
+                    format!("Unknown attribute {} for delegate_components", ident),
+                ));
+            }
+        } else {
+            return Err(syn::Error::new_spanned(
+                attribute,
+                "Unexpected attribute format for delegate_components",
+            ));
+        }
+    }
+
+    Ok(parsed_attributes)
+}
+
+#[derive(Default)]
+pub struct DelegateAttributes {
+    pub use_namespace: Option<DelegateNamespaceAttribute>,
+}
+
+pub struct DelegateNamespaceAttribute {
+    pub namespace: Option<Ident>,
+}
diff --git a/crates/cgp-macro-lib/src/delegate_components/derive_namespace.rs b/crates/cgp-macro-lib/src/delegate_components/derive_namespace.rs
@@ -0,0 +1,49 @@
+use proc_macro2::{Span, TokenStream};
+use quote::quote;
+use syn::{Generics, Ident, Type, parse2};
+
+pub fn derive_namespace_delegate(
+    namespace: Option<Ident>,
+    target_type: &Type,
+    target_generics: &Generics,
+) -> syn::Result<TokenStream> {
+    let namespace = namespace.unwrap_or_else(|| Ident::new("DefaultNamespace", Span::call_site()));
+
+    let mut generics = target_generics.clone();
+    generics.params.push(parse2(quote! { __Component__ })?);
+
+    let impl_generics = generics.split_for_impl().0;
+
+    let namespace_impl = quote! {
+        impl #impl_generics
+            DelegateComponent<__Component__>
+            for #target_type
+        where
+            __Component__: #namespace< #target_type >,
+        {
+            type Delegate = < __Component__ as #namespace< #target_type >>::Provider;
+        }
+    };
+
+    let mut generics = generics.clone();
+    generics.params.push(parse2(quote! { __Context__ })?);
+    generics.params.push(parse2(quote! { __Params__ })?);
+
+    let impl_generics = generics.split_for_impl().0;
+
+    let is_provider_for_impl = quote! {
+        impl #impl_generics
+            IsProviderFor<__Component__, __Context__, __Params__>
+            for #target_type
+        where
+            __Component__: #namespace< #target_type >,
+            < __Component__ as #namespace< #target_type >>::Provider: IsProviderFor<__Component__, __Context__, __Params__>,
+        {
+        }
+    };
+
+    Ok(quote! {
+        #namespace_impl
+        #is_provider_for_impl
+    })
+}
diff --git a/crates/cgp-macro-lib/src/delegate_components/mod.rs b/crates/cgp-macro-lib/src/delegate_components/mod.rs
@@ -1,6 +1,10 @@
+mod attributes;
 mod define_struct;
+mod derive_namespace;
 mod impl_delegate;
 mod merge_generics;
 
+pub use attributes::*;
 pub use define_struct::*;
+pub use derive_namespace::*;
 pub use impl_delegate::*;
diff --git a/crates/cgp-macro-lib/src/derive_builder/utils.rs b/crates/cgp-macro-lib/src/derive_builder/utils.rs
@@ -26,7 +26,7 @@ pub fn field_to_member(index: usize, field: &Field) -> Member {
 
 pub fn field_to_tag(index: usize, field: &Field) -> syn::Result<Type> {
     match &field.ident {
-        Some(ident) => Ok(symbol_from_string(&ident.to_string())),
+        Some(ident) => symbol_from_string(&ident.to_string()),
         None => {
             let index = LitInt::new(&format!("{index}"), field.span());
             parse2(quote! { δ< #index > })

diff --git a/crates/cgp-macro-lib/src/derive_component/attributes.rs b/crates/cgp-macro-lib/src/derive_component/attributes.rs
@@ -4,6 +4,7 @@ use syn::punctuated::Punctuated;
 use syn::token::Comma;
 use syn::{Attribute, TypeParamBound};
 
+use crate::attributes::UseNamespaceAttribute;
 use crate::cgp_fn::UseTypeSpec;
 
 pub fn parse_component_attributes(
@@ -35,6 +36,11 @@ pub fn parse_component_attributes(
                 }
 
                 parsed_attributes.use_type.extend(use_type_specs);
+            } else if ident == "use_namespace" {
+                let use_namespace_specs = attribute.parse_args_with(
+                    Punctuated::<UseNamespaceAttribute, Comma>::parse_terminated,
+                )?;
+                parsed_attributes.use_namespace.extend(use_namespace_specs);
             } else {
                 attributes.push(attribute);
             }
@@ -50,4 +56,5 @@ pub fn parse_component_attributes(
 pub struct ComponentAttributes {
     pub extend: Vec<TypeParamBound>,
     pub use_type: Vec<UseTypeSpec>,
+    pub use_namespace: Vec<UseNamespaceAttribute>,
 }
Original file line number	Diff line number	Diff line change
		@@ -0,0 +1,3 @@
		use core::marker::PhantomData;

		pub struct RedirectLookup<Key, Components>(pub PhantomData<(Key, Components)>);