exprs 0.1.1

A 0 dependency math expression parser and evaluator in Rust. It aims to be simple to use and is more of an exercise than anything.
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

#[derive(PartialEq, Debug)]
/// # Associativity of an operator
///
/// Given a binary operator ~
///
/// And the expression: x ~ y ~ q
///
/// If ~ is left associative it is evaluated as: (x ~ y) ~ q
///
/// If it is right associative: x ~ (y ~ q)
///
pub enum Assoc {
    LEFT,
    NONE,
    RIGHT,
}

#[derive(Debug, PartialEq, Clone, Copy)]
/// # Operators
///
/// Current Operators:
///
/// Binary Operations: +, -, *, /, ^
///
/// Unary Operations: - (negation), ! (factorial)
///
pub enum Op {
    /// Binary Operations
    SUM,
    SUB,
    EXP,
    DIV,
    MUL,
    /// Unary Operations
    FAC,
    NEG,
}

impl Op {
    /// Used to parse an Operator from a character
    ///
    /// If a valid operator was not found, it returns an err type stating the character that couldn't be parsed
    pub fn from_char(s: char) -> Result<Op, String> {
        match s {
            '-' => Ok(Op::SUB),
            '+' => Ok(Op::SUM),
            '*' => Ok(Op::MUL),
            '/' => Ok(Op::DIV),
            '^' => Ok(Op::EXP),
            '!' => Ok(Op::FAC),

            _ => Err(format!("Could not parse {} as operator", s)),
        }
    }
    /// Get the operator's associativity
    ///
    /// ```rust
    /// use exprs::{Op, Assoc};
    /// assert_eq!(Op::EXP.assoc(), Assoc::RIGHT);
    /// ```
    pub fn assoc(&self) -> Assoc {
        match *self {
            Op::SUM | Op::MUL | Op::SUB | Op::DIV => Assoc::LEFT,
            Op::EXP | Op::NEG | Op::FAC => Assoc::RIGHT,
            _ => Assoc::NONE,
        }
    }
    /// Get the operator's precedence
    ///
    /// Higher precedence operators are evaluated before lower precedence operators
    pub fn prec(&self) -> u8 {
        match *self {
            Op::NEG => 5,
            Op::EXP | Op::FAC => 4,
            Op::SUB | Op::SUM => 2,
            Op::MUL | Op::DIV => 3,
            _ => 0,
        }
    }
}

#[derive(Debug, PartialEq, Clone)]
/// # Token type
///
/// Encodes a lexical token
///
/// ## Variants
///
/// * Num(f64): A numeric literal
///     * Token::Num(3.5); the token representing the numeric literal 3.5
/// * Bin(op): A binary operator
/// * Una(op): A unary operator
/// * Fn(String): A function identifier (not yet implemented)
/// * Var(String): A variable identifier
/// * LP, RP: Left and Right parantheses
///
pub enum Token {
    /// Numeric Literal
    Num(f64),
    /// Binary Operator
    Bin(Op),
    /// Unary Operator
    Una(Op),
    /// Function identifier
    Fn(String),
    /// Variable identifier
    Var(String),
    /// Left Paren
    LP,
    /// Right Paren
    RP,
}

impl Token {
    /// check if the token is a binary operator
    #[inline]
    pub fn is_bin(&self) -> bool {
        matches!(self, Token::Bin(_x))
    }
    /// check if the token is an operator
    #[inline]
    pub fn is_op(&self) -> bool {
        matches!(self, Token::Bin(_x)) || matches!(self, Token::Una(_x))
    }
    /// get the operator's token
    #[inline]
    pub fn get_op(&self) -> Option<Op> {
        if let Token::Bin(op) = self {
            Some(op.clone())
        } else if let Token::Una(op) = self {
            Some(op.clone())
        } else {
            None
        }
    }
}