RFC: Extractor API style — attribute annotation vs type-based detection

[aacebo]

Extractor API: which style do you prefer?

We're evaluating two approaches for injecting compile-time context (ident, fields, generics, etc.) into #[zyn::element] functions.

Option A: Attribute annotation (#[zyn(input)])

An explicit attribute marks which parameters are extracted from the macro input:

#[zyn::element]
fn my_element(
    #[zyn(input)] ident: syn::Ident,
    #[zyn(input)] fields: zyn::Fields,
    label: syn::Ident,  // prop — no attribute
) -> zyn::TokenStream {
    zyn::zyn! {
        fn {{ ident }}() {
            println!("{{ label }}: {} fields", {{ fields.len() }});
        }
    }
}

• Explicit — #[zyn(input)] clearly marks extracted params
• Any FromInput type works directly (no wrapper needed)
• Attribute is the sole signal; type alone doesn't determine behavior
• Familiar pattern from frameworks like axum, actix

Option B: Type-based detection (Extract<T>)

The Extract<T> wrapper type itself signals that a parameter is extracted from input — no attribute needed:

#[zyn::element]
fn my_element(
    ident: Extract<syn::Ident>,
    fields: Extract<zyn::Fields>,
    label: syn::Ident,  // prop — not wrapped in Extract
) -> zyn::TokenStream {
    zyn::zyn! {
        fn {{ ident }}() {
            println!("{{ label }}: {} fields", {{ fields.len() }});
        }
    }
}

• The type IS the signal — no extra annotation
• Extract<T> implements Deref<Target = T> for ergonomic access
• Visually distinct from props at a glance
• Detection is structural (last path segment == "Extract")

Side-by-side: derive element with multiple extractors

Option A:

#[zyn::element]
fn validated(
    #[zyn(input)] ident: syn::Ident,
    #[zyn(input)] generics: syn::Generics,
    #[zyn(input)] fields: zyn::Fields<syn::FieldsNamed>,
    #[zyn(input)] attr: zyn::Attr<MyConfig>,
) -> zyn::TokenStream {
    let (impl_generics, ty_generics, where_clause) = generics.split_for_impl();
    zyn::zyn! {
        impl {{ impl_generics }} Validate for {{ ident }} {{ ty_generics }} {{ where_clause }} {
            fn validate(&self) -> bool {
                {{ fields.len() }} > 0 && {{ attr.min_fields }}
            }
        }
    }
}

Option B:

#[zyn::element]
fn validated(
    ident: Extract<syn::Ident>,
    generics: Extract<syn::Generics>,
    fields: Extract<zyn::Fields<syn::FieldsNamed>>,
    attr: Extract<zyn::Attr<MyConfig>>,
) -> zyn::TokenStream {
    let (impl_generics, ty_generics, where_clause) = generics.split_for_impl();
    zyn::zyn! {
        impl {{ impl_generics }} Validate for {{ ident }} {{ ty_generics }} {{ where_clause }} {
            fn validate(&self) -> bool {
                {{ fields.len() }} > 0 && {{ attr.min_fields }}
            }
        }
    }
}

Key differences

Aspect	Option A (#[zyn(input)])	Option B (Extract<T>)
Signal	Attribute on parameter	Wrapper type
Verbosity	#[zyn(input)] x: T	x: Extract<T>
Access	Direct (x.method())	Via Deref (x.method())
Ownership	Own the T directly	Call .inner() to unwrap
Detection	Attribute parsing	Type path inspection

---

Feel free to comment with additional thoughts!