aiken-lang 1.1.23

Cardano smart contract language and toolchain
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

use super::guard;
use crate::{
    ast,
    expr::UntypedExpr,
    parser::{error::ParseError, pattern, token::Token},
};
use chumsky::prelude::*;
use vec1::vec1;

pub fn parser(
    expression: Recursive<'_, Token, UntypedExpr, ParseError>,
) -> impl Parser<Token, ast::UntypedClause, Error = ParseError> + '_ {
    pattern()
        .then(
            choice((
                just(Token::Vbar),
                just(Token::VbarVbar),
                just(Token::Or),
                just(Token::Comma),
            ))
            .ignore_then(pattern())
            .repeated()
            .or_not(),
        )
        .then(choice((just(Token::If)
            .ignore_then(guard())
            .or_not()
            .then_ignore(just(Token::RArrow)),)))
        // TODO: add hint "Did you mean to wrap a multi line clause in curly braces?"
        .then(expression)
        .validate(
            |(((pattern, alternative_patterns_opt), guard), then), span, emit| {
                if guard.is_some() {
                    emit(ParseError::deprecated_when_clause_guard(span));
                }

                (pattern, alternative_patterns_opt, then)
            },
        )
        .map_with_span(|(pattern, alternative_patterns_opt, then), span| {
            let mut patterns = vec1![pattern];
            patterns.append(&mut alternative_patterns_opt.unwrap_or_default());
            ast::UntypedClause {
                location: span,
                patterns,
                then,
            }
        })
}

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

    #[test]
    fn when_clause_todo() {
        assert_expr!(
            r#"
            when val is {
              Bar1{..} -> True
              Bar2{..} -> todo @"unimplemented"
            }
            "#
        );
    }

    #[test]
    fn when_clause_solo_error() {
        assert_expr!(
            r#"
            when val is {
              Bar1{..} -> fail
            }
            "#
        );
    }

    #[test]
    fn when_clause_double_todo() {
        assert_expr!(
            r#"
            when val is {
              Bar1{..} -> todo
              Bar2{..} -> todo
            }
            "#
        );
    }

    #[test]
    fn when_clause_alternative() {
        assert_expr!(
            r#"
            when val is {
              Bar1{..} | Bar2{..} -> todo
              Bar3{..} || Bar4{..} -> todo
              Bar5{..} or Bar6{..} -> todo
              Bar5{..}, Bar6{..} -> todo
            }
            "#
        );
    }
}