2.12 Macros: Code that Writes Code

Macros in Rust are a powerful feature for metaprogramming—writing code that generates other code at compile time. They operate on Rust’s abstract syntax tree (AST), making them more robust and integrated than C’s text-based preprocessor macros.

2.12.1 Declarative vs. Procedural Macros

  • Declarative Macros: Defined using macro_rules!, these work based on pattern matching and substitution. println!, vec!, and assert_eq! are common examples.
  • Procedural Macros: Written as separate Rust functions compiled into special crates. They allow more complex code analysis and generation, often used for tasks like deriving trait implementations (e.g., #[derive(Debug)]).
// A simple declarative macro
macro_rules! create_function {
    // Match the identifier passed (e.g., `my_func`)
    ($func_name:ident) => {
        // Generate a function with that name
        fn $func_name() {
            // Use stringify! to convert the identifier to a string literal
            println!("You called function: {}", stringify!($func_name));
        }
    };
}

// Use the macro to create a function named 'hello_macro'
create_function!(hello_macro);

fn main() {
    // Call the generated function
    hello_macro();
}

2.12.2 println! vs. C’s printf

The println! macro (and its relative print!) performs format string checking at compile time. This prevents runtime errors common with C’s printf family, where mismatches between format specifiers (%d, %s) and the actual arguments can lead to crashes or incorrect output.

2.12.3 Comparison with C

// C preprocessor macro for squaring (prone to issues)
#define SQUARE(x) x * x // Problematic if called like SQUARE(a + b) -> a + b * a + b
// Better C macro
#define SQUARE_SAFE(x) ((x) * (x))

C macros perform simple text substitution, which can lead to unexpected behavior due to operator precedence or multiple evaluations of arguments. Rust macros operate on the code structure itself, avoiding these pitfalls.