typed-eval 0.1.0

A type-safe expression evaluation engine.
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

use crate::{Span, Spanned};

#[derive(Debug, Clone, PartialEq)]
pub enum Expr {
    Int(Spanned<i64>),
    Float(Spanned<f64>),
    String(Spanned<String>),
    Var(Spanned<String>),
    UnOp(Spanned<UnOp>, Box<Expr>),
    BinOp(Spanned<BinOp>, Box<Expr>, Box<Expr>),
    FieldAccess(Box<Expr>, Spanned<String>),
    FuncCall(Box<Expr>, Spanned<Vec<Expr>>),
    InvalidLiteral(Spanned<String>),
    ParseError,
}

#[derive(Debug, Clone, Copy, Hash, PartialEq, Eq)]
pub enum BinOp {
    Add,
    Mul,
    Sub,
    Div,
}

#[derive(Debug, Clone, Copy, Hash, PartialEq, Eq)]
pub enum UnOp {
    Neg,
    Plus,
}

impl Expr {
    pub fn span(&self) -> Span {
        match self {
            Expr::Int(val) => val.span(),
            Expr::Float(val) => val.span(),
            Expr::String(val) => val.span(),
            Expr::Var(s) => s.span(),
            Expr::UnOp(op, rhs) => op.span().join(rhs.span()),
            Expr::BinOp(op, lhs, rhs) => {
                op.span().join(lhs.span()).join(rhs.span())
            }
            Expr::FieldAccess(obj, field) => obj.span().join(field.span()),
            Expr::FuncCall(func, args) => func.span().join(args.span()),
            Expr::InvalidLiteral(err) => err.span(),
            Expr::ParseError => Span::test_span(),
        }
    }
}