Procedural Macros in Rust: syn, quote & vs macro_rules!

TL;DR: A procedural macro is a Rust function that takes a TokenStream as input and returns a TokenStream as output; it transforms or generates code at compile time. There are three kinds: #[derive(MyTrait)] (adds trait impls), #[my_attribute] (transforms items), and my_macro!(...) (function-like, expands anywhere). Proc-macros live in their own crate with proc-macro = true in Cargo.toml. Use syn to parse input and quote! to generate output. Proc-macros have been stable since Rust 1.15 (derive) and Rust 1.45 (attribute and function-like), and are the backbone of nearly every major Rust framework in 2026.

What Are the Three Types of Proc-Macros?

Derive macros add trait implementations. Attribute macros transform items. Function-like macros expand like declarative macros.

// 1. Derive macro; adds impl block for a struct/enum
#[derive(Serialize, Deserialize, Debug)]
struct User { name: String, age: u32 }
 
// 2. Attribute macro; transforms the annotated item
#[route(GET, "/users")]
async fn get_users() -> impl Responder { ... }
 
// 3. Function-like macro; called with macro syntax
let query = sql!(SELECT * FROM users WHERE id = $1);

#[derive(...)] is by far the most common; serde, thiserror, clap, and diesel all use it.

How Do You Create a Proc-Macro Crate?

Proc-macros must live in a separate crate with proc-macro = true set in Cargo.toml.

# my-derive/Cargo.toml
[lib]
proc-macro = true
 
[dependencies]
syn = { version = "2", features = ["full"] }
quote = "1"
proc-macro2 = "1"

// my-derive/src/lib.rs
use proc_macro::TokenStream;
use quote::quote;
use syn::{parse_macro_input, DeriveInput};
 
#[proc_macro_derive(MyTrait)]
pub fn my_trait_derive(input: TokenStream) -> TokenStream {
    let ast = parse_macro_input!(input as DeriveInput);
    let name = &ast.ident;
    quote! {
        impl MyTrait for #name {
            fn hello(&self) -> &str { stringify!(#name) }
        }
    }.into()
}

How Do syn and quote Work Together?

syn parses a TokenStream into a Rust AST. quote! turns Rust syntax back into a TokenStream.

• syn::parse_macro_input!(input as DeriveInput): parse the struct/enum the macro is applied to
• syn::DeriveInput: gives you the name, generics, and fields
• quote! { ... }: write Rust code with #interpolations like a template
• #name, #(#fields),*: interpolate parsed values into generated code

Together they form the standard proc-macro toolkit: parse with syn; generate with quote.

Proc-Macro vs macro_rules! in 2026

macro_rules! does textual pattern matching. Proc-macros operate on token trees and have full Rust logic.

If your macro only needs to repeat or substitute tokens, choose macro_rules! (it is simpler and faster to compile). If you need to inspect struct fields, generate trait impls conditionally, or build a framework like Axum or Leptos, use a proc-macro. In 2026, proc-macros are the default choice for any crate that ships a #[derive(...)] or #[route(...)] annotation.

Frequently Asked Questions

Sources

• Rust Reference; Procedural Macros
• syn on crates.io
• quote on crates.io
• The Little Book of Rust Macros: covers both macro_rules! and proc-macros with worked examples

Related Glossary Terms

• macro: Overview of all macro types in Rust
• macro-rules: Declarative macros as an alternative
• derive: The #[derive(...)] attribute proc-macros power
• trait: Derive proc-macros generate trait implementations
• serde: The most widely used proc-macro crate in the ecosystem

Keep Reading

• Learn Rust in 2026: Proc-macros are a mid-to-advanced Rust topic worth understanding after ownership
• Rust vs Go in 2026: See how Rust's metaprogramming compares to Go's code generation approach