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
|
package hm
// A Namer is anything that knows its own name
type Namer interface {
Name() string
}
// A Typer is an Expression node that knows its own Type
type Typer interface {
Type() Type
}
// An Inferer is an Expression that can infer its own Type given an Env
type Inferer interface {
Infer(Env, Fresher) (Type, error)
}
// An Expression is basically an AST node. In its simplest form, it's lambda calculus
type Expression interface {
Body() Expression
}
// Var is an expression representing a variable
type Var interface {
Expression
Namer
Typer
}
// Literal is an Expression/AST Node representing a literal
type Literal interface {
Var
IsLit() bool
}
// Apply is an Expression/AST node that represents a function application
type Apply interface {
Expression
Fn() Expression
}
// LetRec is an Expression/AST node that represents a recursive let
type LetRec interface {
Let
IsRecursive() bool
}
// Let is an Expression/AST node that represents the standard let polymorphism found in functional languages
type Let interface {
// let name = def in body
Expression
Namer
Def() Expression
}
// Lambda is an Expression/AST node that represents a function definiton
type Lambda interface {
Expression
Namer
IsLambda() bool
}
|
