Commit | Line | Data |
---|---|---|
7f918cf1 CE |
1 | (* Copyright (C) 2015,2017 Matthew Fluet |
2 | * Copyright (C) 1999-2008 Henry Cejtin, Matthew Fluet, Suresh | |
3 | * Jagannathan, and Stephen Weeks. | |
4 | * Copyright (C) 1997-2000 NEC Research Institute. | |
5 | * | |
6 | * MLton is released under a BSD-style license. | |
7 | * See the file MLton-LICENSE for details. | |
8 | *) | |
9 | ||
10 | signature CORE_ML_STRUCTS = | |
11 | sig | |
12 | include ATOMS | |
13 | structure Type: | |
14 | sig | |
15 | type t | |
16 | ||
17 | val arrow: t * t -> t | |
18 | val bool: t | |
19 | val deConOpt: t -> (Tycon.t * t vector) option | |
20 | val deRecord: t -> (Record.Field.t * t) vector | |
21 | val isCharX: t -> bool | |
22 | val isInt: t -> bool | |
23 | val layout: t -> Layout.t | |
24 | val makeHom: {con: Tycon.t * 'a vector -> 'a, | |
25 | var: Tyvar.t -> 'a} -> {destroy: unit -> unit, | |
26 | hom: t -> 'a} | |
27 | val tuple: t vector -> t | |
28 | val unit: t | |
29 | end | |
30 | end | |
31 | ||
32 | signature CORE_ML = | |
33 | sig | |
34 | include CORE_ML_STRUCTS | |
35 | ||
36 | structure Pat: | |
37 | sig | |
38 | type t | |
39 | datatype node = | |
40 | Con of {arg: t option, | |
41 | con: Con.t, | |
42 | targs: Type.t vector} | |
43 | | Const of unit -> Const.t | |
44 | | Layered of Var.t * t | |
45 | | List of t vector | |
46 | | Or of t vector | |
47 | | Record of t Record.t | |
48 | | Var of Var.t | |
49 | | Vector of t vector | |
50 | | Wild | |
51 | ||
52 | val dest: t -> node * Type.t | |
53 | val falsee: t | |
54 | val foreachVar: t * (Var.t -> unit) -> unit | |
55 | (* true if pattern contains a constant, constructor or variable *) | |
56 | val isRefutable: t -> bool | |
57 | val isUnit: t -> bool | |
58 | val isWild: t -> bool | |
59 | val layout: t -> Layout.t | |
60 | val make: node * Type.t -> t | |
61 | val node: t -> node | |
62 | val var: Var.t * Type.t -> t | |
63 | val truee: t | |
64 | val tuple: t vector -> t | |
65 | val ty: t -> Type.t | |
66 | val wild: Type.t -> t | |
67 | end | |
68 | ||
69 | structure Exp: | |
70 | sig | |
71 | type dec | |
72 | type lambda | |
73 | type t | |
74 | datatype noMatch = Impossible | RaiseAgain | RaiseBind | RaiseMatch | |
75 | datatype node = | |
76 | App of t * t | |
77 | | Case of {ctxt: unit -> Layout.t, | |
78 | kind: string * string, | |
79 | nest: string list, | |
80 | matchDiags: {nonexhaustiveExn: Control.Elaborate.DiagDI.t, | |
81 | nonexhaustive: Control.Elaborate.DiagEIW.t, | |
82 | redundant: Control.Elaborate.DiagEIW.t}, | |
83 | noMatch: noMatch, | |
84 | region: Region.t, | |
85 | rules: {exp: t, | |
86 | layPat: (unit -> Layout.t) option, | |
87 | pat: Pat.t, | |
88 | regionPat: Region.t} vector, | |
89 | test: t} | |
90 | | Con of Con.t * Type.t vector | |
91 | | Const of unit -> Const.t | |
92 | | EnterLeave of t * SourceInfo.t | |
93 | | Handle of {catch: Var.t * Type.t, | |
94 | handler: t, | |
95 | try: t} | |
96 | | Lambda of lambda | |
97 | | Let of dec vector * t | |
98 | | List of t vector | |
99 | | PrimApp of {args: t vector, | |
100 | prim: Type.t Prim.t, | |
101 | targs: Type.t vector} | |
102 | | Raise of t | |
103 | | Record of t Record.t | |
104 | | Seq of t vector | |
105 | | Var of (unit -> Var.t) * (unit -> Type.t vector) | |
106 | | Vector of t vector | |
107 | ||
108 | val andAlso: t * t -> t | |
109 | val casee: {ctxt: unit -> Layout.t, | |
110 | kind: string * string, | |
111 | nest: string list, | |
112 | matchDiags: {nonexhaustiveExn: Control.Elaborate.DiagDI.t, | |
113 | nonexhaustive: Control.Elaborate.DiagEIW.t, | |
114 | redundant: Control.Elaborate.DiagEIW.t}, | |
115 | noMatch: noMatch, | |
116 | region: Region.t, | |
117 | rules: {exp: t, | |
118 | layPat: (unit -> Layout.t) option, | |
119 | pat: Pat.t, | |
120 | regionPat: Region.t} vector, | |
121 | test: t} -> t | |
122 | val dest: t -> node * Type.t | |
123 | val iff: t * t * t -> t | |
124 | val falsee: t | |
125 | val foreachVar: t * (Var.t -> unit) -> unit | |
126 | (* true if the expression may side-effect. See p 19 of Definition *) | |
127 | val isExpansive: t -> bool | |
128 | val lambda: lambda -> t | |
129 | val layout: t -> Layout.t | |
130 | val layoutWithType: t -> Layout.t | |
131 | val make: node * Type.t -> t | |
132 | val node: t -> node | |
133 | val orElse: t * t -> t | |
134 | val truee: t | |
135 | val tuple: t vector -> t | |
136 | val ty: t -> Type.t | |
137 | val unit: t | |
138 | val var: Var.t * Type.t -> t | |
139 | val whilee: {expr: t, test: t} -> t | |
140 | end | |
141 | ||
142 | structure Lambda: | |
143 | sig | |
144 | type t | |
145 | ||
146 | val bogus: t | |
147 | val dest: t -> {arg: Var.t, | |
148 | argType: Type.t, | |
149 | body: Exp.t, | |
150 | mayInline: bool} | |
151 | val make: {arg: Var.t, | |
152 | argType: Type.t, | |
153 | body: Exp.t, | |
154 | mayInline: bool} -> t | |
155 | end | |
156 | sharing type Exp.lambda = Lambda.t | |
157 | ||
158 | structure Dec: | |
159 | sig | |
160 | datatype t = | |
161 | Datatype of {cons: {arg: Type.t option, | |
162 | con: Con.t} vector, | |
163 | tycon: Tycon.t, | |
164 | tyvars: Tyvar.t vector} vector | |
165 | | Exception of {arg: Type.t option, | |
166 | con: Con.t} | |
167 | | Fun of {decs: {lambda: Lambda.t, | |
168 | var: Var.t} vector, | |
169 | tyvars: unit -> Tyvar.t vector} | |
170 | | Val of {matchDiags: {nonexhaustiveExn: Control.Elaborate.DiagDI.t, | |
171 | nonexhaustive: Control.Elaborate.DiagEIW.t, | |
172 | redundant: Control.Elaborate.DiagEIW.t}, | |
173 | rvbs: {lambda: Lambda.t, | |
174 | var: Var.t} vector, | |
175 | tyvars: unit -> Tyvar.t vector, | |
176 | vbs: {ctxt: unit -> Layout.t, | |
177 | exp: Exp.t, | |
178 | layPat: unit -> Layout.t, | |
179 | nest: string list, | |
180 | pat: Pat.t, | |
181 | regionPat: Region.t} vector} | |
182 | ||
183 | val layout: t -> Layout.t | |
184 | end | |
185 | sharing type Exp.dec = Dec.t | |
186 | ||
187 | structure Program: | |
188 | sig | |
189 | datatype t = T of {decs: Dec.t vector} | |
190 | ||
191 | val layouts: t * (Layout.t -> unit) -> unit | |
192 | end | |
193 | end |