aiken-lang 1.0.22-alpha

The Aiken compiler
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

use chumsky::prelude::*;

use crate::{
    ast,
    parser::{error::ParseError, token::Token},
};

use super::function;

pub fn parser() -> impl Parser<Token, ast::UntypedDefinition, Error = ParseError> {
    just(Token::Validator)
        .ignore_then(
            function::param(true)
                .separated_by(just(Token::Comma))
                .allow_trailing()
                .delimited_by(just(Token::LeftParen), just(Token::RightParen))
                .map_with_span(|arguments, span| (arguments, span))
                .or_not(),
        )
        .then(
            function()
                .repeated()
                .at_least(1)
                .at_most(2)
                .delimited_by(just(Token::LeftBrace), just(Token::RightBrace))
                .map(|defs| {
                    defs.into_iter().map(|def| {
                        let ast::UntypedDefinition::Fn(fun) = def else {
                            unreachable!("It should be a fn definition");
                        };

                        fun
                    })
                }),
        )
        .map_with_span(|(opt_extra_params, mut functions), span| {
            let (params, params_span) = opt_extra_params.unwrap_or((
                vec![],
                ast::Span {
                    start: 0,
                    end: span.start + "validator".len(),
                },
            ));

            ast::UntypedDefinition::Validator(ast::Validator {
                doc: None,
                fun: functions
                    .next()
                    .expect("unwrapping safe because there's 'at_least(1)' function"),
                other_fun: functions.next(),
                location: ast::Span {
                    start: span.start,
                    // capture the span from the optional params
                    end: params_span.end,
                },
                params,
                end_position: span.end - 1,
            })
        })
}

#[cfg(test)]
mod tests {
    use crate::assert_definition;

    #[test]
    fn validator() {
        assert_definition!(
            r#"
            validator {
              fn foo(datum, rdmr, ctx) {
                True
              }
            }
            "#
        );
    }

    #[test]
    fn double_validator() {
        assert_definition!(
            r#"
            validator {
              fn foo(datum, rdmr, ctx) {
                True
              }

              fn bar(rdmr, ctx) {
                True
              }
            }
            "#
        );
    }
}