syn-grammar 0.8.0

A parser generator for Rust that compiles EBNF-like grammars into syn::parse::Parse implementations.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52

use syn::parse::Parser;
use syn_grammar::grammar;
use syn_grammar::testing::Testable;

#[test]
fn test_generic_rule() {
    grammar! {
        grammar generic_test {
            rule list<T>(item) -> Vec<T> =
                items:item* -> { items }

            pub rule main -> Vec<i32> =
                l:list(i32) -> { l }
        }
    }

    generic_test::parse_main
        .parse_str("1 2 3")
        .test()
        .assert_success_is(vec![1, 2, 3]);
}

#[test]
fn test_generic_map() {
    grammar! {
        grammar generic_map {
            use std::collections::HashMap;

            rule map<K: std::hash::Hash + Eq, V>(k, v) -> HashMap<K, V> =
                entries:entry(k, v)* -> {
                    entries.into_iter().collect()
                }

            rule entry<K, V>(k, v) -> (K, V) =
                key:k ":" val:v -> { (key, val) }

            pub rule main -> HashMap<String, i32> =
                m:map(string, i32) -> {
                    m.into_iter().map(|(k, v)| (k.value, v)).collect()
                }
        }
    }

    let mut expected = std::collections::HashMap::new();
    expected.insert("a".to_string(), 1);
    expected.insert("b".to_string(), 2);

    generic_map::parse_main
        .parse_str("\"a\": 1 \"b\": 2")
        .test()
        .assert_success_is(expected);
}