mathlex 0.4.1

Mathematical expression parser for LaTeX and plain text notation, producing a language-agnostic AST
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
138
139
140
141
142
143
144
145
146
147

//! Calculus function parsing: integrate, sum, product, limit.

use super::*;

impl TextParser {
    /// Parses `integrate(expr, var)` or `integrate(expr, var, lower, upper)`.
    ///
    /// The `var` argument should be a plain identifier (the variable of integration).
    /// Aliases: `integral`, `int`.
    pub(super) fn parse_integrate_function(&mut self) -> ParseResult<Expression> {
        self.consume(Token::LParen)?;
        let integrand = self.parse_expression()?;
        self.consume(Token::Comma)?;

        // Second arg: variable of integration — may be bare identifier or d-prefixed (dx)
        let var_raw = self.expect_identifier("variable of integration")?;
        let var = if var_raw.starts_with('d') && var_raw.len() > 1 {
            var_raw[1..].to_string() // strip leading 'd' from dx, dt, etc.
        } else {
            var_raw
        };

        let bounds = if self.check(&Token::Comma) {
            self.next();
            let lower = self.parse_expression()?;
            self.consume(Token::Comma)?;
            let upper = self.parse_expression()?;
            Some(IntegralBounds {
                lower: Box::new(lower),
                upper: Box::new(upper),
            })
        } else {
            None
        };

        self.consume(Token::RParen)?;
        Ok(ExprKind::Integral {
            integrand: Box::new(integrand),
            var,
            bounds,
        }
        .into())
    }

    /// Parses `sum(expr, var, lower, upper)`.
    ///
    /// Aliases: `summation`, `Sum`.
    pub(super) fn parse_sum_function(&mut self) -> ParseResult<Expression> {
        self.consume(Token::LParen)?;
        let body = self.parse_expression()?;
        self.consume(Token::Comma)?;
        let index = self.expect_identifier("index variable")?;
        self.consume(Token::Comma)?;
        let lower = self.parse_expression()?;
        self.consume(Token::Comma)?;
        let upper = self.parse_expression()?;
        self.consume(Token::RParen)?;
        Ok(ExprKind::Sum {
            index,
            lower: Box::new(lower),
            upper: Box::new(upper),
            body: Box::new(body),
        }
        .into())
    }

    /// Parses `product(expr, var, lower, upper)`.
    ///
    /// Aliases: `prod`, `Product`.
    pub(super) fn parse_product_function(&mut self) -> ParseResult<Expression> {
        self.consume(Token::LParen)?;
        let body = self.parse_expression()?;
        self.consume(Token::Comma)?;
        let index = self.expect_identifier("index variable")?;
        self.consume(Token::Comma)?;
        let lower = self.parse_expression()?;
        self.consume(Token::Comma)?;
        let upper = self.parse_expression()?;
        self.consume(Token::RParen)?;
        Ok(ExprKind::Product {
            index,
            lower: Box::new(lower),
            upper: Box::new(upper),
            body: Box::new(body),
        }
        .into())
    }

    /// Parses `limit(expr, var, point[, direction])`.
    ///
    /// Direction is optional: `"+"` or `"right"` for right-hand,
    /// `"-"` or `"left"` for left-hand, omitted for two-sided.
    /// Aliases: `lim`, `Limit`.
    pub(super) fn parse_limit_function(&mut self) -> ParseResult<Expression> {
        self.consume(Token::LParen)?;
        let expr = self.parse_expression()?;
        self.consume(Token::Comma)?;
        let var = self.expect_identifier("limit variable")?;
        self.consume(Token::Comma)?;
        let to = self.parse_expression()?;

        let direction = if self.check(&Token::Comma) {
            self.next();
            // Expect a direction identifier: +, -, left, right
            let dir_token = self.next().ok_or_else(|| {
                ParseError::unexpected_eof(
                    vec!["direction (+, -, left, right)"],
                    Some(self.current_span()),
                )
            })?;
            match &dir_token.value {
                Token::Plus => Direction::Right,
                Token::Minus => Direction::Left,
                Token::Identifier(s) => match s.as_str() {
                    "right" | "Right" => Direction::Right,
                    "left" | "Left" => Direction::Left,
                    "both" | "Both" => Direction::Both,
                    _ => {
                        return Err(ParseError::unexpected_token(
                            vec!["direction (+, -, left, right)"],
                            format!("{}", dir_token.value),
                            Some(dir_token.span),
                        ));
                    }
                },
                _ => {
                    return Err(ParseError::unexpected_token(
                        vec!["direction (+, -, left, right)"],
                        format!("{}", dir_token.value),
                        Some(dir_token.span),
                    ));
                }
            }
        } else {
            Direction::Both
        };

        self.consume(Token::RParen)?;
        Ok(ExprKind::Limit {
            expr: Box::new(expr),
            var,
            to: Box::new(to),
            direction,
        }
        .into())
    }
}