[hcoop/debian/mlton.git] / mlton / elaborate / elaborate-env.sig

(* Copyright (C) 2017 Matthew Fluet.
 * Copyright (C) 1999-2008 Henry Cejtin, Matthew Fluet, Suresh
 *    Jagannathan, and Stephen Weeks.
 * Copyright (C) 1997-2000 NEC Research Institute.
 *
 * MLton is released under a BSD-style license.
 * See the file MLton-LICENSE for details.
 *)

signature ELABORATE_ENV_STRUCTS =
   sig
      structure Ast: AST
      structure CoreML: CORE_ML
      structure TypeEnv: TYPE_ENV
      sharing Ast.Record = CoreML.Record
      sharing Ast.SortedRecord = CoreML.SortedRecord
      sharing CoreML.Atoms = TypeEnv.Atoms
      sharing CoreML.Type = TypeEnv.Type
   end

signature ELABORATE_ENV =
   sig
      include ELABORATE_ENV_STRUCTS

      structure Decs: DECS
      sharing CoreML = Decs.CoreML

      structure Tyvar: TYVAR
      sharing Tyvar = TypeEnv.Tyvar
      structure TyvarEnv:
         sig
            val lookupTyvar: Ast.Tyvar.t -> Tyvar.t option
            val scope: Ast.Tyvar.t vector * (Tyvar.t vector -> 'a) -> 'a
            val makeLayoutPretty: unit -> {destroy: unit -> unit, layoutPretty: Tyvar.t -> Layout.t}
         end

      structure AdmitsEquality: ADMITS_EQUALITY
      sharing AdmitsEquality = TypeEnv.Tycon.AdmitsEquality
      structure Kind: TYCON_KIND
      sharing Kind = TypeEnv.Tycon.Kind
      structure Tycon: TYCON
      sharing Tycon = TypeEnv.Tycon

      structure Type:
         sig
            type t
         end
      sharing Type = TypeEnv.Type
      structure Scheme:
         sig
            type t
         end
      sharing Scheme = TypeEnv.Scheme

      (* The value of a vid.  This is used to distinguish between vids whose
       * status cannot be determined at parse time.
       *)
      structure Vid:
         sig
            datatype t =
               Con of CoreML.Con.t
             | Exn of CoreML.Con.t
             | Overload of Ast.Priority.t * (CoreML.Var.t * Scheme.t) vector
             | Var of CoreML.Var.t

            val layout: t -> Layout.t
         end

      structure TypeStr:
         sig
            structure Cons:
               sig
                  type t

                  val layout: t -> Layout.t
               end

            type t

            datatype node =
               Datatype of {cons: Cons.t,
                            tycon: Tycon.t}
             | Scheme of Scheme.t
             | Tycon of Tycon.t

            val abs: t -> t
            val admitsEquality: t -> AdmitsEquality.t
            val apply: t * Type.t vector -> Type.t
            val data: Tycon.t * Cons.t -> t
            val def: Scheme.t -> t
            val kind: t -> Kind.t
            val layout: t -> Layout.t
            val node: t -> node
            val toTyconOpt: t -> Tycon.t option (* NONE on Scheme *)
            val tycon: Tycon.t -> t
         end

      structure Interface: INTERFACE
      sharing Interface.Ast = Ast
      sharing Interface.AdmitsEquality = AdmitsEquality
      sharing Interface.Kind = Kind
      sharing Interface.EnvTycon = Tycon
      sharing Interface.EnvTypeStr = TypeStr
      sharing Interface.Tyvar = Tyvar

      structure Structure:
         sig
            type t

            (* ffi represents MLtonFFI, which is built by the basis library and
             * set via the special ffiStr MLB annotation.
             *)
            val ffi: t option ref
            val forceUsed: t -> unit
            val layout: t -> Layout.t
         end
      structure FunctorClosure:
         sig
            type t

            val apply: (t * Structure.t * string list
                        -> Decs.t * Structure.t option)
            val argInterface: t -> Interface.t
         end

      structure InterfaceEnv:
         sig
            structure FlexibleTycon:
               sig
                  type t
               end
            structure Scheme:
               sig
                  type t
               end
            structure Status:
               sig
                  type t
               end
            structure TypeStr:
               sig
                  type t
               end

            type t

            val extendCon: t * Ast.Con.t * Scheme.t -> unit
            val extendExn: t * Ast.Con.t * Scheme.t -> unit
            val extendStrid: t * Ast.Strid.t * Interface.t -> unit
            val extendTycon: t * Ast.Tycon.t * TypeStr.t -> unit
            val extendVid: t * Ast.Vid.t * Status.t * Scheme.t -> unit
            val lookupLongtycon: t * Ast.Longtycon.t -> TypeStr.t option
            val lookupSigid: t * Ast.Sigid.t -> Interface.t option
            val makeInterface:
               t * {isTop: bool} * (unit -> 'a) -> Interface.t * 'a
            val openInterface: t * Interface.t * Region.t -> unit
            val rebindTycon: t * Ast.Tycon.t * TypeStr.t -> unit
         end
      sharing Interface.FlexibleTycon = InterfaceEnv.FlexibleTycon
      sharing Interface.Scheme = InterfaceEnv.Scheme
      sharing Interface.Status = InterfaceEnv.Status
      sharing Interface.TypeStr = InterfaceEnv.TypeStr

      structure Basis:
         sig
            type t
            val layout: t -> Layout.t
         end

      type t

      val amInsideFunctor: unit -> bool
      (* cut keeps only those bindings in the structure that also appear
       * in the interface.  It proceeds recursively on substructures.
       *)
      val cut:
         t * Structure.t * Interface.t
         * {isFunctor: bool, opaque: bool, prefix: string} * Region.t
         -> Structure.t * Decs.t
      val empty: unit -> t
      val extendBasid: t * Ast.Basid.t * Basis.t -> unit
      val extendExn: t * Ast.Con.t * CoreML.Con.t * Scheme.t -> unit
      val extendFctid: t * Ast.Fctid.t * FunctorClosure.t -> unit
      val extendFix: t * Ast.Vid.t * Ast.Fixity.t -> unit
      val extendSigid: t * Ast.Sigid.t * Interface.t -> unit
      val extendStrid: t * Ast.Strid.t * Structure.t -> unit
      val extendTycon:
         t * Ast.Tycon.t * TypeStr.t * {forceUsed: bool, isRebind: bool} -> unit
      val extendVar:
         t * Ast.Var.t * CoreML.Var.t * Scheme.t * {isRebind: bool} -> unit
      val extendOverload:
         t * Ast.Priority.t * Ast.Var.t * (CoreML.Var.t * Scheme.t) vector
         * Scheme.t
         -> unit
      val forceUsed: t -> unit
      val forceUsedLocal: t * (unit -> 'a) -> 'a
      val functorClosure:
         t * Ast.Fctid.t * Interface.t
         * (Structure.t * string list -> Decs.t * Structure.t option)
         -> FunctorClosure.t
      val localAll: t * (unit -> 'a) * ('a -> 'b) -> 'b
      val localCore: t * (unit -> 'a) * ('a -> 'b) -> 'b
      val localModule: t * (unit -> 'a) * ('a -> 'b) -> 'b
      val lookupBasid: t * Ast.Basid.t -> Basis.t option
      val lookupFctid: t * Ast.Fctid.t -> FunctorClosure.t option
      val lookupLongcon: t * Ast.Longcon.t -> (CoreML.Con.t * Scheme.t) option
      val lookupLongexn: t * Ast.Longcon.t -> (CoreML.Con.t * Scheme.t) option
      val lookupLongstrid: t * Ast.Longstrid.t -> Structure.t option
      val lookupLongtycon: t * Ast.Longtycon.t -> TypeStr.t option
      val lookupLongvar: t * Ast.Longvar.t -> (CoreML.Var.t * Scheme.t) option
      val lookupLongvid: t * Ast.Longvid.t -> (Vid.t * Scheme.t) option
      val lookupSigid: t * Ast.Sigid.t -> Interface.t option
      val lookupStrid: t * Ast.Strid.t -> Structure.t option
      val makeBasis: t * (unit -> 'a) -> 'a * Basis.t
      val makeInterfaceEnv: t -> InterfaceEnv.t
      val makeStructure: t * (unit -> 'a) -> 'a * Structure.t
      val newCons:
         t * {con: CoreML.Con.t,
              name: Ast.Con.t,
              scheme: Scheme.t} vector
         -> TypeStr.Cons.t
      (* openStructure (E, S) opens S in the environment E. *) 
      val openStructure: t * Structure.t -> unit
      (* openBasis (E, B) opens B in the environment E. *) 
      val openBasis: t * Basis.t -> unit
      val output: t * Out.t * {compact: bool, def: bool, flat: bool, onlyCurrent: bool, prefixUnset: bool} -> unit
      val peekFix: t * Ast.Vid.t -> Ast.Fixity.t option
      val peekLongcon: t * Ast.Longcon.t -> (CoreML.Con.t * Scheme.t) option
      val processDefUse: t -> unit
      (* scope f evaluates f () in a new scope so that extensions that occur
       * during f () are forgotten afterwards.
       * scope works for infixes, types, values, and structures
       *)
      val scope: t * (unit -> 'a) -> 'a
      (* like scope, but works for bases, signatures and functors as well *)
      val scopeAll: t * (unit -> 'a) -> 'a
      val makeLayoutPrettyTycon:
         t * {prefixUnset: bool}
         -> {destroy: unit -> unit,
             layoutPrettyTycon: Tycon.t -> Layout.t,
             setLayoutPrettyTycon: Tycon.t * Layout.t -> unit,
             loopStr: Structure.t * int * Ast.Strid.t list -> unit}
      val makeLayoutPrettyTyconAndFlexTycon:
         t * InterfaceEnv.t * Interface.t option * {prefixUnset: bool}
         -> {destroy: unit -> unit,
             layoutPrettyTycon: Tycon.t -> Layout.t,
             layoutPrettyFlexTycon: Interface.FlexibleTycon.t -> Layout.t,
             setLayoutPrettyTycon: Tycon.t * Layout.t -> unit}
      val sizeMessage: t -> Layout.t
      val snapshot: t -> (unit -> 'a) -> 'a
   end
Commit	Line	Data
7f918cf1 CE	1	(* Copyright (C) 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 ELABORATE_ENV_STRUCTS =
	11	sig
	12	structure Ast: AST
	13	structure CoreML: CORE_ML
	14	structure TypeEnv: TYPE_ENV
	15	sharing Ast.Record = CoreML.Record
	16	sharing Ast.SortedRecord = CoreML.SortedRecord
	17	sharing CoreML.Atoms = TypeEnv.Atoms
	18	sharing CoreML.Type = TypeEnv.Type
	19	end
	20
	21	signature ELABORATE_ENV =
	22	sig
	23	include ELABORATE_ENV_STRUCTS
	24
	25	structure Decs: DECS
	26	sharing CoreML = Decs.CoreML
	27
	28	structure Tyvar: TYVAR
	29	sharing Tyvar = TypeEnv.Tyvar
	30	structure TyvarEnv:
	31	sig
	32	val lookupTyvar: Ast.Tyvar.t -> Tyvar.t option
	33	val scope: Ast.Tyvar.t vector * (Tyvar.t vector -> 'a) -> 'a
	34	val makeLayoutPretty: unit -> {destroy: unit -> unit, layoutPretty: Tyvar.t -> Layout.t}
	35	end
	36
	37	structure AdmitsEquality: ADMITS_EQUALITY
	38	sharing AdmitsEquality = TypeEnv.Tycon.AdmitsEquality
	39	structure Kind: TYCON_KIND
	40	sharing Kind = TypeEnv.Tycon.Kind
	41	structure Tycon: TYCON
	42	sharing Tycon = TypeEnv.Tycon
	43
	44	structure Type:
	45	sig
	46	type t
	47	end
	48	sharing Type = TypeEnv.Type
	49	structure Scheme:
	50	sig
	51	type t
	52	end
	53	sharing Scheme = TypeEnv.Scheme
	54
	55	(* The value of a vid. This is used to distinguish between vids whose
	56	* status cannot be determined at parse time.
	57	*)
	58	structure Vid:
	59	sig
	60	datatype t =
	61	Con of CoreML.Con.t
	62	\| Exn of CoreML.Con.t
	63	\| Overload of Ast.Priority.t * (CoreML.Var.t * Scheme.t) vector
	64	\| Var of CoreML.Var.t
65
66	val layout: t -> Layout.t
67	end
68
69	structure TypeStr:
70	sig
71	structure Cons:
72	sig
73	type t
74
75	val layout: t -> Layout.t
76	end
77
78	type t
79
80	datatype node =
81	Datatype of {cons: Cons.t,
82	tycon: Tycon.t}
83	\| Scheme of Scheme.t
84	\| Tycon of Tycon.t
85
86	val abs: t -> t
87	val admitsEquality: t -> AdmitsEquality.t
88	val apply: t * Type.t vector -> Type.t
89	val data: Tycon.t * Cons.t -> t
90	val def: Scheme.t -> t
91	val kind: t -> Kind.t
92	val layout: t -> Layout.t
93	val node: t -> node
94	val toTyconOpt: t -> Tycon.t option (* NONE on Scheme *)
95	val tycon: Tycon.t -> t
96	end
97
98	structure Interface: INTERFACE
99	sharing Interface.Ast = Ast
100	sharing Interface.AdmitsEquality = AdmitsEquality
101	sharing Interface.Kind = Kind
102	sharing Interface.EnvTycon = Tycon
103	sharing Interface.EnvTypeStr = TypeStr
104	sharing Interface.Tyvar = Tyvar
105
106	structure Structure:
107	sig
108	type t
109
110	(* ffi represents MLtonFFI, which is built by the basis library and
111	* set via the special ffiStr MLB annotation.
112	*)
113	val ffi: t option ref
114	val forceUsed: t -> unit
115	val layout: t -> Layout.t
116	end
117	structure FunctorClosure:
118	sig
119	type t
120
121	val apply: (t * Structure.t * string list
122	-> Decs.t * Structure.t option)
123	val argInterface: t -> Interface.t
124	end
125
126	structure InterfaceEnv:
127	sig
128	structure FlexibleTycon:
129	sig
130	type t
131	end
132	structure Scheme:
133	sig
134	type t
135	end
136	structure Status:
137	sig
138	type t
139	end
140	structure TypeStr:
141	sig
142	type t
143	end
144
145	type t
146
147	val extendCon: t * Ast.Con.t * Scheme.t -> unit
148	val extendExn: t * Ast.Con.t * Scheme.t -> unit
149	val extendStrid: t * Ast.Strid.t * Interface.t -> unit
150	val extendTycon: t * Ast.Tycon.t * TypeStr.t -> unit
151	val extendVid: t * Ast.Vid.t * Status.t * Scheme.t -> unit
152	val lookupLongtycon: t * Ast.Longtycon.t -> TypeStr.t option
153	val lookupSigid: t * Ast.Sigid.t -> Interface.t option
154	val makeInterface:
155	t * {isTop: bool} * (unit -> 'a) -> Interface.t * 'a
156	val openInterface: t * Interface.t * Region.t -> unit
157	val rebindTycon: t * Ast.Tycon.t * TypeStr.t -> unit
158	end
159	sharing Interface.FlexibleTycon = InterfaceEnv.FlexibleTycon
160	sharing Interface.Scheme = InterfaceEnv.Scheme
161	sharing Interface.Status = InterfaceEnv.Status
162	sharing Interface.TypeStr = InterfaceEnv.TypeStr
163
164	structure Basis:
165	sig
166	type t
167	val layout: t -> Layout.t
168	end
169
170	type t
171
172	val amInsideFunctor: unit -> bool
173	(* cut keeps only those bindings in the structure that also appear
174	* in the interface. It proceeds recursively on substructures.
175	*)
176	val cut:
177	t * Structure.t * Interface.t
178	* {isFunctor: bool, opaque: bool, prefix: string} * Region.t
179	-> Structure.t * Decs.t
180	val empty: unit -> t
181	val extendBasid: t * Ast.Basid.t * Basis.t -> unit
182	val extendExn: t * Ast.Con.t * CoreML.Con.t * Scheme.t -> unit
183	val extendFctid: t * Ast.Fctid.t * FunctorClosure.t -> unit
184	val extendFix: t * Ast.Vid.t * Ast.Fixity.t -> unit
185	val extendSigid: t * Ast.Sigid.t * Interface.t -> unit
186	val extendStrid: t * Ast.Strid.t * Structure.t -> unit
187	val extendTycon:
188	t * Ast.Tycon.t * TypeStr.t * {forceUsed: bool, isRebind: bool} -> unit
189	val extendVar:
190	t * Ast.Var.t * CoreML.Var.t * Scheme.t * {isRebind: bool} -> unit
191	val extendOverload:
192	t * Ast.Priority.t * Ast.Var.t * (CoreML.Var.t * Scheme.t) vector
193	* Scheme.t
194	-> unit
195	val forceUsed: t -> unit
196	val forceUsedLocal: t * (unit -> 'a) -> 'a
197	val functorClosure:
198	t * Ast.Fctid.t * Interface.t
199	* (Structure.t * string list -> Decs.t * Structure.t option)
200	-> FunctorClosure.t
201	val localAll: t * (unit -> 'a) * ('a -> 'b) -> 'b
202	val localCore: t * (unit -> 'a) * ('a -> 'b) -> 'b
203	val localModule: t * (unit -> 'a) * ('a -> 'b) -> 'b
204	val lookupBasid: t * Ast.Basid.t -> Basis.t option
205	val lookupFctid: t * Ast.Fctid.t -> FunctorClosure.t option
206	val lookupLongcon: t * Ast.Longcon.t -> (CoreML.Con.t * Scheme.t) option
207	val lookupLongexn: t * Ast.Longcon.t -> (CoreML.Con.t * Scheme.t) option
208	val lookupLongstrid: t * Ast.Longstrid.t -> Structure.t option
209	val lookupLongtycon: t * Ast.Longtycon.t -> TypeStr.t option
210	val lookupLongvar: t * Ast.Longvar.t -> (CoreML.Var.t * Scheme.t) option
211	val lookupLongvid: t * Ast.Longvid.t -> (Vid.t * Scheme.t) option
212	val lookupSigid: t * Ast.Sigid.t -> Interface.t option
213	val lookupStrid: t * Ast.Strid.t -> Structure.t option
214	val makeBasis: t * (unit -> 'a) -> 'a * Basis.t
215	val makeInterfaceEnv: t -> InterfaceEnv.t
216	val makeStructure: t * (unit -> 'a) -> 'a * Structure.t
217	val newCons:
218	t * {con: CoreML.Con.t,
219	name: Ast.Con.t,
220	scheme: Scheme.t} vector
221	-> TypeStr.Cons.t
222	(* openStructure (E, S) opens S in the environment E. *)
223	val openStructure: t * Structure.t -> unit
224	(* openBasis (E, B) opens B in the environment E. *)
225	val openBasis: t * Basis.t -> unit
226	val output: t * Out.t * {compact: bool, def: bool, flat: bool, onlyCurrent: bool, prefixUnset: bool} -> unit
227	val peekFix: t * Ast.Vid.t -> Ast.Fixity.t option
228	val peekLongcon: t * Ast.Longcon.t -> (CoreML.Con.t * Scheme.t) option
229	val processDefUse: t -> unit
230	(* scope f evaluates f () in a new scope so that extensions that occur
231	* during f () are forgotten afterwards.
232	* scope works for infixes, types, values, and structures
233	*)
234	val scope: t * (unit -> 'a) -> 'a
235	(* like scope, but works for bases, signatures and functors as well *)
236	val scopeAll: t * (unit -> 'a) -> 'a
237	val makeLayoutPrettyTycon:
238	t * {prefixUnset: bool}
239	-> {destroy: unit -> unit,
240	layoutPrettyTycon: Tycon.t -> Layout.t,
241	setLayoutPrettyTycon: Tycon.t * Layout.t -> unit,
242	loopStr: Structure.t * int * Ast.Strid.t list -> unit}
243	val makeLayoutPrettyTyconAndFlexTycon:
244	t * InterfaceEnv.t * Interface.t option * {prefixUnset: bool}
245	-> {destroy: unit -> unit,
246	layoutPrettyTycon: Tycon.t -> Layout.t,
247	layoutPrettyFlexTycon: Interface.FlexibleTycon.t -> Layout.t,
248	setLayoutPrettyTycon: Tycon.t * Layout.t -> unit}
249	val sizeMessage: t -> Layout.t
250	val snapshot: t -> (unit -> 'a) -> 'a
251	end