Element extractor that pulls enum variants from the input. Errors at compile time if the input is not an enum. Access the inner `Punctuated<syn::Vari

An `@`-prefixed statement in a zyn template. See the [`at`](crate::ast::at) module for the syntax of each variant.

Element extractor that resolves a `#[derive(Attribute)]` struct from the input's attributes. Use as an element parameter type to auto-extract a parse

Extension methods for a single `syn::Attribute`. Provides name checking, argument parsing, and dot-path metadata querying. The `get`, `exists`, and `

Converts the input to camelCase. Template usage: `{{ name | camel }}`

Element extractor that pulls the `syn::Data` from a derive input. Defaults to `syn::Data` (accepts any kind). Parameterize with `syn::DataStruct`, `s

Extension methods for `syn::Data`. Provides variant predicates (`is_struct`, `is_enum`, `is_union`) and conversions (`as_struct`, `as_enum`, `as_unio

Extension trait that adds `.debug()` to [`proc_macro2::TokenStream`]. # Example ```ignore use zyn::debug::DebugExt; let output: String = tokens.deb

Wraps a reference to a [`proc_macro2::TokenStream`] and provides formatting methods for debug output. Created by [`DebugExt::debug()`]. Use [`.raw()`

A `#[zyn::element]` component invocation. ```text @my_getter(name = field.ident.clone(), ty = field.ty.clone()) @wrapper(title = "hello") { nested co

Internal trait for AST node expansion. Not part of the public API.

Generic extractor wrapper — delegates to `T::from_input`. Use this in element parameters to extract any `FromInput` type without giving it a more spe

Extension methods for a single `syn::Field`. Provides dot-path metadata querying across the field's attributes. The first path segment matches the at

Identifies a struct field by name or position. Construct from a `syn::Ident`, `syn::Index`, `&str`, or `usize`. Implements [`ToTokens`] and [`Display

Element extractor that pulls struct fields from the input. Defaults to `syn::Fields` (accepts any field kind). Parameterize with `syn::FieldsNamed` o

Extension methods for types that contain `syn::Fields`. Provides variant predicates (`is_named`, `is_unnamed`, `is_unit`), conversions (`as_named`, `

Formats the input using a pattern string, producing a string literal. The `{}` placeholder in the pattern is replaced with the input value. Template

A `@for` loop. Iterator form: ```text @for (item in fields.iter()) { {{ item.ident }}, } ``` Classic repeat form (repeats N times with no binding):

Converts a single `Arg` into a typed value. Implement this trait to support a type as a field in `#[derive(Attribute)]` structs. Built-in impls cover

Converts `syn::Data` into a specific data representation. Implementations exist for `syn::Data` (any kind), `syn::DataStruct`, `syn::DataEnum`, and `

Converts `syn::Fields` into a specific fields representation. Implementations exist for `syn::Fields` (any kind), `syn::FieldsNamed` (named only), an

Extracts a value from the macro input context. Implement this trait to define how a type is resolved from an `Input` (derive or item). Built-in impls

A delimited group in a zyn template: `(...)`, `[...]`, or `{...}`. The body is expanded recursively and wrapped in the appropriate delimiter.

Formats the input using a pattern string, producing an `Ident`. The `{}` placeholder in the pattern is replaced with the input value. Template usage

An `@if` / `@else if` / `@else` conditional block. ```text @if (condition) { // then branch } @else if (other) { // else-if branch } @else { // else

An interpolation expression: `{{ expr }}` or `{{ expr | pipe | ... }}`. The expression is evaluated at expand time and emitted into the output token

Extension methods for `syn::Item`. Provides variant predicates (`is_struct`, `is_enum`, `is_fn`, etc.), conversions (`as_struct`, `as_enum`, `as_fn`,

An iterator that yields unique internal identifiers for template expansion.

Converts the input to kebab-case as a string literal. Unlike other pipes that return `Ident`, this returns a `LitStr` because hyphens are not valid i

Converts the input to lowercase. Template usage: `{{ name | lower }}`

A `@match` expression. ```text @match (expr) { Some(v) => { {{ v }} }, None => { default }, } ```

Extension methods for a single `syn::Meta`. Provides variant predicates (`is_path`, `is_list`, `is_name_value`), conversions (`as_path`, `as_list`, `

A type that can be converted into a list of [`Span`]s. Implemented for `Span`, `Vec<Span>`, and `&[Span]`.

A single node in a parsed zyn template. See the [`ast`](crate::ast) module for the full node taxonomy.

Converts the input to PascalCase. Template usage: `{{ name | pascal }}`

Implemented by `#[zyn::pipe]` types. Transforms a value in a pipe chain.

A single pipe stage in a `{{ expr | pipe }}` interpolation. At expand time, the name is matched against the built-in pipe list. Unrecognised names ar

Converts the input to its plural form. Template usage: `{{ name | plural }}`

Implemented by `#[zyn::element]` types. Renders the element with the given `Input` context.

Converts the input to SCREAMING_SNAKE_CASE. Template usage: `{{ name | screaming }}`

Converts the input to its singular form. Template usage: `{{ name | singular }}`

Converts the input to snake_case. Template usage: `{{ name | snake }}`

Converts the input to a string literal. Template usage: `{{ name | str }}`

A parsed template AST. Created by parsing template syntax via `syn::parse2::<Template>(tokens)`.

Literal Rust tokens passed through unchanged in a zyn template. In `zyn! { fn {{ name }}() {} }`, the tokens `fn`, `(`, `)`, `{`, `}` each contribute

Trims characters from the start and end of the input. Template usage: `{{ name | trim:"_" }}`

Extension methods for detecting and unwrapping common type wrappers. Recognizes `Option<T>` and `Result<T, E>` by their last path segment. Implemente

Converts the input to UPPERCASE. Template usage: `{{ name | upper }}`

Extension methods for a single `syn::Variant`. Provides dot-path metadata querying across the variant's attributes. The first path segment matches th