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
|
## std.ast: Exposes the AST for building and operating on with macros.
pub type Expr = union
Ident(string), Number(int), Float(float), Char(chr), String(str)
Struct(list[tuple[field: str, value: Expr]])
Tuple(list[tuple[field: string?, value: Expr]])
List(list[Expr])
Let(id: Pattern, kind: Type?, value: ref Expr)
Var(id: Pattern, kind: Type?, value: ref Expr?)
Const(id: Pattern, kind: Type?, value: ref Expr)
FuncDecl( # effects?
id: str,
generics: list[GenericParams],
params: list[FunctionParams],
kind: Type,
body: list[Expr]
)
TypeDecl(id: str, generics: list[str], alias: Type)
Module(id: str, body: list[Expr])
Use(path: str)
Pub(Expr) # can easily generate incoherent statements. still desired?
Call(id: str, params: list[Expr])
Cond(branches: list[CondBranch], else_body: list[Expr]?)
Try(
try_body: list[Expr],
catches: list[TryBranch]
finally_body: list[Expr]?
)
Match(
item: ref Expr,
branches: list[MatchBranch]
)
Block(id: str?, body: list[Expr])
ConstBlock(body: list[Expr]),
For(binding: Pattern, range: ref Expr, body: list[Expr])
While(cond: ref Expr, body: list[Expr])
Loop(body: list[Expr]),
pub type CondBranch = tuple
cond: Expr
body: list[Expr]
pub type TryBranch = tuple
exceptions: list[str]
body: list[Expr]
pub type MatchBranch = tuple
pattern: Pattern
guard: Option[Expr]
body: list[Expr]
pub type Type = ref union
Void, Never,
Integer, Float, String,
Func(from: Type, to: Type) # todo: multiple parameters
Struct(list[tuple[id: str, kind: Type]])
Tuple(list[tuple[id: str?, kind: Type]])
Union(list[tuple[id: str, kind: Type]])
Interface( # todo: generics
funcs: list[Signature]
for_type: Type?
)
Array(size: uint, kind: Type)
List(Type)
Slice(Type) # todo: plus ownership
Alias(str) # todo: params?? huh?
Static(Type)
Mutable(Type)
Reference(Type)
Pointer(Type)
pub type Signature = struct # todo: generics
id: str
effect: Option[str]
params: list[Type]
kind: Option[Type]
pub type Pattern = union
Ident(str)
Number(int), Float(float), Char(chr), String(str)
Struct(name: str, params: list[Pattern])
Tuple(list[Pattern])
List(list[Pattern])
|
