bjorn 0.2.0

Another side project interpreter.
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

#[derive(Debug, PartialEq, Clone)]
pub enum Token {
    INT(String),
    FLOAT(String),
    BOOL(bool),
    ID(String),

    NEWLINE,
    INDENT,
    DEDENT,

    IF,
    ELSE,
    WHILE,

    DEF,
    RETURN,

    COLON,
    COMMA,

    OR,
    AND,
    NOT,

    EQ,
    NE,
    LE,
    GE,
    LT,
    GT,

    ASSIGN,

    PLUS,
    MINUS,
    MUL,
    DIV,

    LPAREN,
    RPAREN,

    EOF,
}

impl Token {
    pub fn integer(&self) -> Option<i32> {
        if let Token::INT(i) = self {
            return match i.parse::<i32>() {
                Ok(i) => Some(i),
                Err(_) => None
            }
        }
        None
    }

    pub fn float(&self) -> Option<f64> {
        if let Token::FLOAT(i) = self {
            return match i.parse::<f64>() {
                Ok(i) => Some(i),
                Err(_) => None
            }
        }
        None
    }

    pub fn boolean(&self) -> Option<bool> {
        if let Token::BOOL(i) = self {
            return Some(*i)
        }
        None
    }

    pub fn identifier(&self) -> Option<String> {
        if let Token::ID(i) = self {
            return match i.parse::<String>() {
                Ok(i) => Some(i),
                Err(_) => None
            }
        }
        None
    }
}