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
|
> {
> module Parser (parse) where
> import Type
> import Lexer
> }
> %token
> backslash { Builtin "\\" }
> var { Ident $$ }
> rightarrow { Builtin "->" }
> caseT { Builtin "case" }
> letT { Builtin "let" }
> ofT { Builtin "of" }
> inT { Builtin "in" }
> letnT { Builtin "letn" }
> leftcurly { LeftCurly }
> rightcurly { RightCurly }
> equals { Builtin "=" }
> colon { Builtin ":" }
> cons { Constructor $$ }
> leftbracket { LeftBracket }
> rightbracket { RightBracket }
> semicolon { SemiColon }
> percent { Percent }
> %name parse
> %tokentype { Token }
> %%
> expr
> : backslash var binders rightarrow expr
> { foldr Lambda $5 ($2: reverse $3) }
> | caseT var ofT leftcurly patterns rightcurly
> { Case $2 (reverse $5) }
> | letT var equals var expr inT expr
> { LetApp ($2,$4,$5) $7 }
> | letT var equals expr inT expr
> { Let ($2,$4) $6 }
> | letnT var equals expr inT expr
> { LetN ($2,$4) $6 }
>
> | labelref colon expr { Label $1 $3 }
> | simpleexpr { $1 }
> simpleexpr
> : cons simpleexprs { Cons $1 (reverse $2) }
> | simpleexpr0 { $1 }
>
> simpleexprs
> : simpleexprs simpleexpr0 { $2 : $1 }
> | { [] }
>
> simpleexpr0
> : var { Var $1 }
> | labelref { LabelRef $1 }
> | leftbracket expr rightbracket { $2 }
>
> patterns
> : patterns pattern { $2 : $1 }
> | pattern { [ $1 ] }
>
> pattern : cons binders rightarrow expr semicolon
> { ($1, reverse $2, $4) }
>
> binders : binders var { $2 : $1 }
> | { [ ] }
>
> labelref
> : percent var { $2 }
> {
> happyError :: Int -> a
> happyError x = error ("Error at LINE " ++ show x)
> }
|
