Summary - Declarative macros

Combine macro_rules! and repetitions to build a vec_of! macro.

Declarative macros summary

macro_rules! generates code through pattern matching. Fragments (expr, ident, ty, tt...) say what is expected, repetitions ($(..),*, +, ?) how many times. Several arms and recursion are possible. Macros are hygienic; when exported, #[macro_export] and $crate:: are used. If a function is enough, write a function; macros are for variadic arguments, code generation and compile-time checks.

Your own vec! macro

A list macro supporting empty use, repetition and a trailing comma:

macro_rules! liste {
    () => {
        Vec::new()
    };
    ($($x:expr),+ $(,)?) => {{
        let mut v = Vec::new();
        $(v.push($x);)+
        v
    }};
}

The real vec! computes the element count at compile time to preallocate capacity.

Exercise List macro

Write the liste! macro above. Print let a: Vec<i32> = liste![]; and, with a trailing comma, let b = liste![1, 2, 3,]; with {:?}, separated by a space.

Show example solution

macro_rules! liste {
    () => {
        Vec::new()
    };
    ($($x:expr),+ $(,)?) => {{
        let mut v = Vec::new();
        $(v.push($x);)+
        v
    }};
}

fn main() {
    let a: Vec<i32> = liste![];
    let b = liste![1, 2, 3,];
    println!("{:?} {:?}", a, b);
}

Test yourself

How do <code>vec![0; 5]</code> and <code>vec![1, 2]</code> work with the same macro?
- Both are the same pattern
- It doesn't work
- vec! has two separate arms: ($e:expr; $n:expr) and ($($x:expr),*)
- The compiler treats it specially
Show answer

vec! has two separate arms: ($e:expr; $n:expr) and ($($x:expr),*) — Macro arms are tried in order; the semicolon doesn't fit the second arm's pattern.

Trailing comma

($($x:expr),+ ____) => {{
    let mut v = Vec::new();
    $(v.push($x);)+
    v
}};

Show answer

($($x:expr),+ $(,)?) => {{
    let mut v = Vec::new();
    $(v.push($x);)+
    v
}};

Group summary

macro_rules!

Generates code by pattern
$x:expr

Fragment
$(..),*

Repetition
Hijyen

No name clashes

Next lesson: proc_macro crate

We Are Enhancing Your Experience

Cookie Preferences

Strictly Necessary Cookies

Analytical Cookies