mihama 0.0.1

A Modern Functional and Dependent Type Programming Language Base on Rust
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
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137

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

#[derive(Debug, PartialEq, Clone)]
pub enum Token {
    LeftParen,    // (
    RightParen,   // )
    LeftBrace,    // {
    RightBrace,   // }
    LeftBracket,  // [
    RightBracket, // ]
    Comma,        // ,
    Dot,          // .
    Semicolon,    // ;
    Colon,        // :

    Plus,         // +
    Sub,          // -
    Mul,          // *
    Div,          // /
    Pow,          // **
    Mod,          // %
    Assign,       // =
    Equal,        // ==
    Not,          // !
    NotEqual,     // !=
    Greater,      // >
    GreaterEqual, // >=
    Less,         // <
    LessEqual,    // <=
    Arrow,        // =>
    ThinArrow,    // ->
    Arm,          // |
    And,          // &&
    Or,           // ||

    Ident(String),
    Float(f64),
    Int(i64),
    String(String),
    Char(char),

    Let,
    Type,
    Match,
    If,
    Then,
    Else,
    In,
    Import,
    Export,
    From,
    As,
    Abstract,

    LineComment(String),
    BlockComment(String),

    Eof,
}

impl Display for Token {
    fn fmt(&self, f: &mut Formatter) -> fmt::Result {
        match self {
            Token::LeftParen => write!(f, "("),
            Token::RightParen => write!(f, ")"),
            Token::LeftBrace => write!(f, "{{"),
            Token::RightBrace => write!(f, "}}"),
            Token::LeftBracket => write!(f, "["),
            Token::RightBracket => write!(f, "]"),
            Token::Comma => write!(f, ","),
            Token::Dot => write!(f, "."),
            Token::Semicolon => write!(f, ";"),
            Token::Colon => write!(f, ":"),

            Token::Plus => write!(f, "+"),
            Token::Sub => write!(f, "-"),
            Token::Mul => write!(f, "*"),
            Token::Div => write!(f, "/"),
            Token::Pow => write!(f, "**"),
            Token::Mod => write!(f, "%"),
            Token::Assign => write!(f, "="),
            Token::Equal => write!(f, "=="),
            Token::Not => write!(f, "!"),
            Token::NotEqual => write!(f, "!="),
            Token::Greater => write!(f, ">"),
            Token::GreaterEqual => write!(f, ">="),
            Token::Less => write!(f, "<"),
            Token::LessEqual => write!(f, "<="),
            Token::Arrow => write!(f, "=>"),
            Token::ThinArrow => write!(f, "->"),
            Token::Arm => write!(f, "|"),
            Token::And => write!(f, "&&"),
            Token::Or => write!(f, "||"),

            Token::Ident(s) => write!(f, "{}", s),
            Token::Float(n) => write!(f, "{}", n),
            Token::Int(n) => write!(f, "{}", n),
            Token::String(s) => write!(f, "{}", s),
            Token::Char(c) => write!(f, "{}", c),

            Token::Let => write!(f, "let"),
            Token::Type => write!(f, "type"),
            Token::Match => write!(f, "match"),
            Token::If => write!(f, "if"),
            Token::Then => write!(f, "then"),
            Token::Else => write!(f, "else"),
            Token::In => write!(f, "in"),
            Token::Import => write!(f, "import"),
            Token::Export => write!(f, "export"),
            Token::From => write!(f, "from"),
            Token::As => write!(f, "as"),
            Token::Abstract => write!(f, "abstract"),

            Token::LineComment(s) => write!(f, "//{}", s),
            Token::BlockComment(s) => write!(f, "/*{}*/", s),

            Token::Eof => write!(f, "EOF"),
        }
    }
}

#[derive(Debug, Clone, PartialEq)]
pub struct TokenData {
    pub token: Token,
    pub line: usize,
    pub column: usize,
}

impl Display for TokenData {
    fn fmt(&self, f: &mut Formatter) -> fmt::Result {
        write!(
            f,
            "TokenData: {:?} at line {}, column {}",
            self.token, self.line, self.column
        )
    }
}