gyard 0.1.2

A generic shunting yard algorithm implementation
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
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137

use std::fmt::Debug;

use gyard::{InputToken, Operator, OutputToken};

#[derive(Debug, PartialEq)]
pub struct MathAdd;
#[derive(Debug, PartialEq)]
pub struct MathSub;
#[derive(Debug, PartialEq)]
pub struct MathMul;
#[derive(Debug, PartialEq)]
pub struct MathDiv;

impl gyard::Operator for MathAdd {
    fn precedence(&self) -> usize {
        11
    }

    fn is_left_associative(&self) -> bool {
        true
    }
}
impl Eval for MathAdd {
    fn eval(&self, value_stack: &mut Vec<f64>) {
        let a = value_stack.pop().unwrap();
        let b = value_stack.pop().unwrap();
        let r = a + b;
        value_stack.push(r);
    }
}

impl gyard::Operator for MathSub {
    fn precedence(&self) -> usize {
        11
    }

    fn is_left_associative(&self) -> bool {
        true
    }
}
impl Eval for MathSub {
    fn eval(&self, value_stack: &mut Vec<f64>) {
        let a = value_stack.pop().unwrap();
        let b = value_stack.pop().unwrap();
        let r = a - b;
        value_stack.push(r);
    }
}

impl gyard::Operator for MathMul {
    fn precedence(&self) -> usize {
        12
    }

    fn is_left_associative(&self) -> bool {
        true
    }
}
impl Eval for MathMul {
    fn eval(&self, value_stack: &mut Vec<f64>) {
        let a = value_stack.pop().unwrap();
        let b = value_stack.pop().unwrap();
        let r = a * b;
        value_stack.push(r);
    }
}

impl gyard::Operator for MathDiv {
    fn precedence(&self) -> usize {
        12
    }

    fn is_left_associative(&self) -> bool {
        true
    }
}
impl Eval for MathDiv {
    fn eval(&self, value_stack: &mut Vec<f64>) {
        let a = value_stack.pop().unwrap();
        let b = value_stack.pop().unwrap();
        let r = a / b;
        value_stack.push(r);
    }
}

trait Eval: Operator {
    fn eval(&self, value_stack: &mut Vec<f64>);
}

impl gyard::Operator for Box<dyn Eval> {
    fn precedence(&self) -> usize {
        self.as_ref().precedence()
    }

    fn is_left_associative(&self) -> bool {
        self.as_ref().is_left_associative()
    }
}
impl Eval for Box<dyn Eval> {
    fn eval(&self, value_stack: &mut Vec<f64>) {
        self.as_ref().eval(value_stack);
    }
}

fn main() {
    // 1 + 2 - f ( 3 ) * 4 / 5
    let infix = [
        InputToken::Value(1.),
        InputToken::Operator(Box::new(MathAdd) as Box<dyn Eval>),
        InputToken::Value(2.),
        InputToken::Operator(Box::new(MathSub)),
        InputToken::Function("f"),
        InputToken::LeftParen,
        InputToken::Value(3.),
        InputToken::RightParen,
        InputToken::Operator(Box::new(MathMul)),
        InputToken::Value(4.),
        InputToken::Operator(Box::new(MathDiv)),
        InputToken::Value(5.),
    ];
    let postfix = gyard::to_postfix(infix).unwrap();

    let mut value_stack = Vec::<f64>::new();
    for token in postfix {
        match token {
            OutputToken::Function("f") => {
                let v = value_stack.pop().unwrap();
                value_stack.push(v * 2. + 1.)
            }
            OutputToken::Function(_) => unimplemented!(),
            OutputToken::Value(v) => value_stack.push(v),
            OutputToken::Operator(o) => o.eval(&mut value_stack),
        }
    }
    assert_eq!(value_stack.len(), 1);
    assert_eq!(value_stack[0], -2.6)
}