panfix 0.6.2

Panfix parsing: linear time parsing of multifix operators.
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
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119

mod visitor {
    use panfix::rpn_visitor::{Node, Stack, Visitor};

    #[derive(Debug)]
    struct Item(char);

    impl Node for Item {
        fn arity(&self) -> usize {
            match self.0 {
                'a' | 'b' => 0,
                '√' => 1,
                '+' | '*' => 2,
                '?' => 3,
                _ => unimplemented!(),
            }
        }
    }

    fn write_sexpr(sexpr: &mut String, visitor: Visitor<Item>) {
        let node = visitor.node();
        if node.arity() == 0 {
            sexpr.push(node.0);
        } else {
            sexpr.push('(');
            sexpr.push(node.0);
            assert_eq!(visitor.children().len(), node.arity());
            for child in visitor.children() {
                sexpr.push(' ');
                write_sexpr(sexpr, child);
            }
            sexpr.push(')');
        }
    }

    fn make_stack(source: &str) -> Stack<Item> {
        let mut rpn = Stack::new();
        if !source.is_empty() {
            for token in source.split(' ') {
                let ch = token.chars().next().unwrap();
                rpn.push(Item(ch));
            }
        }
        rpn
    }

    fn to_tree(source: &str) -> String {
        let rpn = make_stack(source);
        let mut sexpr = "".to_string();
        let len = rpn.groups().len();
        assert_eq!(len, rpn.num_groups());
        for (i, visitor) in rpn.groups().enumerate() {
            write_sexpr(&mut sexpr, visitor);
            if i + 1 != len {
                sexpr.push(' ');
            }
        }
        sexpr
    }

    fn last_group_to_tree(source: &str) -> String {
        let rpn = make_stack(source);
        let mut sexpr = "".to_string();
        if let Some(visitor) = rpn.last_group() {
            write_sexpr(&mut sexpr, visitor);
        }
        sexpr
    }

    #[test]
    fn test_empty() {
        assert_eq!(to_tree(""), "");
    }

    #[test]
    fn test_many_groups() {
        assert_eq!(to_tree("a a b a"), "a a b a");
        assert_eq!(to_tree("a b + b a *"), "(+ a b) (* b a)");
    }

    #[test]
    fn test_left_and_right() {
        assert_eq!(to_tree("a b a b a + * + *"), "(* a (+ b (* a (+ b a))))");
        assert_eq!(to_tree("a b + a * b + a *"), "(* (+ (* (+ a b) a) b) a)");
        assert_eq!(to_tree("a a b a ? a ?"), "(? a (? a b a) a)");
    }

    #[test]
    fn test_complicated() {
        assert_eq!(to_tree("a a * b b * + √"), "(√ (+ (* a a) (* b b)))");
        assert_eq!(
            to_tree("a a * b b * + √ a a * b b * + √"),
            "(√ (+ (* a a) (* b b))) (√ (+ (* a a) (* b b)))"
        );
    }

    #[test]
    fn test_last_group() {
        assert_eq!(last_group_to_tree(""), "");
        assert_eq!(last_group_to_tree("a a b"), "b");
        assert_eq!(last_group_to_tree("a a * b b *"), "(* b b)");
    }

    #[test]
    fn test_last_child_none() {
        let rpn = make_stack("a b");
        let group = rpn.last_group().unwrap();
        assert!(group.last_child().is_none());
    }

    #[test]
    fn test_last_child() {
        let rpn = make_stack("a a * a b * +");
        let group = rpn.groups().next().unwrap();
        let child = group.last_child().unwrap();
        let mut sexpr = String::new();
        write_sexpr(&mut sexpr, child);
        assert_eq!(sexpr, "(* a b)");
    }
}