finx 0.1.0

A fast, lightweight embeddable scripting 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
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
138
139
140
141
142
143
144
145
146
147
148
149
150
151

#[cfg(test)]
mod tests {
    use logos::Logos;
    use finx::lexer::Token;

    #[test]
    fn test_lexer() {
        let source = r#"
            let a = 1;
            let b = "hello";
            fn add(x, y) {
                if x > y {
                    return x;
                }
                return y;
            }
            if true == false {
                print("oops");
            }
        "#;

        let lexer = Token::lexer(source);
        let tokens: Vec<Token> = lexer
            .map(|token_result| token_result.unwrap_or(Token::Error))
            .collect();

        assert_eq!(
            tokens,
            vec![
                Token::Let,
                Token::Identifier("a".to_string()),
                Token::Assign,
                Token::NumberLiteral(1.0),
                Token::Semicolon,
                Token::Let,
                Token::Identifier("b".to_string()),
                Token::Assign,
                Token::StringLiteral("hello".to_string()),
                Token::Semicolon,
                Token::Fn,
                Token::Identifier("add".to_string()),
                Token::LParen,
                Token::Identifier("x".to_string()),
                Token::Comma,
                Token::Identifier("y".to_string()),
                Token::RParen,
                Token::LBrace,
                Token::If,
                Token::Identifier("x".to_string()),
                Token::Gt,
                Token::Identifier("y".to_string()),
                Token::LBrace,
                Token::Return,
                Token::Identifier("x".to_string()),
                Token::Semicolon,
                Token::RBrace,
                Token::Return,
                Token::Identifier("y".to_string()),
                Token::Semicolon,
                Token::RBrace,
                Token::If,
                Token::True,
                Token::EqEq,
                Token::False,
                Token::LBrace,
                Token::Identifier("print".to_string()),
                Token::LParen,
                Token::StringLiteral("oops".to_string()),
                Token::RParen,
                Token::Semicolon,
                Token::RBrace,
            ]
        );
    }

    #[test]
    fn test_simple_if() {
        let source = r#"
            if 1 == 1 {
                print("yes");
            } if a {
                print("a exists and is not null");
            }
        "#;
        let lexer = Token::lexer(source);
        let tokens: Vec<Token> = lexer
            .map(|token_result| token_result.unwrap_or(Token::Error))
            .collect();

        assert_eq!(
            tokens,
            vec![
                Token::If,
                Token::NumberLiteral(1.0),
                Token::EqEq,
                Token::NumberLiteral(1.0),
                Token::LBrace,
                Token::Identifier("print".to_string()),
                Token::LParen,
                Token::StringLiteral("yes".to_string()),
                Token::RParen,
                Token::Semicolon,
                Token::RBrace,
                Token::If,
                Token::Identifier("a".to_string()),
                Token::LBrace,
                Token::Identifier("print".to_string()),
                Token::LParen,
                Token::StringLiteral("a exists and is not null".to_string()),
                Token::RParen,
                Token::Semicolon,
                Token::RBrace,
            ]
        );
    }

    #[test]
    fn test_lexer_skips_comments() {
        let source = r#"let a = 1; // this is a comment
        let b = 2; /* 
        block comment 
        let d = 4;
        */ let c = 3;"#;

        let lexer = Token::lexer(source);
        let tokens: Vec<Token> = lexer
            .map(|token_result| token_result.unwrap_or(Token::Error))
            .collect();

        assert_eq!(
            tokens,
            vec![
                Token::Let,
                Token::Identifier("a".to_string()),
                Token::Assign,
                Token::NumberLiteral(1.0),
                Token::Semicolon,
                Token::Let,
                Token::Identifier("b".to_string()),
                Token::Assign,
                Token::NumberLiteral(2.0),
                Token::Semicolon,
                Token::Let,
                Token::Identifier("c".to_string()),
                Token::Assign,
                Token::NumberLiteral(3.0),
                Token::Semicolon,
            ]
        );
    }
}