Rust — Macros

Declarative macros

macro_rules! say_hello {
    () => {
        println!("Hello, World!");
    };
}

macro_rules! create_function {
    ($func_name:ident) => {
        fn $func_name() {
            println!("Function: {}", stringify!($func_name));
        }
    };
}

create_function!(foo);
create_function!(bar);

fn main() {
    say_hello!();
    foo();
    bar();
}

Macro with parameters

macro_rules! calculate {
    (eval $e:expr) => {
        {
            let val: i64 = $e;
            println!("{} = {}", stringify!($e), val);
        }
    };
}

fn main() {
    calculate!(eval 1 + 2);
    calculate!(eval 10 * 5);
}

Pattern matching in macros

macro_rules! vector {
    ($($x:expr),*) => {
        {
            let mut temp_vec = Vec::new();
            $(
                temp_vec.push($x);
            )*
            temp_vec
        }
    };
}

fn main() {
    let v = vector![1, 2, 3, 4, 5];
    println!("{:?}", v);
}

Procedural macros

// Custom derive macro
use proc_macro::TokenStream;

#[proc_macro_derive(HelloMacro)]
pub fn hello_macro_derive(input: TokenStream) -> TokenStream {
    // Implementation
    input
}

Mini Practice

Write Rust code that:

1. Creates a basic macro with macro_rules!
2. Uses pattern matching in macros
3. Creates a macro that generates functions
4. Demonstrates macro hygiene

Up Next

In the next lesson, you'll learn about Unsafe Rust — when you need more control.