Rust by Example

($expression:expr) => {

// `stringify!` will convert the expression *as it is* into a string.

println!("{:?} = {:?}",

stringify!($expression),

$expression);

};

}

fn main() {

foo();

bar();

print_result!(1u32 + 1);

// Recall that blocks are expressions too!

print_result!({

let x = 1u32;

x * x + 2 * x - 1

});

}

הההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההה

XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

These are some of the available designators:

   • block

   • expr is used for expressions

   • ident is used for variable/function names

   • item

   • literal is used for literal constants

   • pat (pattern)

   • path

   • stmt (statement)

   • tt (token tree)

   • ty (type)

   • vis (visibility qualifier)

For a complete list, see the Rust Reference.

Overload

Macros can be overloaded to accept different combinations of arguments. In that regard, macro_rules! can work similarly to a match block:

// `test!` will compare `$left` and `$right`

// in different ways depending on how you invoke it:

macro_rules! test {

// Arguments don't need to be separated by a comma.

// Any template can be used!

($left:expr; and $right:expr) => {

println!("{:?} and {:?} is {:?}",

stringify!($left),

stringify!($right),

$left && $right)

};

// ^ each arm must end with a semicolon.

($left:expr; or $right:expr) => {

println!("{:?} or {:?} is {:?}",

stringify!($left),

stringify!($right),

$left || $right)

};

}

fn main() {

test!(1i32 + 1 == 2i32; and 2i32 * 2 == 4i32);

test!(true; or false);

}

הההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההה

XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

Repeat

Macros can use + in the argument list to indicate that an argument may repeat at least once, or *, to indicate that the argument may repeat zero or more times.

In the following example, surrounding the matcher with $(...),+ will match one or more expression, separated by commas. Also note that the semicolon is optional on the last case.

// `find_min!` will calculate the minimum of any number of arguments.

macro_rules! find_min {

// Base case:

($x:expr) => ($x);

// `$x` followed by at least one `$y,`

($x:expr, $($y:expr),+) => (