monkeyinterpreter 0.2.0

An interpreter written in Rust for the monkey programming language described in the book 'Writing An Interpreter In Go' (https://interpreterbook.com/).
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

use std::fmt::{self, Display};

#[derive(PartialEq, Clone, Eq, Hash, Debug)]
pub enum Token {
    Illegal,
    EOF,

    // Identifiers + literals
    Ident(String),
    Int(i64),

    // Booleans
    True,
    False,

    String(String),

    // Operators
    Assign,
    Plus,
    Minus,
    Bang,
    Asterisk,
    Slash,
    EQ,
    NotEq,

    LT,
    GT,

    // Delimiters
    Comma,
    Semicolon,
    Colon,

    LParen,
    RParen,
    RBrace,
    LBrace,
    LBracket,
    RBracket,

    // Keywords
    Function,
    Let,
    If,
    Else,
    Return,
}

impl Token {
    pub fn get_representative_token(&self) -> Token {
        match self {
            Token::Ident(_) => Token::Ident("".to_owned()),
            Token::Int(_) => Token::Int(0),
            Token::String(_) => Token::String("".to_owned()),
            _ => self.to_owned(),
        }
    }

    /// Returns `true` if the token is [`Ident`].
    ///
    /// [`Ident`]: Token::Ident
    #[must_use]
    pub fn is_ident(&self) -> bool {
        matches!(self, Self::Ident(..))
    }
}

impl Display for Token {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        let s;
        let res = match self {
            Token::Illegal => "Illegal",
            Token::EOF => "EOF",
            Token::Ident(x) => x,
            Token::Int(x) => {
                s = x.to_string();
                &s
            }
            Token::True => "true",
            Token::False => "false",
            Token::Assign => "=",
            Token::Plus => "+",
            Token::Minus => "-",
            Token::Bang => "!",
            Token::Asterisk => "*",
            Token::Slash => "/",
            Token::EQ => "==",
            Token::NotEq => "!=",
            Token::LT => "<",
            Token::GT => ">",
            Token::Comma => ",",
            Token::Semicolon => ";",
            Token::LParen => "(",
            Token::RParen => ")",
            Token::RBrace => "{",
            Token::LBrace => "}",
            Token::LBracket => "[",
            Token::RBracket => "]",
            Token::Function => "fn",
            Token::Let => "let",
            Token::If => "if",
            Token::Else => "else",
            Token::Return => "return",
            Token::Colon => ":",
            Token::String(s) => s,
        };
        write!(f, "{}", res)
    }
}