rust - 如何在递归 macro_rules 中扩展子模式？

Question

我正在编写一个宏来方便地匹配 enum 中的嵌套结构类型变量到编译时模板。这个想法是利用 Rust 的模式匹配在结构的某些位置强制执行特定值，或将变量绑定(bind)到其他有趣的位置。基本思想在我的实现中有效，但它不适用于嵌套模式。我认为问题在于，一旦宏输入的一部分被解析为 $<name>:pat它以后不能被解析为 $<name>:tt .

为了避免模棱两可地使用术语模式，我将根据 Rust 文档使用以下符号:

• 模式 是出现在 match 中的内容武器，在 if let语句，并在宏中由片段说明符 $<name>:pat 匹配.
• 匹配器 是宏中语法规则的左侧。
• 模板 是我的宏的输入部分，它决定了宏将如何展开。

Playground MCVE

这是 enum 的简化版本我正在使用的类型:

#[derive(Debug, Clone)]
enum TaggedValue {
    Str(&'static str),
    Seq(Vec<TaggedValue>),
}

例如下面的表达式

use TaggedValue::*;
let expression = Seq(vec![
    Str("define"),
    Seq(vec![Str("mul"), Str("x"), Str("y")]),
    Seq(vec![Str("*"), Str("x"), Str("y")]),
]);

可以被这个宏调用匹配:

match_template!(
    &expression,                               // dynamic input structure
    { println!("fn {}: {:?}", name, body) },   // action to take after successful match
    [Str("define"), [Str(name), _, _], body]   // template to match against
);

此处，成功匹配标识符 name和 body绑定(bind)到 expression 中的相应子元素并在作为第二个参数传递给宏的 block 中作为变量提供。

这是我编写上述宏的努力:

macro_rules! match_template {
    // match sequence template with one element
    ($exp:expr, $action:block, [$single:pat]) => {
        if let Seq(seq) = $exp {
            match_template!(&seq[0], $action, $single)
        } else {
            panic!("mismatch")
        }
    };

    // match sequence template with more than one element
    ($exp:expr, $action:block, [$first:pat, $($rest:tt)*]) => {
        if let Seq(seq) = $exp {
            // match first pattern in sequence against first element of $expr
            match_template!(&seq[0], {
                // then match remaining patterns against remaining elements of $expr
                match_template!(Seq(seq[1..].into()), $action, [$($rest)*])
            }, $first)
        } else {
            panic!("mismatch")
        }
    };

    // match a non sequence template and perform $action on success
    ($exp:expr, $action:block, $atom:pat) => {
        if let $atom = $exp $action else {panic!("mismatch")}
    };
}

对于非嵌套模板，它按预期工作，对于嵌套模板，我可以手动嵌套宏调用。但是，在单个宏调用中直接指定嵌套模板会失败并出现编译错误。

match_template!(
    &expression,
    {
        match_template!(
            signature,
            { println!("fn {}: {:?}", name, body) },
            [Str(name), _, _]
        )
    },
    [Str("define"), signature, body]
);
// prints:
//   fn mul: Seq([Str("*"), Str("x"), Str("y")])

match_template!(
    &expression,
    { println!("fn {}: {:?}", name, body) },
    [Str("define"), [Str(name), _, _], body]
);
// error[E0529]: expected an array or slice, found `TaggedValue`
//   --> src/main.rs:66:25
//    |
// 66 |         [Str("define"), [Str(name), _, _], body]
//    |                         ^^^^^^^^^^^^^^^^^ pattern cannot match with input type `TaggedValue`

Playground MCVE

我怀疑错误是说 [Str(name), _, _]被匹配为单个切片模式，它被第三个宏规则接受，它导致类型不匹配。但是，我希望它是一个标记树，以便第二条规则可以将它分解为一系列模式。

我尝试将第二条规则更改为 ($exp:expr, $action:block, [$first:tt, $($rest:tt)*]) =>但这只会导致错误发生在外层。

需要对宏进行哪些修改才能递归扩展此类模板？

(我认为 Recursive macro to parse match arms in Rust 中的 token 咀嚼在这里不起作用，因为我明确想在模式中绑定(bind)标识符。)

这是我希望宏调用扩展到的内容(为简洁起见，忽略不匹配的分支。此外，我通过在 seq 变量后缀来模拟宏卫生):

// macro invocation
match_template!(
    &expression,
    { println!("fn {}: {:?}", name, body) },
    [Str("define"), [Str(name), _, _], body]
);

// expansion
if let Seq(seq_1) = &expression {
    if let Str("define") = &seq_1[0] {
        if let Seq(seq_1a) = Seq(seq_1[1..].into()) {
            if let Seq(seq_2) = &seq_1a[0] {
                if let Str(name) = &seq_2[0] {
                    if let Seq(seq_2a) = Seq(seq_2[1..].into()) {
                        if let _ = &seq_2a[0] {
                            if let Seq(seq_2b) = Seq(seq_2a[1..].into()) {
                                if let _ = &seq_2b[0] {
                                    if let Seq(seq_1b) = Seq(seq_1a[1..].into()) {
                                        if let body = &seq_1b[0] {
                                            { println!("fn {}: {:?}", name, body) }
                                        }
                                    }
                                }
                            }
                        } 
                    } 
                } 
            } 
        } 
    } 
} 

完整的扩展有点冗长，但这个略微缩短的版本捕获了应该发生的事情的本质:

if let Seq(seq) = &expression {
    if let Str("define") = &seq[0] {
        if let Seq(signature) = &seq[1] {
            if let Str(name) = &signature[0] {
                if let body = &seq[2] {
                    println!("fn {}: {:?}", name, body)
                }
            }
        }
    }
}

最后，这里是another playground link这显示了递归扩展的各个步骤。它非常密集。

Answer 1

确实，问题似乎出在宏与逗号分隔的模式列表相匹配。因此，在输入 [Str("define"), [Str(name), _, _], body] 宏解释内部 [...]作为不能匹配 TaggedValue 类型表达式的切片模式。

解决方案是将输入扩展为标记树。然而，这需要一个小技巧，因为单个标记树不能代表所有模式。特别是，Variant(value) 形式的模式由两个标记树组成:Variant 和 (value)。在调用宏的终端(非递归)规则之前，可以将这两个标记组合回一个模式。

例如，在单元素模板中匹配这种模式的规则是这样开始的:

($exp:expr, $action:block, [$single_variant:tt $single_value:tt]) =>

这些标记一起传递给宏的另一个调用

match_template!(&seq[0], $action, $single_variant $single_value)

终端规则将它们匹配为单个模式

($exp:expr, $action:block, $atom:pat) =>

最终的宏定义包含两个额外的规则来解释Variant(value) 模式:

macro_rules! match_template {
    ($exp:expr, $action:block, [$single:tt]) => {
        if let Seq(seq) = $exp {
            match_template!(&seq[0], $action, $single)
        } else {
            panic!("mismatch")
        }
    };

    ($exp:expr, $action:block, [$single_variant:tt $single_value:tt]) => {
        if let Seq(seq) = $exp {
            match_template!(&seq[0], $action, $single_variant $single_value)
        } else {
            panic!("mismatch")
        }
    };

    ($exp:expr, $action:block, [$first:tt, $($rest:tt)*]) => {
        if let Seq(seq) = $exp {
            match_template!(&seq[0], {
                match_template!(Seq(seq[1..].into()), $action, [$($rest)*])
            }, $first)
        } else {
            panic!("mismatch")
        }
    };

    ($exp:expr, $action:block, [$first_variant:tt $first_value:tt, $($rest:tt)*]) => {
        if let Seq(seq) = $exp {
            match_template!(&seq[0], {
                match_template!(Seq(seq[1..].into()), $action, [$($rest)*])
            }, $first_variant $first_value)
        } else {
            panic!("mismatch")
        }
    };

    ($exp:expr, $action:block, $atom:pat) => {
        if let $atom = $exp $action else {panic!("mismatch")}
    };
}

这是完整示例的链接:playground .