这是一个添加了一些跟踪功能的分支。如果有疑问，请使用标准的 pom 包。

pom

使用运算符重载不使用宏创建的 PEG 解析器组合器。

文档

• 教程
• API 参考
• 使用 Rust 学习解析器组合器 - By Bodil Stokke

什么是 PEG？

PEG 代表解析表达式语法，是一种分析形式语法，即它用一组识别语言中字符串的规则来描述形式语言。与 CFG 不同，PEG 不能是歧义的；如果字符串可以解析，它只有一个有效的解析树。每个解析函数在概念上将其输入字符串作为参数，并产生以下结果之一

• 成功，其中函数可以可选地向前移动或消耗一个或多个输入字符串提供的字符，或者
• 失败，在这种情况下不消耗任何输入。

更多信息请参阅 维基百科。

什么是解析器组合器？

解析器组合器是一个高阶函数，它接受几个解析器作为输入，并返回一个新的解析器作为其输出。解析器组合器启用递归下降解析策略，这有利于模块化分块构建和测试。

使用组合器构建的解析器易于构建、易于阅读、模块化、结构良好且易于维护。使用运算符重载，解析器组合器可以采用中缀运算符的形式，用于将不同的解析器粘合在一起形成一个完整的规则。因此，解析器组合器使得解析器可以以嵌入式方式定义，代码结构与形式语法的规则相似。而且，代码比宏更容易调试。

主要优势是您不需要经过任何类型的代码生成步骤，您始终使用底层的基础语言。除了构建问题（以及通常与错误消息和可调试性相关的问题，公平地说，宏与代码生成的问题差不多）之外，通常更容易自由地混合语法表达式和普通代码。

预定义解析器和组合器列表

操作符的选择由它们的操作符优先级、元数和“意义”确定。使用 * 忽略表达式开始时第一个操作符的结果，+ 和 - 可以满足表达式其余部分的需求。

例如，A * B * C - D + E - F 将返回 C 和 E 的结果作为一对。

示例代码

extern crate pom;
use pom::parser::*;

let input = b"abcde";
let parser = sym(b'a') * none_of(b"AB") - sym(b'c') + seq(b"de");
let output = parser.parse(input);
assert_eq!(output, Ok( (b'b', vec![b'd', b'e']) ) );

示例 JSON 解析器

extern crate pom;
use pom::parser::*;
use pom::Parser;

use std::collections::HashMap;
use std::str::{self, FromStr};

#[derive(Debug, PartialEq)]
pub enum JsonValue {
	Null,
	Bool(bool),
	Str(String),
	Num(f64),
	Array(Vec<JsonValue>),
	Object(HashMap<String,JsonValue>)
}

fn space() -> Parser<u8, ()> {
	one_of(b" \t\r\n").repeat(0..).discard()
}

fn number() -> Parser<u8, f64> {
	let integer = one_of(b"123456789") - one_of(b"0123456789").repeat(0..) | sym(b'0');
	let frac = sym(b'.') + one_of(b"0123456789").repeat(1..);
	let exp = one_of(b"eE") + one_of(b"+-").opt() + one_of(b"0123456789").repeat(1..);
	let number = sym(b'-').opt() + integer + frac.opt() + exp.opt();
	number.collect().convert(str::from_utf8).convert(|s|f64::from_str(&s))
}

fn string() -> Parser<u8, String> {
	let special_char = sym(b'\\') | sym(b'/') | sym(b'"')
		| sym(b'b').map(|_|b'\x08') | sym(b'f').map(|_|b'\x0C')
		| sym(b'n').map(|_|b'\n') | sym(b'r').map(|_|b'\r') | sym(b't').map(|_|b'\t');
	let escape_sequence = sym(b'\\') * special_char;
	let string = sym(b'"') * (none_of(b"\\\"") | escape_sequence).repeat(0..) - sym(b'"');
	string.convert(String::from_utf8)
}

fn array() -> Parser<u8, Vec<JsonValue>> {
	let elems = list(call(value), sym(b',') * space());
	sym(b'[') * space() * elems - sym(b']')
}

fn object() -> Parser<u8, HashMap<String, JsonValue>> {
	let member = string() - space() - sym(b':') - space() + call(value);
	let members = list(member, sym(b',') * space());
	let obj = sym(b'{') * space() * members - sym(b'}');
	obj.map(|members|members.into_iter().collect::<HashMap<_,_>>())
}

fn value() -> Parser<u8, JsonValue> {
	( seq(b"null").map(|_|JsonValue::Null)
	| seq(b"true").map(|_|JsonValue::Bool(true))
	| seq(b"false").map(|_|JsonValue::Bool(false))
	| number().map(|num|JsonValue::Num(num))
	| string().map(|text|JsonValue::Str(text))
	| array().map(|arr|JsonValue::Array(arr))
	| object().map(|obj|JsonValue::Object(obj))
	) - space()
}

pub fn json() -> Parser<u8, JsonValue> {
	space() * value() - end()
}

fn main() {
	let input = br#"
	{
        "Image": {
            "Width":  800,
            "Height": 600,
            "Title":  "View from 15th Floor",
            "Thumbnail": {
                "Url":    "http://www.example.com/image/481989943",
                "Height": 125,
                "Width":  100
            },
            "Animated" : false,
            "IDs": [116, 943, 234, 38793]
        }
    }"#;

	println!("{:?}", json().parse(input));
}

您可以使用以下命令运行此示例

cargo run --example json

基准测试

生命周期和文件

字符串字面量具有静态生命周期，因此它们可以与从 pom::Parser 导入的静态版本的 Parser 一起工作。从文件中读取的输入具有较短的生存期。在这种情况下，你应该导入 pom::parser::Parser 并在你的解析函数上声明生命周期。所以

fn space() -> Parser<u8, ()> {
    one_of(b" \t\r\n").repeat(0..).discard()
}

会变成

fn space<'a>() -> Parser<'a, u8, ()> {
    one_of(b" \t\r\n").repeat(0..).discard()
}