introduction_to_rust_declarative_macros

reverse_polish_notation.rs

macro_rules! rpn {
    { @inner_op stack [$r:expr, $l:expr $(, $stack:expr)*]; $op:tt $($tt:tt)* } => {
        rpn! { @inner stack [$l $op $r $(, $stack)*]; $($tt)* }
    };
    { @inner stack [$res:expr]; } => { $res };
    { @inner stack $stack:tt; + $($tt:tt)* } => {
        rpn!{ @inner_op stack $stack; + $($tt)* }
    };
    { @inner stack $stack:tt; - $($tt:tt)* } => {
        rpn!{ @inner_op stack $stack; - $($tt)* }
    };
    { @inner stack $stack:tt; * $($tt:tt)* } => {
        rpn!{ @inner_op stack $stack; * $($tt)* }
    };
    { @inner stack $stack:tt; / $($tt:tt)* } => {
        rpn!{ @inner_op stack $stack; / $($tt)* }
    };
    { @inner stack [$($stack:expr),*]; $num:tt $($tt:tt)* } => {
        rpn!{ @inner stack [$num $(, $stack)*]; $($tt)* }
    };
	{ $($tt:tt)* } => {
	   rpn!{ @inner stack [ ]; $($tt)* }
	};
}

fn main() {
    assert_eq! { rpn! {3 4 +}, 7};
    assert_eq! { rpn! {3 4 + 5 +}, 12};
    assert_eq! { rpn! {3 4 5 + *}, 27};
    assert_eq! { rpn! {15 7 1 1 + - / 3 * 2 1 1 + + -}, 5};
}

simple_macro.rs

macro_rules! pow {
    (squared $n:expr) => {
        $n.pow(2)
    };
    (cubed $n:expr) => {
        $n.pow(3)
    };
}

macro_rules! adder {
    () => { 0 };
    ($($n:expr),*) => {
        {
            let mut sum = 0;
            $(
                sum += $n;
            )*
            sum
        }
    };
}

macro_rules! calculator {
    {add $($add:expr),*; mul $($mul:expr),*} => {
        {
            let mut sum = 0;
            let mut mul = 1;
            $(
                sum += $add;
            )*
            $(
                mul *= $mul;
            )*
            (sum, mul)
        }
    }
}

fn main() {
    assert_eq!(pow!(squared 2_i32), 4);
    assert_eq!(pow!(cubed 2_i32), 8);

    assert_eq!(adder!(1, 2, 3, 4), 10);
    assert_eq!(adder!(1), 1);
    assert_eq!(adder!(), 0);
    
    assert_eq!(calculator!(add 1, 2, 3; mul 1, 2, 3), (6, 6));
}