Rust macros are a powerful feature that can take your code to the next level. I’ve been using them for years, and I’m still amazed at what they can do. Let’s explore some advanced techniques that go beyond simple code generation.

Procedural macros are where the real magic happens. These macros can manipulate the abstract syntax tree (AST) of your code, allowing for complex transformations. I remember the first time I used a procedural macro to automatically implement a trait for all structs in my codebase. It was a game-changer.

Here’s a simple example of a procedural macro that adds a debug print to every function:

use proc_macro::TokenStream;
use quote::quote;
use syn::{parse_macro_input, ItemFn};

#[proc_macro_attribute]
pub fn debug_print(attr: TokenStream, item: TokenStream) -> TokenStream {
    let input = parse_macro_input!(item as ItemFn);
    let name = &input.sig.ident;
    let body = &input.block;

    let output = quote! {
        fn #name #input.sig.generics (#input.sig.inputs) #input.sig.output {
            println!("Entering function: {}", stringify!(#name));
            let result = { #body };
            println!("Exiting function: {}", stringify!(#name));
            result
        }
    };

    output.into()
}

This macro wraps the function body with debug print statements. You can use it like this:

#[debug_print]
fn my_function() {
    println!("Hello, world!");
}

When you call my_function(), it will print:

Entering function: my_function
Hello, world!
Exiting function: my_function

But macros can do so much more than just add debug statements. They can enforce coding patterns, generate boilerplate code, and even extend the language itself.

One powerful use of macros is to implement design patterns. For example, you could create a macro that automatically implements the builder pattern for your structs:

#[proc_macro_derive(Builder)]
pub fn derive_builder(input: TokenStream) -> TokenStream {
    let ast = parse_macro_input!(input as DeriveInput);
    let name = &ast.ident;
    let fields = match &ast.data {
        Data::Struct(DataStruct { fields: Fields::Named(fields), .. }) => &fields.named,
        _ => panic!("This macro only works on structs with named fields"),
    };

    let builder_methods = fields.iter().map(|f| {
        let name = &f.ident;
        let ty = &f.ty;
        quote! {
            pub fn #name(mut self, val: #ty) -> Self {
                self.#name = Some(val);
                self
            }
        }
    });

    let build_fields = fields.iter().map(|f| {
        let name = &f.ident;
        quote! {
            #name: self.#name.ok_or(concat!(stringify!(#name), " is not set"))?
        }
    });

    let expanded = quote! {
        impl #name {
            pub fn builder() -> #name Builder {
                #name Builder::default()
            }
        }

        #[derive(Default)]
        pub struct #name Builder {
            #(#fields,)*
        }

        impl #name Builder {
            #(#builder_methods)*

            pub fn build(self) -> Result<#name, String> {
                Ok(#name {
                    #(#build_fields,)*
                })
            }
        }
    };

    TokenStream::from(expanded)
}

This macro generates a builder for your struct, allowing you to create instances with a fluent interface:

#[derive(Builder)]
struct Person {
    name: String,
    age: u32,
}

let person = Person::builder()
    .name("Alice".to_string())
    .age(30)
    .build()
    .unwrap();

Macros can also be used to extend Rust’s type system. For instance, you could create a macro that implements a type-level state machine:

macro_rules! state_machine {
    (
        $machine:ident {
            $($state:ident),+
        }
        $($from:ident -> $to:ident),+
    ) => {
        mod $machine {
            $(pub struct $state;)+

            $(
                impl $from {
                    pub fn transition(self) -> $to {
                        $to
                    }
                }
            )+
        }
    };
}

state_machine! {
    TrafficLight {
        Red, Yellow, Green
    }
    Red -> Green,
    Green -> Yellow,
    Yellow -> Red
}

fn main() {
    let light = TrafficLight::Red;
    let light = light.transition(); // Now it's Green
    let light = light.transition(); // Now it's Yellow
    let light = light.transition(); // Now it's Red again
}

This macro creates a type-safe state machine where invalid transitions are caught at compile-time.

Another advanced use of macros is to generate code based on external data sources. For example, you could create a macro that reads a JSON file at compile time and generates Rust structs from it:

use proc_macro::TokenStream;
use quote::quote;
use serde_json::Value;
use std::fs;

#[proc_macro]
pub fn json_to_struct(input: TokenStream) -> TokenStream {
    let input = input.to_string();
    let json_file = input.trim().trim_matches('"');
    let json_str = fs::read_to_string(json_file).expect("Failed to read JSON file");
    let json: Value = serde_json::from_str(&json_str).expect("Invalid JSON");

    let struct_name = json_file.split('.').next().unwrap().to_string().to_camel_case();

    let fields = json.as_object().unwrap().iter().map(|(key, value)| {
        let field_name = key.to_snake_case();
        let field_type = match value {
            Value::String(_) => quote!(String),
            Value::Number(_) => quote!(f64),
            Value::Bool(_) => quote!(bool),
            Value::Array(_) => quote!(Vec<serde_json::Value>),
            Value::Object(_) => quote!(serde_json::Map<String, serde_json::Value>),
            Value::Null => quote!(Option<serde_json::Value>),
        };
        quote! { #field_name: #field_type }
    });

    let expanded = quote! {
        #[derive(Debug, serde::Serialize, serde::Deserialize)]
        struct #struct_name {
            #(#fields,)*
        }
    };

    expanded.into()
}

You could then use this macro like this:

json_to_struct!("config.json");

This would generate a Rust struct based on the contents of config.json.

Macros can also be used to implement domain-specific languages (DSLs) within Rust. For example, you could create a macro for defining and running simple workflows:

