honeycomb

一个不需要运行时的便携式解析器组合库

文档

您可以在这里找到 honeycomb 的文档。

依赖项

没有！Honeycomb 甚至不需要标准库！

您只需要一个可以运行 Rust 的设备，就可以开始使用了。

JSON 解析器

以下是一个 JSON 解析器的示例。

基本上，我们定义函数，从小的原子解析器创建更大的解析器。我们创建解析布尔值、字符串、数字和 null 值的解析器，然后使用这些解析器构建解析数组、对象定义的解析器。

extern crate honeycomb;
use honeycomb::{
    atoms::{rec, seq_no_ws},
    language,
    transform::{to_btree, to_number},
    Parser,
};

use std::collections::BTreeMap;

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

fn boolean() -> Parser<JsonValue> {
    (seq_no_ws("true").map(|_| JsonValue::Bool(true)))
        | (seq_no_ws("false").map(|_| JsonValue::Bool(false)))
}

fn string() -> Parser<String> {
    language::string()
}

fn number() -> Parser<JsonValue> {
    language::number()
        .map(to_number)
        .map(JsonValue::Num)
}

fn null() -> Parser<JsonValue> {
    seq_no_ws("null")
        .map(|_| JsonValue::Null)
}

fn array() -> Parser<JsonValue> {
    language::array("[", json(), "]")
        .map(JsonValue::Array)
}

fn object() -> Parser<JsonValue> {
    language::array("{", string().suffix(seq_no_ws(":")) & rec(json), "}")
        .map(to_btree).map(JsonValue::Object)
}

fn json() -> Parser<JsonValue> {
    null() | boolean() | number() | (string() - JsonValue::Str) | rec(array) | rec(object)
}

fn main() {
    println!(
        "{:#?}",
        json().parse(
            r#"
{
    "testing" : null,
    "recursion" : {
        "WOW": 1.2345
    },
    "array": [1, 2, {"test": "123"}, 4],
    "test": "testing"
}
"#
        )
    );
}

编程语言分词器

这使用了一个内置的解析器，称为 token。

token 解析器返回一个字符串向量，表示标识符、字符串、数字和符号。

在这里，我们使用 token 解析器创建一个接受任意数量标记的解析器。

extern crate honeycomb;
use honeycomb::language::token;

fn main() {
    println!(
        "{:?}",
        (token().repeat(..)).parse(
            r#"

struct Point {
    x: i32, y: i32
}


fn testing() {
    println("hello world!");
}

fn main() {

}
"#
        )
    );
}