匹配多个字符

string(pattern) - 匹配给定的 pattern，但不是将其转换为某个值，而是简单地返回匹配的字符作为 String。

默认情况下，alpha+ 返回一个 Vec<char>，这在 AoC 中有时很有用，但通常最好返回一个 String。

自定义转换

... name1:pattern1 ... => expr - 在成功匹配到 => 左侧的模式后，计算 Rust 表达式 expr 将结果转换为单个 Rust 值。

使用此功能将输入转换为结构体。例如，假设你的谜题输入包含每个精灵的名字和身高

Holly=33
Ivy=7
DouglasFir=1093

并且你希望将其转换为 struct Elf 值的向量。你需要编写的代码是

struct Elf {
    name: String,
    height: u32,
}

let p = parser!(lines(
    elf:string(alpha+) '=' ht:u32 => Elf { name: elf, height: ht }
));

名字 elf 适用于模式 string(alpha+)，名字 ht 适用于模式 i32。=> 后面是普通的 Rust 代码。

名字 仅在相同匹配括号或花括号集中的 expr 中有效。

备选方案

{pattern1, pattern2, ...} - 匹配任何一种 模式。首先尝试匹配 pattern1；如果匹配，停止。如果不匹配，则尝试 pattern2，依此类推。所有模式必须产生相同类型的 Rust 值。

这类似于 Rust 的 match 表达式。

例如，parser!({"<" => -1, ">" => 1}) 要么匹配 <，返回值 -1，要么匹配 >，返回 1。

备选方案在你想将输入转换为枚举时很有用。例如，我的 2015 年 12 月 23 日的谜题输入是一系列看起来像这样的指令列表

jie a, +4
tpl a
inc a
jmp +2
hlf a
jmp -7

这可以轻松解析为美观的枚举向量，如下所示

enum Reg {
    A,
    B,
}

enum Insn {
    Hlf(Reg),
    Tpl(Reg),
    Inc(Reg),
    Jmp(isize),
    Jie(Reg, isize),
    Jio(Reg, isize),
}

use Reg::*;
use Insn::*;

let reg = parser!({"a" => A, "b" => B});
let p = parser!(lines({
    "hlf " r:reg => Hlf(r),
    "tpl " r:reg => Tpl(r),
    "inc " r:reg => Inc(r),
    "jmp " offset:isize => Jmp(offset),
    "jie " r:reg ", " offset:isize => Jie(r, offset),
    "jio " r:reg ", " offset:isize => Jio(r, offset),
}));

规则集

rule name1: type1 = pattern1; - 引入一个“规则”，一个有名称的子解析器。

这支持解析带有嵌套括号或方括号的文本。

enum Formation {
    Elf(char),
    Stack(Vec<Formation>),
}

let p = parser!(
    // First rule: A "formation" has return type Formation and is either
    // a letter or a stack.
    rule formation: Formation = {
        s:alpha => Formation::Elf(s),
        v:stack => Formation::Stack(v),
    };

    // Second rule: A "stack" is one or more formations, wrapped in
    // matching parentheses.
    rule stack: Vec<Formation> = '(' v:formation+ ')' => v;

    // After all rules, the pattern that .parse() will actually match.
    lines(formation+)
);

assert!(p.parse("px(fo(i)(RR(c)))j(Q)zww\n").is_ok());

assert!(p.parse("x(fo))\n").is_err());  // parens not balanced

通常 let 就足以用于其他解析器使用的解析器；但 rule 对于像上面的 formation 和 stack 那样需要自我引用或相互引用的解析器是必需的。Rust 的 let 不支持这一点。

注意：左递归语法通常不适用于 PEG 解析器。

行和部分

line(pattern) - 匹配匹配 pattern 的单行文本和行尾的换行符。

这类似于正则表达式中的 ^pattern\n，有两个小差异

• line(pattern) 将仅匹配一行文本，即使 pattern 可以匹配更多换行符。

• 如果您的输入不以换行符结尾，line(<var<pattern)仍然可以匹配末尾的非换行符结束的"line"。

line(string(any_char+))匹配一行文本，移除换行符，并返回剩余的部分作为一个String。 line("")匹配一个空白行。

lines(pattern) - 匹配任何数量的与pattern匹配的文本行。等同于line(pattern)*。

let p = parser!(lines(repeat_sep(digit, " ")));
assert_eq!(
    p.parse("1 2 3\n4 5 6\n").unwrap(),
    vec![vec![1, 2, 3], vec![4, 5, 6]],
);

section(pattern) - 匹配零个或多个非空白行，随后是一个空白行或输入结束。非空白行必须与pattern匹配。例如，section(lines(u64))匹配一个包含数字的列表部分，每行一个。

AoC谜题的输入通常包含几行数据，然后是一个空白行，然后是不同类型的数据。您可以使用section(p1) section(p2)来解析它。

sections(pattern) - 匹配任何数量的与pattern匹配的部分。等同于section(pattern)*。

集合

hash_set(pattern)，hash_map(pattern)，btree_set(pattern)，btree_map(pattern)，vec_deque(pattern) - 这些使用pattern匹配一些文本，然后将结果值放入HashSet或其他集合中。

pattern必须生成一个可迭代类型。这些函数通过在pattern生成的任何内容上调用.into_iter()来实现，然后使用.collect()来生成新的集合。

pattern本身需要一个*或+，或者其他使其匹配多个值的东西。

let p = parser!(hash_set(digit+));  // <-- note the `+`
assert_eq!(p.parse("3127").unwrap(), HashSet::from([1, 2, 3, 7]));

一个映射是由一对序列构建的

let p = parser!(hash_map(
    lines(string(alpha+) ": " any_char)   // <-- this produces a vector of (String, char) pairs
));

assert_eq!(
    p.parse("Midge: @\nToyler: #\nKnitley: &\n").unwrap(),
    HashMap::from([
        ("Midge".to_string(), '@'),
        ("Toyler".to_string(), '#'),
        ("Knitley".to_string(), '&'),
    ]),
);

将所有这些结合起来解析一个复杂示例

let example = "\
Wiring Diagram #1:
a->q->E->z->J
D->f->D

Wiring Diagram #2:
g->r->f
g->B
";

let p = parser!(sections(
    line("Wiring Diagram #" usize ":")
    lines(repeat_sep(alpha, "->"))
));
assert_eq!(
    p.parse(example).unwrap(),
    vec![
        (1, vec![vec!['a', 'q', 'E', 'z', 'J'], vec!['D', 'f', 'D']]),
        (2, vec![vec!['g', 'r', 'f'], vec!['g', 'B']]),
    ],
);

许可证：MIT