macro_rules! workflow {
    ($($step:ident => $action:expr),+ $(,)?) => {{
        $(
            fn $step() {
                println!("Executing step: {}", stringify!($step));
                $action
            }
        )+

        vec![$(stringify!($step),)+]
    }};
}

fn main() {
    let steps = workflow! {
        fetch_data => { println!("Fetching data from API..."); },
        process_data => { println!("Processing data..."); },
        save_results => { println!("Saving results to database..."); },
    };

    for step in steps {
        match step {
            "fetch_data" => fetch_data(),
            "process_data" => process_data(),
            "save_results" => save_results(),
            _ => panic!("Unknown step"),
        }
    }
}

This creates a simple DSL for defining workflows, which can be extended to include more complex logic, error handling, and parallel execution.

Macros can also be used to generate test cases. For example, you could create a macro that generates parameterized tests:

macro_rules! parameterized_tests {
    ($($name:ident: $value:expr,)*) => {
        $(
            #[test]
            fn $name() {
                let (input, expected) = $value;
                assert_eq!(my_function(input), expected);
            }
        )*
    }
}

fn my_function(x: i32) -> i32 {
    x * x
}

parameterized_tests! {
    test_zero: (0, 0),
    test_one: (1, 1),
    test_two: (2, 4),
    test_negative: (-3, 9),
}

This macro generates four separate test functions, each with different input and expected output.

One area where macros really shine is in reducing boilerplate in trait implementations. For example, you could create a macro that automatically implements PartialEq and Eq for your structs:

macro_rules! derive_equality {
    ($type:ident $($field:ident),+) => {
        impl PartialEq for $type {
            fn eq(&self, other: &Self) -> bool {
                $(self.$field == other.$field)&&+
            }
        }

        impl Eq for $type {}
    }
}

struct Point {
    x: i32,
    y: i32,
}

derive_equality!(Point x, y);

fn main() {
    let p1 = Point { x: 1, y: 2 };
    let p2 = Point { x: 1, y: 2 };
    let p3 = Point { x: 3, y: 4 };

    assert_eq!(p1, p2);
    assert_ne!(p1, p3);
}

This macro automatically implements PartialEq and Eq for the Point struct based on its fields.

Macros can also be used to implement compile-time checks. For example, you could create a macro that ensures a function is called with string literals only:

macro_rules! only_literals {
    ($func:ident($($arg:expr),*)) => {{
        $(
            const _: &str = stringify!($arg);
        )*
        $func($($arg),*)
    }}
}

fn print_uppercase(s: &str) {
    println!("{}", s.to_uppercase());
}

fn main() {
    only_literals!(print_uppercase("hello")); // This works
    let s = "world";
    // only_literals!(print_uppercase(s)); // This would cause a compile error
}

This macro ensures that print_uppercase is only called with string literals, catching potential errors at compile time.

Another powerful use of macros is to generate repetitive code patterns. For example, you could create a macro that generates a series of similar functions:

macro_rules! generate_math_functions {
    ($($name:ident: $op:tt),+) => {
        $(
            pub fn $name(x: f64, y: f64) -> f64 {
                x $op y
            }
        )+
    }
}

generate_math_functions! {
    add: +,
    subtract: -,
    multiply: *,
    divide: /
}

fn main() {
    println!("5 + 3 = {}", add(5.0, 3.0));
    println!("5 - 3 = {}", subtract(5.0, 3.0));
    println!("5 * 3 = {}", multiply(5.0, 3.0));
    println!("5 / 3 = {}", divide(5.0, 3.0));
}

This macro generates four different math functions with a single macro invocation.

Macros can also be used to implement complex algorithms at compile time. For example, you could create a macro that generates a lookup table for a function:

macro_rules! generate_lookup_table {
    ($name:ident, $type:ty, $size:expr, $func:expr) => {
        static $name: [$type; $size] = {
            let mut table = [0 as $type; $size];
            let mut i = 0;
            while i < $size {
                table[i] = $func(i as $type);
                i += 1;
            }
            table
        };
    }
}

generate_lookup_table!(SQRT_TABLE, f32, 100, |x| (x as f32).sqrt());

fn main() {
    println!("Square root of 25: {}", SQRT_TABLE[25]);
}

This macro generates a lookup table for the square root function at compile time, which can be more efficient than calculating the values at runtime.

Macros can also be used to implement custom attribute-like syntax. For example, you could create a macro that allows you to easily define HTTP endpoints:

macro_rules! route {
    ($method:ident $path:expr => $handler:ident) => {
        #[allow(non_snake_case)]
        mod $handler {
            use super::*;
            pub fn handle(req: Request) -> Response {
                // Implementation details omitted for brevity
            }
        }

        routes.insert(($method, $path.to_string()), $handler::handle);
    }
}

fn main() {
    let mut routes = HashMap::new();

    route!(GET "/users" => get_users);
    route!(POST "/users" => create_user);
    route!(GET "/users/:id" => get_user);
    route!(PUT "/users/:id" => update_user);
    route!(DELETE "/users/:id" => delete_user);

    // Use the routes...
}

This macro allows you to define HTTP routes in a clean, declarative style.

In conclusion, Rust macros are an incredibly powerful tool that can significantly enhance your coding experience. They allow you to write more expressive, maintainable, and efficient code by automating repetitive tasks, implementing complex patterns, and even extending the language itself. While they can be complex to write, the benefits they offer in terms of code clarity and reusability are well worth the effort. As you continue your Rust journey, I encourage you to explore the world of macros and see how they can transform your code. Happy coding!