t-ree 0.1.0

AST definitions for the T programming language
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

/// Arithmetic binary operators.
#[derive(Copy, Clone, Debug, PartialEq, Eq)]
pub enum ArithmeticOperator {
    /// Addition (`+`).
    Add,
    /// Subtraction (`-`).
    Subtract,
    /// Multiplication (`*`).
    Multiply,
    /// Division (`/`).
    Divide,
    /// Remainder (`%`).
    Remainder,
}

/// Comparison binary operators.
#[derive(Copy, Clone, Debug, PartialEq, Eq)]
pub enum ComparisonOperator {
    /// Equal (`==`).
    Equal,
    /// Not equal (`!=`).
    NotEqual,
    /// Less than (`<`).
    Less,
    /// Less than or equal (`<=`).
    LessEqual,
    /// Greater than (`>`).
    Greater,
    /// Greater than or equal (`>=`).
    GreaterEqual,
}

/// Logical binary operators.
#[derive(Copy, Clone, Debug, PartialEq, Eq)]
pub enum LogicalOperator {
    /// Logical AND (`&&`).
    And,
    /// Logical OR (`||`).
    Or,
}

/// Bitwise binary operators.
#[derive(Copy, Clone, Debug, PartialEq, Eq)]
pub enum BitwiseOperator {
    /// Bitwise AND (`&`).
    And,
    /// Bitwise OR (`|`).
    Or,
    /// Bitwise XOR (`^`).
    Xor,
    /// Left shift (`<<`).
    ShiftLeft,
    /// Right shift (`>>`).
    ShiftRight,
}

/// Binary operator categories.
#[derive(Copy, Clone, Debug, PartialEq, Eq)]
pub enum BinaryOperator {
    /// Arithmetic operator.
    Arithmetic(ArithmeticOperator),
    /// Comparison operator.
    Comparison(ComparisonOperator),
    /// Logical operator.
    Logical(LogicalOperator),
    /// Bitwise operator.
    Bitwise(BitwiseOperator),
}

impl std::fmt::Display for BinaryOperator {
    fn fmt(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        match self {
            Self::Arithmetic(ArithmeticOperator::Add) => write!(formatter, "+"),
            Self::Arithmetic(ArithmeticOperator::Subtract) => write!(formatter, "-"),
            Self::Arithmetic(ArithmeticOperator::Multiply) => write!(formatter, "*"),
            Self::Arithmetic(ArithmeticOperator::Divide) => write!(formatter, "/"),
            Self::Arithmetic(ArithmeticOperator::Remainder) => write!(formatter, "%"),
            Self::Comparison(ComparisonOperator::Equal) => write!(formatter, "=="),
            Self::Comparison(ComparisonOperator::NotEqual) => write!(formatter, "!="),
            Self::Comparison(ComparisonOperator::Less) => write!(formatter, "<"),
            Self::Comparison(ComparisonOperator::LessEqual) => write!(formatter, "<="),
            Self::Comparison(ComparisonOperator::Greater) => write!(formatter, ">"),
            Self::Comparison(ComparisonOperator::GreaterEqual) => write!(formatter, ">="),
            Self::Logical(LogicalOperator::And) => write!(formatter, "&&"),
            Self::Logical(LogicalOperator::Or) => write!(formatter, "||"),
            Self::Bitwise(BitwiseOperator::And) => write!(formatter, "&"),
            Self::Bitwise(BitwiseOperator::Or) => write!(formatter, "|"),
            Self::Bitwise(BitwiseOperator::Xor) => write!(formatter, "^"),
            Self::Bitwise(BitwiseOperator::ShiftLeft) => write!(formatter, "<<"),
            Self::Bitwise(BitwiseOperator::ShiftRight) => write!(formatter, ">>"),
        }
    }
}

/// Unary operators.
#[derive(Copy, Clone, Debug, PartialEq, Eq)]
pub enum UnaryOperator {
    /// Arithmetic negation (`-x`).
    Negate,
    /// Logical NOT (`!x`).
    LogicalNot,
    /// Bitwise NOT (`~x`).
    BitwiseNot,
}