Rust Macros Cheat Sheet

// A simple declarative macromacro_rules! square {    ($x:expr) => {        $x * $x    };}fn main() {    let result = square!(5); // expands to 5 * 5    println!("{}", result);}// Macros can have multiple match arms, like matchmacro_rules! greet {    () => {        println!("Hello!");    };    ($name:expr) => {        println!("Hello, {}!", $name);    };}greet!();          // "Hello!"greet!("Ferris");  // "Hello, Ferris!"

// $(...),* repeats zero or more times, comma-separatedmacro_rules! my_vec {    ( $( $x:expr ),* ) => {        {            let mut v = Vec::new();            $( v.push($x); )*            v        }    };}let v = my_vec![1, 2, 3]; // expands to a Vec containing 1, 2, 3// $(...),+ requires one or more repetitionsmacro_rules! my_max {    ($x:expr) => { $x };    ($x:expr, $( $rest:expr ),+) => {        {            let rest_max = my_max!($( $rest ),+);            if $x > rest_max { $x } else { rest_max }        }    };}

// #[derive(...)] is a procedural macro that generates trait impls at compile time#[derive(Debug, Clone, PartialEq)]struct Point {    x: i32,    y: i32,}// serde's derive macros (from the `serde` crate) generate serialization code#[derive(serde::Serialize, serde::Deserialize)]struct Config {    name: String,    retries: u32,}let p1 = Point { x: 1, y: 2 };let p2 = p1.clone();assert_eq!(p1, p2); // works because of #[derive(PartialEq)]println!("{:?}", p1); // works because of #[derive(Debug)]

// Cargo.toml for the proc-macro crate// [lib]// proc-macro = true//// [dependencies]// syn = { version = "2", features = ["full"] }// quote = "1"// proc-macro2 = "1"use proc_macro::TokenStream;use quote::quote;use syn::{parse_macro_input, DeriveInput};#[proc_macro_derive(Describe)]pub fn derive_describe(input: TokenStream) -> TokenStream {    let ast = parse_macro_input!(input as DeriveInput);    let name = &ast.ident;    let expanded = quote! {        impl Describe for #name {            fn describe() -> &'static str {                stringify!(#name)            }        }    };    expanded.into()}

use proc_macro::TokenStream;use quote::quote;use syn::{parse_macro_input, ItemFn};// Attribute macro: #[my_timed] fn foo() { ... }#[proc_macro_attribute]pub fn my_timed(_attr: TokenStream, item: TokenStream) -> TokenStream {    let input = parse_macro_input!(item as ItemFn);    let name = &input.sig.ident;    let block = &input.block;    let sig = &input.sig;    quote! {        #sig {            let __start = std::time::Instant::now();            let __result = (|| #block)();            println!("{} took {:?}", stringify!(#name), __start.elapsed());            __result        }    }.into()}// Function-like: sql!("SELECT * FROM users") -- parses arbitrary custom syntax#[proc_macro]pub fn sql(input: TokenStream) -> TokenStream {    let query = input.to_string();    quote! { format!("executing: {}", #query) }.into().into()}

// "tt muncher": peel off one token tree per recursive callmacro_rules! count_idents {    () => { 0 };    ($head:ident $(, $tail:ident)*) => {        1 + count_idents!($( $tail ),*)    };}let n = count_idents!(a, b, c); // 3, computed entirely at compile time// Internal rules (prefixed with @) keep helper arms out of the public APImacro_rules! build_map {    (@insert $map:ident, $k:expr => $v:expr) => {        $map.insert($k, $v);    };    ( $( $k:expr => $v:expr ),* $(,)? ) => {{        let mut m = std::collections::HashMap::new();        $( build_map!(@insert m, $k => $v); )*        m    }};}let scores = build_map!{ "a" => 1, "b" => 2 };

// Hygiene: `tmp` inside the macro can't collide with a caller's own `tmp`macro_rules! swap {    ($a:expr, $b:expr) => {{        let tmp = $a;        $a = $b;        $b = tmp;    }};}fn main() {    let mut tmp = 1; // no clash with the macro's internal `tmp`    let mut y = 2;    swap!(tmp, y);}// #[macro_export] makes a macro_rules! macro visible outside its defining crate,// and places it at the crate root so callers do `use my_crate::my_macro;`#[macro_export]macro_rules! my_macro {    () => { println!("from my_crate") };}