什么是 Rust 宏？ —— 浅谈 Rust 宏

let ar = "ar";
let gu = String::from("gu");
let s = 's';

println!("literal string, and here are the {}{}{}{}.", ar, gu, "ment", s);

macro_rules! panic {
    () => ({ ¥crate::panic!("explicit panic") });
    (¥msg:expr) => ({ ¥crate::rt::begin_panic(¥msg) });
    (¥msg:expr,) => ({ ¥crate::panic!(¥msg) });
    (¥fmt:expr, ¥(¥arg:tt)+) => ({
        ¥crate::rt::begin_panic_fmt(&¥crate::format_args!(¥fmt, ¥(¥arg)+))
    });
}

(Pattern) => { Exapnsion };

macro_rules! test {
    ( ¥( ¥e:expr )* ) => { println!("expr"); };
    ( ¥( ¥t:literal )* ) => { println!("literal"); };
}

panic!(msg:expr);       // 实际上可以在 msg 的左右侧，expr 的左右侧加上空格，空格将会被忽略

¥ ( ... ) sep rep

macro_rules! zip {
    ( ¥( ¥i:expr ),* ; ¥( ¥j:expr ),* ) => {
        [ ¥( (¥i, ¥j) )* ]
    };
}

macro_rules! build_vec {
    (
        ¥( ¥i:expr ),*                          // 重复，以支持任意数量的参数
        ¥(,)?                                   // 可选的末尾逗号
    ) => {
        {                                       // 创建一个块，以支持多条语句
            let mut vec = Vec::new();           // 构造一个 Vec，必须为 mut，否则下文无法进行 push

            ¥(                                  // 重复，将每个 ¥i 推入 vec 中
                vec.push(¥i);
            )*

            vec                                 // 返回 vec
        }
    }
}

[1, 3 .. 10]
-- output: [1,3,5,7,9]
[1, 3 ..]
-- output: [1,3,5..]
[x + y | x <- [1..5], y <- [1..5]]
-- output: [2,3,4,5,6,3,4,5,6,7,4,5,6,7,8,5,6,7,8,9,6,7,8,9,10]

macro_rules! list {
    // 匹配 list!(first, second, ..)
    // 注意，second 后面的 逗号 必须保留，原因在上文已经提到过了
    ( ¥first:expr, ¥second:expr, ..) => {
        {
            let step = ¥second - ¥first;
            (¥first..).step_by(step)
        }
    };

    // 匹配 list!(first, second, .. end) 和 list!(first, second, .., end)
    ( ¥first:expr, ¥second:expr, .. ¥(,)? ¥end:expr ) => {
        {
            let step = ¥second - ¥first;
            (¥first..¥end + 1).step_by(step)
        }
    };
}

fn main() {
    println!("{:?}", list!(1, 3, .. 11).collect::<Vec<u32>>());
    println!("{:?}", list!(1, 3, ..).take(10).collect::<Vec<u32>>());       // 由于 RangeFrom 是一个无限的迭代器，所以需要使用 take

    // outputs:
    // [1, 3, 5, 7, 9, 11]
    // [1, 3, 5, 7, 9, 11, 13, 15, 17, 19]
}

xs0 >>= \x0 ->
    xs1 >>= \x1 ->
        generator x0 x1 <¥> xs2       -- 最后一个列表的迭代需要使用 map

xs0.flat_map(move |x0| {    // 必须进行 move，否则在 generator 调用的时候会抱怨生命周期
    xs1.flat_map(move |x1| {
        xs2.map(move |x2| {
            generator(x0, x1, x2)
        })
    })
})

macro_rules! __rec_iter {
    (
        ¥gen:expr ;                 // 生成器，expr 类型
        ¥id:ident <- ¥it:expr,      // 当前的迭代语句
        ¥( ¥rest:tt )* ) => {       // 剩余代码
        ¥it.flat_map(move |¥id| __rec_iter!(¥gen ; ¥( ¥rest )* ) )      // 生成一层 flat_map，其内部交给下一层 __rec_iter 宏
    };

    ( 
        ¥gen:expr ;                     // 生成器
        ¥id:ident <- ¥it:expr ) => {    // 当前的迭代语句，对于整个宏来说也是最后一个
        ¥it.map(move |¥id| ¥gen)        // 生成 map，其内部由为 gen
    };
}

macro_rules! list {
    ( ¥gen:expr ; ¥( ¥id:ident <- ¥it:expr ),* ) => {
        __rec_iter!( ¥gen ; ¥( ¥id <- ¥it ),* )
    };

    /* other rules */
}

fn main() {
    let result = list!(x + y ; x <- 1..=5, y <- 1..=5);
    println!("{:?}", result.collect::<Vec<i32>>());

    // output
    // [2, 3, 4, 5, 6, 3, 4, 5, 6, 7, 4, 5, 6, 7, 8, 5, 6, 7, 8, 9, 6, 7, 8, 9, 10]
}

macro_rules! using_x {
    ( ¥action:expr ) => {
        {
            let x = 1;
            ¥action
        }
    }
}

fn main() {
    let two = using_x!(x + 1);
}

using_x!(x + 1);
         ^ not found in this scope

fn main() {
    let two = {
        let x = 1;
        x + 1
    }
}

fn main() {
    let two = {
        let macro_x = 1;
        outer_x + 1
    }
}

macro_rules! using_x {
    ( ¥id:ident, ¥action:expr ) => {
        {
            let ¥id = 1;
            ¥action
        }
    }
}

fn main() {
    let two = using_x!(x, x + 1);
}