wotex 0.0.0

...
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

use super::*;


impl LowerHex for ASTNode {
    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
        match self {
            ASTNode::Sequence(e) => { LowerHex::fmt(e, f) }
            ASTNode::List(_) => { todo!() }
            ASTNode::Variable(e) => { Display::fmt(e, f) }
            ASTNode::Function(_, _) => { todo!() }
            ASTNode::Evaluated(e) => { LowerHex::fmt(&**e, f) }
        }
    }
}

impl LowerHex for Sequence {
    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
        for i in &self.inner {
            LowerHex::fmt(i, f)?;
        }
        Ok(())
    }
}

impl MaybeParentheses {
    fn need_parentheses(&self) -> bool {
        // f() or atan(x, y)
        if self.rest.len() != 1 {
            return true;
        }
        false
    }
}

impl LowerHex for MaybeParentheses {
    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
        match self.operator_name {
            true =>
                write!(f, "\\operatorname{{{}}}", self.head)?,
            false =>
                write!(f, "\\{}", self.head)?
        }
        let parentheses = self.need_parentheses();
        let count = self.rest.len();
        f.write_char('{')?;
        if parentheses {
            f.write_str("\\left(")?;
        }
        for (i, ast) in self.rest.iter().enumerate() {
            write!(f, "{:x}", ast)?;
            if i != count - 1 {
                f.write_char(',')?;
            }
        }
        if parentheses {
            f.write_str("\\right)")?;
        }
        f.write_char('}')
    }
}