它提供了非常 宽松 的解析器，它们会在存在各种错误的情况下愉快地生成解析树。一方面，这增加了处理解析树时需要处理的案例数量。另一方面，这些额外的情况是错误情况，这将是为它们生成自定义错误消息的好时机。

示例：JSON

最好的介绍可能是通过一个工作示例。让我们看看使用Panfix解析解析JSON需要什么。这是一个JSON的Panfix语法

use panfix::{Parser, Grammar, GrammarError};

fn make_json_parser() -> Result<Parser, GrammarError> {
    let mut grammar = Grammar::new("[ \n\r\t]+")?;
    grammar.regex("String", r#""([^\\"]|(\\.))*""#)?;
    grammar.regex("Number", r#"-?(?:0|[1-9]\d*)(?:\.\d+)?(?:[eE][+-]?\d+)?"#)?;
    grammar.regex("Invalid", r#"[a-zA-Z_][a-zA-Z0-9_]*"#)?; // for catching missing qutoes
    grammar.string("Null", "null")?;
    grammar.string("True", "true")?;
    grammar.string("False", "false")?;
    grammar.op("Array", pattern!("[" "]"))?;
    grammar.op("Object", pattern!("{" "}"))?;
    grammar.right_assoc();
    grammar.op("Keyval", pattern!(_ ":" _))?;
    grammar.right_assoc();
    grammar.op("Comma", pattern!(_ "," _))?;
    grammar.finish()
}

regex 和 string 行定义了如何解析像字符串和布尔值这样的常量。 regex 表示“匹配这个正则表达式模式”，string 表示“匹配这个精确字符串”。Array 行表示[开始一个数组并]结束它。类似的，“Object”行。

接下来是

    grammar.right_assoc();
    grammar.op("Keyval", pattern!(_ ":" _))?;
    grammar.right_assoc();
    grammar.op("Comma", pattern!(_ "," _))?;

两个 right\_assoc 调用开始了两个 优先级组，每个组有一个运算符。优先级组有两个效果。

首先，在先前定义的组中定义的运算符比在后来定义的组中定义的运算符绑定更紧密。例如，您会将在优先级较低的组中定义 &&，而不是在优先级较高的组中定义 >，这样 x < y && y < z 就会被解析为 (x < y) && (y < z)，而不是 x < (y && y) < z。

其次，每个优先级组声明其运算符是左结合还是右结合。例如，字段访问 _._ 应声明为右结合，以便 person.birthday.month 被解析为 (person.birthday).month，而不是 person.(birthday.month)。在 JSON 示例中，我们声明 : 和 , 为右结合，但在这种情况下，左结合同样适用。

pattern!(_ "," _) 声明 , 是一个接受左右参数的操作符，分别由开始和结束处的下划线表示。相比之下，pattern!("[" "]") 缺少下划线，因此表示 JSON 数组不接受左右参数。另一方面，在标记之间总是允许 存在 参数：例如在 [ 和 ] 之间。

注意这个语法没有说明的一些事情。它没有说 : 只允许在对象 {...} 内部使用，也没有说对象键必须是字符串。正前缀解析在这方面相当不寻常。您不是定义想要的精确语法，而是定义一个语法的 超集，然后在处理解析树时构建上下文特定的错误消息。

解析一些（格式不佳的）JSON

让我们看看当我们这样解析格式不佳的 "JSON" 时会发生什么：

{
    "id": 999,
    "object_class:" "safe",
    "weight_kg": 54.5
    "disposition": "friendly",
    "diet": [
        "M&Ms",
        "Necco wafers",
        "other sweets",
    ],
    "interactions": {
        "target_id": 682,
        "effect": mixed,
    }
}

如下：

let parser = make\_json\_parser().unwrap();
let input = ...read that JSON file...;
let source = Source::new("bad\_json", input);
match parser.parse(&source) { ... }

parse 的调用实际上会返回 Ok 而不是 Err！这是因为正前缀解析故意非常宽松。它唯一关心的是运算符是否完整，在这个例子中，[ 总是与 ] 匹配，而 { 总是与 } 匹配。因此，parse 返回 Ok(tree)。当你 Display 这个树时，你会得到：

(Object
  (Comma (Keyval "id" 999)
    (Comma (_ "object_class:" "safe")
      (Comma
        (Keyval "weight_kg"
          (Keyval (_ 54.5 "disposition") "friendly"))
        (Comma
          (Keyval "diet"
            (Array
              (Comma "M&Ms"
                (Comma "Necco wafers"
                  (Comma "other sweets" _)))))
          (Keyval "interactions"
            (Object
              (Comma (Keyval "target_id" 682)
                (Comma (Keyval "effect" mixed) _)))))))))

解析宽松性的机制在于隐式插入两种类型的节点，显示为上面所示的 _。

空节点

空节点是在缺少参数的地方插入的。例如，考虑JSON的“饮食”部分

"diet": [
    "M&Ms",
    "Necco wafers",
    "other sweets",
],

, 定义为接受两个参数，但缺少了 之后 的参数 "other sweets",。因此，在解析树中插入一个空节点，记作 _

(Array
  (Comma "M&Ms"
    (Comma "Necco wafers"
      (Comma "other sweets" _)))))

在JSON中这是一个错误，尽管在一些允许尾随逗号的编程语言中不会是错误。

并列节点

并列节点是空节点的补充：它们是在一行中有两个表达式但没有任何连接它们的地方插入的。例如，这个JSON片段

"weight_kg": 54.5
"disposition": "friendly",

变成了解析树中的这个片段

(Keyval "weight_kg"
  (Keyval (_ 54.5 "disposition") "friendly"))

其中 _ 是一个并列节点，表示 54.5 和 "disposition" 是并列的（即相邻的）。

    #[derive(Debug)]
    enum Json {
        String(String),
        Number(f64),
        Boolean(bool),
        Null,
        Array(Vec<Json>),
        Object(HashMap<String, Json>),
    }

fn parse_list(&mut self, mut visitor: Visitor<'s, '_, '_>, elems: &mut Vec<Json>) {
    while visitor.name() == "Comma" {
        let [head, tail] = visitor.children();
        let head = self.parse_value(head);
        elems.push(head);
        visitor = tail;
    }
    if visitor.name() == "Blank" {
        self.error(visitor, "JSON does not allow trailing commas.");
    } else {
        elems.push(self.parse_value(visitor));
    }
}

Parse Error: Expected a key:value pair.
At 'stdin' line 2.

    "object_class:" "safe",
    ^^^^^^^^^^^^^^^^^^^^^^

Parse Error: Expected a JSON value here, not a key:value pair.
At 'stdin' lines 3-4.
    "weight_kg": 54.5
                 ^^^^
    "disposition": "friendly",
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

Parse Error: JSON does not allow trailing commas.
At 'stdin' line 8.

        "other sweets",
                       ^

Parse Error: Missing quotes.
At 'stdin' line 12.

        "effect": mixed,
                  ^^^^^

Parse Error: JSON does not allow trailing commas.
At 'stdin' line 12.

        "effect": mixed,
                        ^