[hcoop/debian/mlton.git] / mlton / elaborate / interface.sig

(* Copyright (C) 2017 Matthew Fluet.
 * Copyright (C) 1999-2007 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 INTERFACE_STRUCTS = 
   sig
      structure Ast: AST
      structure AdmitsEquality: ADMITS_EQUALITY
      structure Kind: TYCON_KIND
      structure EnvTycon:
         sig
            type t

            val admitsEquality: t -> AdmitsEquality.t
            val arrow: t
            val equals: t * t -> bool
            val exn: t
            val kind: t -> Kind.t
            val layout: t -> Layout.t
            val layoutAppPretty:
               t
               * LayoutPretty.t vector
               * {layoutPretty: t -> Layout.t}
               -> LayoutPretty.t
            val layoutAppPrettyNormal:
               Layout.t
               * LayoutPretty.t vector
               -> LayoutPretty.t
            val tuple: t
         end
      structure EnvTypeStr:
         sig
            type t
            val layout: t -> Layout.t
         end
      structure Tyvar:
         sig
            include ID
            val makeNoname: {equality: bool} -> t
            val makeLayoutPretty:
               unit
               -> {destroy: unit -> unit,
                   layoutPretty: t -> Layout.t,
                   localInit: t vector -> unit}
         end
   end

signature INTERFACE = 
   sig
      include INTERFACE_STRUCTS

      structure FlexibleTycon:
         sig
            type typeStr
            type t

            val admitsEquality: t -> AdmitsEquality.t
            val dest: t -> {admitsEquality: AdmitsEquality.t,
                            hasCons: bool,
                            kind: Kind.t,
                            prettyDefault: string}
            val layout: t -> Layout.t
            val layoutPrettyDefault: t -> Layout.t
            val plist: t -> PropertyList.t
            val new: {admitsEquality: AdmitsEquality.t,
                      hasCons: bool,
                      kind: Kind.t,
                      prettyDefault: string,
                      region: Region.t} -> t
            val realize: t * EnvTypeStr.t -> unit
            datatype realization =
               ETypeStr of EnvTypeStr.t
             | TypeStr of typeStr
            val realization: t -> realization option
            val setAdmitsEquality: t * AdmitsEquality.t -> unit
         end
      structure Tycon:
         sig
            datatype t =
               Flexible of FlexibleTycon.t
             | Rigid of EnvTycon.t
            val admitsEquality: t -> AdmitsEquality.t
         end
      structure Record: RECORD
      sharing Record = Ast.SortedRecord
      structure Type:
         sig
            type t

            val arrow: t * t -> t
            val con: Tycon.t * t vector -> t
            val deArrow: t -> t * t
            val deEta: t * Tyvar.t vector -> Tycon.t option
            val exn: t
            val hom: t * {con: Tycon.t * 'a vector -> 'a,
                          record: 'a Record.t -> 'a,
                          var: Tyvar.t -> 'a} -> 'a
            val layout: t -> Layout.t
            val layoutPretty:
               t * {expand: bool,
                    layoutPrettyEnvTycon: EnvTycon.t -> Layout.t,
                    layoutPrettyFlexTycon: FlexibleTycon.t -> Layout.t,
                    layoutPrettyTyvar: Tyvar.t -> Layout.t}
               -> LayoutPretty.t
            val record: t Record.t -> t
            val var: Tyvar.t -> t
         end
      structure Status:
         sig
            datatype t = Con | Exn | Var

            val layout: t -> Layout.t
            val toString: t -> string
         end
      structure Time:
         sig
            type t

            val tick: unit -> t
         end
      structure Scheme:
         sig
            datatype t = T of {ty: Type.t,
                               tyvars: Tyvar.t vector}

            val admitsEquality: t -> bool
            val fromTycon: Tycon.t -> t
            val make: Tyvar.t vector * Type.t -> t
            val ty: t -> Type.t
         end
      structure Cons:
         sig
            type t
            val dest: t -> {name: Ast.Con.t,
                            scheme: Scheme.t} vector
            val empty: t
            val fromSortedVector: {name: Ast.Con.t,
                                   scheme: Scheme.t} vector -> t
            val fromVector: {name: Ast.Con.t,
                             scheme: Scheme.t} vector -> t
            val layout: t -> Layout.t
            val map: t * ({name: Ast.Con.t,
                           scheme: Scheme.t}
                          -> {scheme: Scheme.t}) -> t
         end
      structure TypeStr:
         sig
            type t

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

            val abs: t -> t
            val admitsEquality: t -> AdmitsEquality.t
            val apply: t * Type.t vector -> Type.t
            val cons: t -> Cons.t
            val data: Tycon.t * Cons.t * bool -> t
            val def: Scheme.t -> t
            val kind: t -> Kind.t
            val layout: t -> Layout.t
            val node: t -> node
            val pushSpec: t * Region.t -> unit
            val repl: t -> t
            val toTyconOpt: t * {expand: bool} -> Tycon.t option (* NONE on Scheme *)
            val tycon: Tycon.t * bool -> t
            val specs: t * Region.t -> Region.t list

            val share:
               {layoutPrettyEnvTycon: EnvTycon.t -> Layout.t,
                layoutPrettyFlexTycon: FlexibleTycon.t -> Layout.t,
                region: Region.t,
                time: Time.t,
                ty1: {name: unit -> Layout.t,
                      region: Region.t,
                      spec: Region.t,
                      tyStr: t},
                ty2: {name: unit -> Layout.t,
                      region: Region.t,
                      spec: Region.t,
                      tyStr: t}}
               -> unit
            val wheree:
               {layoutPrettyEnvTycon: EnvTycon.t -> Layout.t,
                layoutPrettyFlexTycon: FlexibleTycon.t -> Layout.t,
                realization: t,
                region: Region.t,
                time: Time.t,
                ty: {name: unit -> Layout.t,
                     region: Region.t,
                     spec: Region.t,
                     tyStr: t}}
               -> unit
         end
      sharing type FlexibleTycon.typeStr = TypeStr.t
      structure TyconMap:
         sig
            datatype 'a t = T of {strs: (Ast.Strid.t * 'a t) array,
                                  types: (Ast.Tycon.t * 'a) array}

            val empty: unit -> 'a t
            val layout: ('a -> Layout.t) -> 'a t -> Layout.t
            val peekStrid: 'a t * Ast.Strid.t -> 'a t option
            val peekTycon: 'a t * Ast.Tycon.t ->'a option
         end

      type t

      val copy: t -> t (* copy renames all flexible tycons. *)
      val equals: t * t -> bool
      val dest: t -> {strs: (Ast.Strid.t * t) array,
                      types: (Ast.Tycon.t * TypeStr.t) array,
                      vals: (Ast.Vid.t * (Status.t * Scheme.t)) array}
      val empty: t
      val flexibleTycons: t -> FlexibleTycon.t TyconMap.t
      val layout: t -> Layout.t
      val lookupLongstrid:
         t * Ast.Longstrid.t * Region.t * {prefix: Ast.Strid.t list}
         -> t option
      val lookupLongtycon:
         t * Ast.Longtycon.t * Region.t * {prefix: Ast.Strid.t list}
         -> (Ast.Tycon.t * TypeStr.t) option
      val new: {isClosed: bool,
                original: t option,
                strs: (Ast.Strid.t * t) array,
                types: (Ast.Tycon.t * TypeStr.t) array,
                vals: (Ast.Vid.t * (Status.t * Scheme.t)) array} -> t
      val original: t -> t
      val peekStrid: t * Ast.Strid.t -> t option
      datatype 'a peekResult =
         Found of 'a
       | UndefinedStructure of Ast.Strid.t list
      val peekStrids: t * Ast.Strid.t list -> t peekResult
      val peekTycon: t * Ast.Tycon.t -> (Ast.Tycon.t * TypeStr.t) option
      val plist: t -> PropertyList.t
      val share:
         {layoutPrettyEnvTycon: EnvTycon.t -> Layout.t,
          layoutPrettyFlexTycon: FlexibleTycon.t -> Layout.t,
          I1: t, long1: Ast.Longstrid.t,
          I2: t, long2: Ast.Longstrid.t,
          time: Time.t,
          region: Region.t}
         -> unit
   end
Commit	Line	Data
7f918cf1 CE	1	(* Copyright (C) 2017 Matthew Fluet.
	2	* Copyright (C) 1999-2007 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 INTERFACE_STRUCTS =
	11	sig
	12	structure Ast: AST
	13	structure AdmitsEquality: ADMITS_EQUALITY
	14	structure Kind: TYCON_KIND
	15	structure EnvTycon:
	16	sig
	17	type t
	18
	19	val admitsEquality: t -> AdmitsEquality.t
	20	val arrow: t
	21	val equals: t * t -> bool
	22	val exn: t
	23	val kind: t -> Kind.t
	24	val layout: t -> Layout.t
	25	val layoutAppPretty:
	26	t
	27	* LayoutPretty.t vector
	28	* {layoutPretty: t -> Layout.t}
	29	-> LayoutPretty.t
	30	val layoutAppPrettyNormal:
	31	Layout.t
	32	* LayoutPretty.t vector
	33	-> LayoutPretty.t
	34	val tuple: t
	35	end
	36	structure EnvTypeStr:
	37	sig
	38	type t
	39	val layout: t -> Layout.t
	40	end
	41	structure Tyvar:
	42	sig
	43	include ID
	44	val makeNoname: {equality: bool} -> t
	45	val makeLayoutPretty:
	46	unit
	47	-> {destroy: unit -> unit,
	48	layoutPretty: t -> Layout.t,
	49	localInit: t vector -> unit}
	50	end
	51	end
	52
	53	signature INTERFACE =
	54	sig
	55	include INTERFACE_STRUCTS
	56
	57	structure FlexibleTycon:
	58	sig
	59	type typeStr
	60	type t
	61
	62	val admitsEquality: t -> AdmitsEquality.t
	63	val dest: t -> {admitsEquality: AdmitsEquality.t,
	64	hasCons: bool,
65	kind: Kind.t,
66	prettyDefault: string}
67	val layout: t -> Layout.t
68	val layoutPrettyDefault: t -> Layout.t
69	val plist: t -> PropertyList.t
70	val new: {admitsEquality: AdmitsEquality.t,
71	hasCons: bool,
72	kind: Kind.t,
73	prettyDefault: string,
74	region: Region.t} -> t
75	val realize: t * EnvTypeStr.t -> unit
76	datatype realization =
77	ETypeStr of EnvTypeStr.t
78	\| TypeStr of typeStr
79	val realization: t -> realization option
80	val setAdmitsEquality: t * AdmitsEquality.t -> unit
81	end
82	structure Tycon:
83	sig
84	datatype t =
85	Flexible of FlexibleTycon.t
86	\| Rigid of EnvTycon.t
87	val admitsEquality: t -> AdmitsEquality.t
88	end
89	structure Record: RECORD
90	sharing Record = Ast.SortedRecord
91	structure Type:
92	sig
93	type t
94
95	val arrow: t * t -> t
96	val con: Tycon.t * t vector -> t
97	val deArrow: t -> t * t
98	val deEta: t * Tyvar.t vector -> Tycon.t option
99	val exn: t
100	val hom: t * {con: Tycon.t * 'a vector -> 'a,
101	record: 'a Record.t -> 'a,
102	var: Tyvar.t -> 'a} -> 'a
103	val layout: t -> Layout.t
104	val layoutPretty:
105	t * {expand: bool,
106	layoutPrettyEnvTycon: EnvTycon.t -> Layout.t,
107	layoutPrettyFlexTycon: FlexibleTycon.t -> Layout.t,
108	layoutPrettyTyvar: Tyvar.t -> Layout.t}
109	-> LayoutPretty.t
110	val record: t Record.t -> t
111	val var: Tyvar.t -> t
112	end
113	structure Status:
114	sig
115	datatype t = Con \| Exn \| Var
116
117	val layout: t -> Layout.t
118	val toString: t -> string
119	end
120	structure Time:
121	sig
122	type t
123
124	val tick: unit -> t
125	end
126	structure Scheme:
127	sig
128	datatype t = T of {ty: Type.t,
129	tyvars: Tyvar.t vector}
130
131	val admitsEquality: t -> bool
132	val fromTycon: Tycon.t -> t
133	val make: Tyvar.t vector * Type.t -> t
134	val ty: t -> Type.t
135	end
136	structure Cons:
137	sig
138	type t
139	val dest: t -> {name: Ast.Con.t,
140	scheme: Scheme.t} vector
141	val empty: t
142	val fromSortedVector: {name: Ast.Con.t,
143	scheme: Scheme.t} vector -> t
144	val fromVector: {name: Ast.Con.t,
145	scheme: Scheme.t} vector -> t
146	val layout: t -> Layout.t
147	val map: t * ({name: Ast.Con.t,
148	scheme: Scheme.t}
149	-> {scheme: Scheme.t}) -> t
150	end
151	structure TypeStr:
152	sig
153	type t
154
155	datatype node =
156	Datatype of {tycon: Tycon.t,
157	cons: Cons.t,
158	repl: bool}
159	\| Scheme of Scheme.t
160	\| Tycon of {eq: bool,
161	tycon: Tycon.t}
162
163	val abs: t -> t
164	val admitsEquality: t -> AdmitsEquality.t
165	val apply: t * Type.t vector -> Type.t
166	val cons: t -> Cons.t
167	val data: Tycon.t * Cons.t * bool -> t
168	val def: Scheme.t -> t
169	val kind: t -> Kind.t
170	val layout: t -> Layout.t
171	val node: t -> node
172	val pushSpec: t * Region.t -> unit
173	val repl: t -> t
174	val toTyconOpt: t * {expand: bool} -> Tycon.t option (* NONE on Scheme *)
175	val tycon: Tycon.t * bool -> t
176	val specs: t * Region.t -> Region.t list
177
178	val share:
179	{layoutPrettyEnvTycon: EnvTycon.t -> Layout.t,
180	layoutPrettyFlexTycon: FlexibleTycon.t -> Layout.t,
181	region: Region.t,
182	time: Time.t,
183	ty1: {name: unit -> Layout.t,
184	region: Region.t,
185	spec: Region.t,
186	tyStr: t},
187	ty2: {name: unit -> Layout.t,
188	region: Region.t,
189	spec: Region.t,
190	tyStr: t}}
191	-> unit
192	val wheree:
193	{layoutPrettyEnvTycon: EnvTycon.t -> Layout.t,
194	layoutPrettyFlexTycon: FlexibleTycon.t -> Layout.t,
195	realization: t,
196	region: Region.t,
197	time: Time.t,
198	ty: {name: unit -> Layout.t,
199	region: Region.t,
200	spec: Region.t,
201	tyStr: t}}
202	-> unit
203	end
204	sharing type FlexibleTycon.typeStr = TypeStr.t
205	structure TyconMap:
206	sig
207	datatype 'a t = T of {strs: (Ast.Strid.t * 'a t) array,
208	types: (Ast.Tycon.t * 'a) array}
209
210	val empty: unit -> 'a t
211	val layout: ('a -> Layout.t) -> 'a t -> Layout.t
212	val peekStrid: 'a t * Ast.Strid.t -> 'a t option
213	val peekTycon: 'a t * Ast.Tycon.t ->'a option
214	end
215
216	type t
217
218	val copy: t -> t (* copy renames all flexible tycons. *)
219	val equals: t * t -> bool
220	val dest: t -> {strs: (Ast.Strid.t * t) array,
221	types: (Ast.Tycon.t * TypeStr.t) array,
222	vals: (Ast.Vid.t * (Status.t * Scheme.t)) array}
223	val empty: t
224	val flexibleTycons: t -> FlexibleTycon.t TyconMap.t
225	val layout: t -> Layout.t
226	val lookupLongstrid:
227	t * Ast.Longstrid.t * Region.t * {prefix: Ast.Strid.t list}
228	-> t option
229	val lookupLongtycon:
230	t * Ast.Longtycon.t * Region.t * {prefix: Ast.Strid.t list}
231	-> (Ast.Tycon.t * TypeStr.t) option
232	val new: {isClosed: bool,
233	original: t option,
234	strs: (Ast.Strid.t * t) array,
235	types: (Ast.Tycon.t * TypeStr.t) array,
236	vals: (Ast.Vid.t * (Status.t * Scheme.t)) array} -> t
237	val original: t -> t
238	val peekStrid: t * Ast.Strid.t -> t option
239	datatype 'a peekResult =
240	Found of 'a
241	\| UndefinedStructure of Ast.Strid.t list
242	val peekStrids: t * Ast.Strid.t list -> t peekResult
243	val peekTycon: t * Ast.Tycon.t -> (Ast.Tycon.t * TypeStr.t) option
244	val plist: t -> PropertyList.t
245	val share:
246	{layoutPrettyEnvTycon: EnvTycon.t -> Layout.t,
247	layoutPrettyFlexTycon: FlexibleTycon.t -> Layout.t,
248	I1: t, long1: Ast.Longstrid.t,
249	I2: t, long2: Ast.Longstrid.t,
250	time: Time.t,
251	region: Region.t}
252	-> unit
253	end