quote

Repetition is performed using #(...)* or #(...),* syntax, similar to macro_rules!. This iterates through elements of an interpolated variable (such as a Vec, slice, BTreeSet, or any Iterator) and inserts the repetition body for each element.

• #(#var)* — No separators.
• #(#var),* — Uses the character before the asterisk as a separator (e.g., a comma) and does not produce a trailing separator.
• #(#var ,)* — Produces a trailing separator.
• Repetitions can contain multiple interpolations or other code structures.

Add quote to your Cargo.toml dependencies to use the quote! macro for turning Rust syntax tree data structures into tokens.

[dependencies]
quote = "1.0"

When invoking a method on a type that is being interpolated (e.g., field_type::new()), the expansion might result in invalid syntax for certain types like Vec<i32>. To ensure correct syntax (e.g., <Vec<i32>>::new()), wrap the interpolated type in angle brackets.

# use quote::quote;
#
# let field_type = quote!(...);
#
// Use angle brackets for correct syntax with complex types
quote! {
    let value = <#field_type>::new();
}

Interpolating an identifier directly next to other tokens (e.g., _#ident) will not concatenate them; they will remain separate tokens. To create a new identifier by modifying an existing one, use the format_ident! macro.

let varname = format_ident!("_{}", ident);
quote! {
    let mut #varname = 0;
}

When calling methods on a type provided via interpolation (like field_type), using #field_type::new() can fail if the type requires turbofish syntax (e.g., Vec<i32>). To ensure correctness for all types, wrap the interpolated type in angle brackets: <#field_type>::new().

quote! {
    let value = <#field_type>::new();
}

Since tokens produced by quote! implement ToTokens, you can build complex TokenStreams incrementally by interpolating previously generated fragments into new quote! calls.

let type_definition = quote! {...};
let methods = quote! {...};

let tokens = quote! {
    #type_definition
    #methods
};

When writing generated code to a file (e.g., in build.rs), the conversion from tokens to source code is lossy and lacks hygiene/span information. To make the output human-readable and easier to debug, pass the tokens through prettyplease before writing to disk.

let output = quote! { ... };
let syntax_tree = syn::parse2(output).unwrap();
let formatted = prettyplease::unparse(&syntax_tree);

let out_dir = env::var_os("OUT_DIR").unwrap();
let dest_path = Path::new(&out_dir).join("out.rs");
fs::write(dest_path, formatted).unwrap();

The quote! macro allows you to write Rust-like syntax that is packaged into a proc_macro2::TokenStream. You can interpolate variables using the #var syntax. Any type implementing the quote::ToTokens trait (including primitives and most syn types) can be interpolated.

let tokens = quote! {
    struct SerializeWith #generics #where_clause {
        value: &'a #field_ty,
        phantom: core::marker::PhantomData<#item_ty>,
    }

    impl #generics serde::Serialize for SerializeWith #generics #where_clause {
        fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
        where
            S: serde::Serializer,
        {
            #path(self.value, serializer)
        }
    }

    SerializeWith {
        value: #value,
        phantom: core::marker::PhantomData::<#item_ty>,
    }
};