xprs 0.1.0

Xprs is a flexible and extensible mathematical expression parser and evaluator for Rust, designed for simplicity and ease of use.
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

/* Built-in imports */
use std::collections::{HashMap, HashSet};
/* Crate imports */
use crate::token::Function;

/// Represents a symbol in the context.
#[derive(Debug, PartialEq, PartialOrd, Clone)]
#[non_exhaustive]
pub enum Symbol {
    /// A variable.
    Variable(f64),
    /// A function.
    Function(Function),
}

impl From<f64> for Symbol {
    #[inline]
    fn from(value: f64) -> Self {
        Self::Variable(value)
    }
}

impl From<Function> for Symbol {
    #[inline]
    fn from(value: Function) -> Self {
        Self::Function(value)
    }
}

/// Represents the context for the mathematical expression parser.
///
/// # Examples
///
/// ```
/// use xprs::{Context, Symbol, xprs_fn};
///
/// let sin_xprs_func = xprs_fn!("sin", f64::sin, 1);
/// let mut context = Context::default()
///     .with_expected_vars(["y"].into())
///     .with_var("x", 42.0)
///     // clone because assert_eq! is used later
///     .with_fn(sin_xprs_func.clone());
///
/// let x_var = context.get("x");
/// assert_eq!(x_var, Some(&Symbol::Variable(42.0)));
///
/// let sin_func = context.get("sin");
/// assert_eq!(sin_func, Some(&Symbol::Function(sin_xprs_func)));
///
/// let expected_vars = context.get_expected_vars();
/// assert_eq!(expected_vars, Some(&["y"].into()));
/// ```
#[derive(Debug, Default, PartialEq, Clone)]
pub struct Context<'names> {
    /// The symbols that are available in the context.
    symbols: HashMap<&'names str, Symbol>,
    /// Optional set of expected variables.
    expected_vars: Option<HashSet<&'names str>>,
}

impl<'names> Context<'names> {
    /// Sets the value of a variable in the context.
    #[inline]
    pub fn set_var<T: Into<f64>>(&mut self, name: &'names str, value: T) {
        self.symbols.insert(name, value.into().into());
    }

    /// Sets the value of a variable in the context, returning the context.
    #[inline]
    #[must_use]
    pub fn with_var<T: Into<f64>>(
        mut self,
        name: &'names str,
        value: T,
    ) -> Self {
        self.symbols.insert(name, value.into().into());
        self
    }

    /// Sets a function in the context.
    #[inline]
    pub fn set_fn(&mut self, func: Function) {
        self.symbols.insert(func.name, func.into());
    }

    /// Sets a function in the context, returning the context.
    #[inline]
    #[must_use]
    pub fn with_fn(mut self, func: Function) -> Self {
        self.symbols.insert(func.name, func.into());
        self
    }

    /// Sets the expected variables for the context.
    #[inline]
    pub fn set_expected_vars(&mut self, expected_vars: HashSet<&'names str>) {
        self.expected_vars = Some(expected_vars);
    }

    /// Sets the expected variables for the context, returning the context.
    #[inline]
    #[must_use]
    pub fn with_expected_vars(
        mut self,
        expected_vars: HashSet<&'names str>,
    ) -> Self {
        self.expected_vars = Some(expected_vars);
        self
    }

    /// Sets the symbols for the context.
    #[inline]
    #[must_use]
    pub fn with_symbols(
        mut self,
        symbols: HashMap<&'names str, Symbol>,
    ) -> Self {
        self.symbols = symbols;
        self
    }

    /// Returns the value of a symbol in the context.
    #[inline]
    #[must_use]
    pub fn get(&self, name: &str) -> Option<&Symbol> {
        self.symbols.get(name)
    }

    /// Retrieves the set of expected variables from the context.
    #[inline]
    #[must_use]
    pub const fn get_expected_vars(&self) -> Option<&HashSet<&str>> {
        self.expected_vars.as_ref()
    }
}