blanket-script 0.0.2

BlanketScript is a simple script language inspired by Rust that transpiles to JavaScript.
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

use nom::{
    bytes::complete::tag,
    sequence::{delimited, pair, terminated},
    Parser,
};

use crate::parser::{
    expression::{parse_expression, parse_identifier},
    ws1,
};

use super::{ws0, Expression, ParseResult};

#[derive(Debug, Eq, PartialEq, Clone)]
pub enum Statement {
    LetStatement {
        identifier: String,
        expression: Expression,
    },
}

fn parse_let_statement(input: &str) -> ParseResult<Statement> {
    pair(
        delimited(tag("let"), ws1(parse_identifier), tag("=")),
        terminated(ws0(parse_expression), tag(";")),
    )
    .map(|(identifier, expression)| Statement::LetStatement {
        identifier,
        expression,
    })
    .parse(input)
}

pub(crate) fn parse_statement(input: &str) -> ParseResult<Statement> {
    parse_let_statement(input)
}

#[cfg(test)]
mod tests {
    use super::*;
    use crate::parser::*;

    macro_rules! assert_parse {
        ($input:expr, $expected:expr) => {
            let (rest, result) = parse_statement($input).unwrap();
            assert_eq!(rest, "");
            assert_eq!(result, $expected);
        };
    }

    #[test]
    fn test_parse_let_statement() {
        assert_parse!(
            "let x = 42;",
            Statement::LetStatement {
                identifier: "x".into(),
                expression: Expression::Number("42".into())
            }
        );
        assert_parse!(
            "let foo = 42n;",
            Statement::LetStatement {
                identifier: "foo".into(),
                expression: Expression::BigInt("42".into())
            }
        );
        assert_parse!(
            "let bar = \"hello\";",
            Statement::LetStatement {
                identifier: "bar".into(),
                expression: Expression::String(StringLiteral {
                    value: "hello".into(),
                    interpolations: vec![]
                })
            }
        );
        assert_parse!(
            "let baz = bar;",
            Statement::LetStatement {
                identifier: "baz".into(),
                expression: Expression::Identifier("bar".into())
            }
        );
    }
}