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

//! Expression and logical operator parsing for the text parser.

use super::*;

impl TextParser {
    pub(super) fn parse_expression(&mut self) -> ParseResult<Expression> {
        self.parse_logical()
    }

    pub(super) fn parse_logical(&mut self) -> ParseResult<Expression> {
        if let Some(token) = self.peek() {
            if matches!(token.value, Token::Not) {
                self.next();
                let operand = self.parse_logical()?;
                return Ok(ExprKind::Logical {
                    op: LogicalOp::Not,
                    operands: vec![operand],
                }
                .into());
            }
        }
        let mut left = self.parse_quantifier()?;
        while let Some(token) = self.peek() {
            let op = match &token.value {
                Token::Iff => LogicalOp::Iff,
                Token::Implies => LogicalOp::Implies,
                Token::Or => LogicalOp::Or,
                Token::And => LogicalOp::And,
                _ => break,
            };
            self.next();
            let right = self.parse_quantifier()?;
            left = ExprKind::Logical {
                op,
                operands: vec![left, right],
            }
            .into();
        }
        Ok(left)
    }

    pub(super) fn parse_quantifier(&mut self) -> ParseResult<Expression> {
        if let Some(token) = self.peek() {
            match &token.value {
                Token::ForAll => {
                    self.next();
                    return self.parse_quantifier_body(false);
                }
                Token::Exists => {
                    self.next();
                    return self.parse_quantifier_body(true);
                }
                _ => {}
            }
        }
        self.parse_set_operation()
    }

    /// Parses the body of a quantifier: variable [in domain], body
    pub(super) fn parse_quantifier_body(&mut self, is_exists: bool) -> ParseResult<Expression> {
        let variable = if let Some(token) = self.peek() {
            if let Token::Identifier(name) = &token.value {
                let var = name.clone();
                self.next();
                var
            } else {
                return Err(ParseError::unexpected_token(
                    vec!["variable"],
                    format!("{}", token.value),
                    Some(token.span),
                ));
            }
        } else {
            return Err(ParseError::unexpected_eof(
                vec!["variable"],
                Some(self.current_span()),
            ));
        };

        let domain = if let Some(token) = self.peek() {
            if matches!(token.value, Token::In) {
                self.next();
                Some(Box::new(self.parse_set_operation()?))
            } else {
                None
            }
        } else {
            None
        };

        self.consume(Token::Comma)?;
        let body = Box::new(self.parse_logical()?);

        if is_exists {
            Ok(ExprKind::Exists {
                variable,
                domain,
                body,
                unique: false,
            }
            .into())
        } else {
            Ok(ExprKind::ForAll {
                variable,
                domain,
                body,
            }
            .into())
        }
    }
}