mathexpr 0.1.1

A fast, safe mathematical expression parser and evaluator with bytecode compilation
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

//! Error types for mathexpr.
//!
//! This module provides error types for parsing and evaluation failures.

#[cfg(not(feature = "std"))]
use alloc::string::String;

use core::fmt;

/// Error returned when parsing a mathematical expression fails.
#[derive(Debug, Clone, PartialEq)]
pub enum ParseError {
    /// The parser succeeded but there was unexpected input remaining.
    UnexpectedTrailingInput(String),
    /// The expression contains invalid syntax.
    InvalidSyntax(String),
}

impl fmt::Display for ParseError {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        match self {
            ParseError::UnexpectedTrailingInput(s) => {
                write!(f, "Unexpected trailing input: {}", s)
            }
            ParseError::InvalidSyntax(s) => write!(f, "Invalid syntax: {}", s),
        }
    }
}

#[cfg(feature = "std")]
impl std::error::Error for ParseError {}

/// Error returned when evaluating a compiled expression fails.
#[derive(Debug, Clone, PartialEq)]
pub enum EvalError {
    /// A variable was referenced that wasn't provided during compilation.
    UnknownVariable(String),
    /// Division or modulo by zero.
    DivisionByZero,
    /// An unknown function was called.
    UnknownFunction(String),
    /// A function was called with the wrong number of arguments.
    WrongArity {
        /// The function name.
        name: String,
        /// Expected number of arguments.
        expected: usize,
        /// Actual number of arguments provided.
        got: usize,
    },
    /// A mathematical error occurred (e.g., sqrt of negative number).
    MathError(String),
}

impl fmt::Display for EvalError {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        match self {
            EvalError::UnknownVariable(name) => write!(f, "Unknown variable: {}", name),
            EvalError::DivisionByZero => write!(f, "Division by zero"),
            EvalError::UnknownFunction(name) => write!(f, "Unknown function: {}", name),
            EvalError::WrongArity {
                name,
                expected,
                got,
            } => {
                write!(
                    f,
                    "Function {} expects {} args, got {}",
                    name, expected, got
                )
            }
            EvalError::MathError(msg) => write!(f, "Math error: {}", msg),
        }
    }
}

#[cfg(feature = "std")]
impl std::error::Error for EvalError {}

/// Error returned when compiling an expression fails.
#[derive(Debug, Clone, PartialEq)]
pub enum CompileError {
    /// A variable in the expression was not in the provided variable list.
    UndefinedVariable(String),
    /// An unknown function was used in the expression.
    UnknownFunction(String),
    /// A function was called with the wrong number of arguments.
    WrongArity {
        /// The function name.
        name: String,
        /// Expected number of arguments.
        expected: usize,
        /// Actual number of arguments provided.
        got: usize,
    },
}

impl fmt::Display for CompileError {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        match self {
            CompileError::UndefinedVariable(name) => {
                write!(f, "Undefined variable: {}", name)
            }
            CompileError::UnknownFunction(name) => {
                write!(f, "Unknown function: {}", name)
            }
            CompileError::WrongArity {
                name,
                expected,
                got,
            } => {
                write!(
                    f,
                    "Function {} expects {} args, got {}",
                    name, expected, got
                )
            }
        }
    }
}

#[cfg(feature = "std")]
impl std::error::Error for CompileError {}