types.mli 10.3 KB
Newer Older
1 2
open Ident

3
module BoolAtoms : BoolVar.S with
4
  type s = Atoms.t and
5
  type elem = Atoms.t Var.pairvar
6
module BoolIntervals : BoolVar.S with
7
  type s = Intervals.t and
8
  type elem = Intervals.t Var.pairvar
9
module BoolChars : BoolVar.S with
10
  type s = Chars.t and
11
  type elem = Chars.t Var.pairvar
12

13
type const =
14
  | Integer of Intervals.V.t
15
  | Atom of Atoms.V.t
16 17 18 19 20 21
  | Char of Chars.V.t
  | Pair of const * const
  | Xml of const * const
  | Record of const label_map
  | String of U.uindex * U.uindex * U.t * const

Jérôme Maloberti's avatar
Jérôme Maloberti committed
22 23
type service_params =
  | TProd of service_params * service_params
24
  | TOption of service_params
Jérôme Maloberti's avatar
Jérôme Maloberti committed
25 26 27 28 29 30 31
  | TList of string * service_params
  | TSet of service_params
  | TSum of service_params * service_params
  | TString of string
  | TInt of string
  | TInt32 of string
  | TInt64 of string
32
  | TFloat of string
Jérôme Maloberti's avatar
Jérôme Maloberti committed
33 34 35
  | TBool of string
  | TFile of string
      (* | TUserType of string * (string -> 'a) * ('a -> string) *)
36
  | TCoord of string
Jérôme Maloberti's avatar
Jérôme Maloberti committed
37
  | TCoordv of service_params * string
38
  | TESuffix of string
Jérôme Maloberti's avatar
Jérôme Maloberti committed
39 40 41
  | TESuffixs of string
      (*  | TESuffixu of (string * (string -> 'a) * ('a -> string)) *)
  | TSuffix of (bool * service_params)
42
  | TUnit
Jérôme Maloberti's avatar
Jérôme Maloberti committed
43 44
  | TAny
  | TConst of string;;
45

46
module Const: Custom.T with type t = const
47

48
(*
49 50 51
module CompUnit : sig
  include Custom.T

52
  val get_current: unit -> t
53 54
  val mk: U.t -> t
  val value: t -> U.t
55
  val print_qual: Format.formatter -> t -> unit
56 57 58 59 60 61 62 63 64

  val enter: t -> unit
  val leave: unit -> unit
  val close_serialize: unit -> t list

  val pervasives: t

  module Tbl : Inttbl.S with type key = t
end
65
*)
66

67
module Abstract : sig
68 69
  module T : Custom.T with type t = string
  type abs = T.t
70 71 72
  type t
  val any: t
  val atom: abs -> t
73
  val compare: t -> t -> int
74 75 76 77 78 79 80 81

  module V : sig
    type t = abs * Obj.t
  end

  val contains: abs -> t -> bool
end

82 83
(** Algebra **)

84 85
include Custom.T
module Node : Custom.T
86

87
module Pair : Bool.S with type elem = (Node.t * Node.t)
88
module BoolPair : BoolVar.S with type s = Pair.t and type elem = Pair.t Var.pairvar
89 90

module Rec : Bool.S with type elem = bool * Node.t Ident.label_map
91
module BoolRec : BoolVar.S with type s = Rec.t and type elem = Rec.t Var.pairvar
92

93
type descr = t
94

95 96
val make: unit -> Node.t
val define: Node.t -> t -> unit
97

98 99
val cons: t -> Node.t
val internalize: Node.t -> Node.t
100

101 102
val id: Node.t -> int
val descr: Node.t -> t
103

104 105
(** Boolean connectives **)

106 107 108 109 110 111
val cup    : t -> t -> t
val cap    : t -> t -> t
val diff   : t -> t -> t
val neg    : t -> t
val empty  : t
val any    : t
112

Pietro Abate's avatar
Pietro Abate committed
113 114
val no_var  : t -> bool
val is_var  : t -> bool
115
val has_tlv : t -> bool
116

117
val any_node : Node.t
118
val empty_node : Node.t
119

120
val non_constructed : t
121
val non_constructed_or_absent : t
122

123 124
(** Constructors **)

125 126
type pair_kind = [ `Normal | `XML ]

127
val var      : Var.var -> t
128 129
val interval : Intervals.t -> t
val atom     : Atoms.t -> t
130 131 132 133
val times    : Node.t -> Node.t -> t
val xml      : Node.t -> Node.t -> t
val arrow    : Node.t -> Node.t -> t
val record   : label -> Node.t -> t
134
  (** bool = true -> open record; bool = false -> closed record *)
135
val record_fields : bool * Node.t label_map -> t
136
val char     : Chars.t -> t
137
val constant : const -> t
138
val abstract : Abstract.t -> t
139

140 141
(** Helpers *)

142
val all_vars : t -> Var.Set.t
143 144
val tuple : Node.t list -> t

145
val rec_of_list: bool -> (bool * Ns.Label.t * t) list -> t
146

147
val empty_closed_record: t
148
val empty_open_record: t
149

150 151 152 153 154 155 156
(** Positive systems and least solutions **)

module Positive :
sig
  type v
  val forward: unit -> v
  val define: v -> v -> unit
157
  val ty: t -> v
158 159
  val cup: v list -> v
  val times: v -> v -> v
160
  val xml: v -> v -> v
161

Pietro Abate's avatar
WIP  
Pietro Abate committed
162
  (* val decompose : t -> v *)
Pietro Abate's avatar
Pietro Abate committed
163 164
  val substitute : t -> (Var.var * t) -> t
  val substituterec : t -> Var.var -> t
165
  val solve: v -> Node.t
Pietro Abate's avatar
Pietro Abate committed
166
  val substitutefree : t -> t
167 168 169 170 171
end

(** Normalization **)

module Product : sig
172 173
  val any : t
  val any_xml : t
174
  val any_of: pair_kind -> t
175 176
  val other : ?kind:pair_kind -> t -> t
  val is_product : ?kind:pair_kind -> t -> bool
177 178 179

  (* List of non-empty rectangles *)
  type t = (descr * descr) list
180
  val is_empty: t -> bool
181
  val get: ?kind:pair_kind -> descr -> t
182 183
  val pi1: t -> descr
  val pi2: t -> descr
184
  val pi2_restricted: descr -> t -> descr
185

186 187 188 189 190 191
  (* Intersection with (pi1,Any) *)
  val restrict_1: t -> descr -> t

  (* List of non-empty rectangles whose first projection
     are pair-wise disjunct *)
  type normal = t
192
  val normal: ?kind:pair_kind -> descr -> normal
193

194 195 196 197
  val constraint_on_2: normal -> descr -> descr
    (* constraint_on_2 n t1:  maximal t2 such that (t1,t2) <= n *)
    (* Assumption: t1 <= pi1(n) *)

198 199
  val need_second: t -> bool
    (* Is there more than a single rectangle ? *)
200 201 202 203


  val clean_normal: t -> t
    (* Merge rectangles with same second component *)
204 205 206
end

module Record : sig
207
  val any : t
208 209
  val absent : t
  val absent_node : Node.t
210 211
  val or_absent: t -> t
  val any_or_absent: t
212
  val any_or_absent_node : Node.t
213

214 215
  val has_absent: t -> bool
  val has_record: t -> bool
216

217 218
  val split : t -> label -> Product.t
  val split_normal : t -> label -> Product.normal
219

220 221 222
  val pi : label -> t -> t
    (* May contain absent *)

223
  val project : t -> label -> t
224 225
    (* Raise Not_found if label is not necessarily present *)

226
  val condition : t -> label -> t -> t
227
    (* condition t1 l t2 : What must follow if field l hash type t2 *)
228 229
  val project_opt : t -> label -> t
  val has_empty_record: t -> bool
230 231


232
  val first_label: t -> label
233
  val all_labels: t -> LabelSet.t
234

235
  val empty_cases: t -> bool * bool
236

237 238
  val merge: t -> t -> t
  val remove_field: t -> label -> t
239

240
  val get: t -> ((bool * t) label_map * bool * bool) list
241 242 243 244 245 246 247


  type t
  val focus: descr -> label -> t
  val get_this: t -> descr
  val need_others: t -> bool
  val constraint_on_others: t -> descr -> descr
248 249
end

250
module Arrow : sig
251
  val any : t
252

253
  val sample: t -> t
254

255
  val check_strenghten: t -> t -> t
256 257 258 259 260 261 262
    (* [check_strenghten t s]
       Assume that [t] is an intersection of arrow types
       representing the interface of an abstraction;
       check that this abstraction has type [s] (otherwise raise Not_found)
       and returns a refined type for this abstraction.
    *)

263
  val check_iface: (t * t) list -> t -> bool
264

265
  type t = descr * (descr * descr) list list
266
  val is_empty: t -> bool
267 268
  val get: descr -> t
    (* Always succeed; no check <= Arrow.any *)
269

270 271 272
  val domain: t -> descr
  val apply: t -> descr -> descr
    (* Always succeed; no check on the domain *)
273 274 275 276 277 278

  val need_arg : t -> bool
    (* True if the type of the argument is needed to obtain
       the type of the result (must use [apply]; otherwise,
       [apply_noarg] is enough *)
  val apply_noarg : t -> descr
279 280 281
end


282
module Int : sig
283
  val has_int : t -> Intervals.V.t -> bool
284
  val get: t -> BoolIntervals.t
285
  val any : t
286 287
end

288
module Atom : sig
289
  val has_atom : t -> Atoms.V.t -> bool
290
  val get: t -> BoolAtoms.t
291
  val any : t
292 293
end

294
module Char : sig
295
  val has_char : t -> Chars.V.t -> bool
296
  val is_empty : t -> bool
297
  val get: t -> BoolChars.t
298
  val any : t
299 300
end

301 302
val get_abstract: t -> Abstract.t

303
val normalize : t -> t
304

305
(** Subtyping  **)
306

307 308 309
val is_empty : t -> bool
val non_empty: t -> bool
val subtype  : t -> t -> bool
310
val disjoint : t -> t -> bool
311
val equiv : t -> t -> bool
312

313 314 315 316 317 318 319 320 321
(** Tools for compilation of PM **)

val cond_partition: t -> (t * t) list -> t list
  (* The second argument is a list of pair of types (ti,si)
     interpreted as the question "member of ti under the assumption si".
     The result is a partition of the first argument which is precise enough
     to answer all the questions. *)


322 323
module Print :
sig
324
  val register_global : string -> Ns.QName.t -> t -> unit
325
  val print_const : Format.formatter -> const -> unit
326
  val print: Format.formatter -> t -> unit
327
  val print_node: Format.formatter -> Node.t -> unit
328 329 330

  (* Don't try to find a global name at toplevel *)
  val print_noname: Format.formatter -> t -> unit
331 332

  val to_string: t -> string
333
end
334

Jérôme Maloberti's avatar
Jérôme Maloberti committed
335 336 337 338 339 340
module Service :
sig
  val to_service_params: t -> service_params
  val to_string: service_params -> string
end

341
module Witness : sig
342 343 344 345
  type witness
  val print_witness: Format.formatter -> witness -> unit
end
val witness: t -> Witness.witness
346

347

348
module Cache : sig
349 350 351 352 353 354
  type 'a cache
  val emp: 'a cache
  val find: (t -> 'a) -> t -> 'a cache -> 'a cache * 'a

  val memo: (t -> 'a) -> (t -> 'a)
end
355 356

module Tallying : sig
357 358 359 360

  type constr =
  |Pos of (Var.var * t) (** alpha <= t | alpha \in P *)
  |Neg of (t * Var.var) (** t <= alpha | alpha \in N *)
361

362
  exception UnSatConstr of string
363 364
  exception Step1Fail
  exception Step2Fail
365

366
  module CS : sig
367
    module M : sig
368 369 370 371 372 373 374 375 376 377
      type key = Var.var
      type t
(*      include Map.S with type key = (bool * Var.var)*)
      val compare  : t -> t -> int
      val empty : t
      val add : key -> descr*descr -> t -> t
      val singleton : key -> descr*descr -> t
      val print : Format.formatter -> t -> unit
      val merge : t -> t -> t

378 379 380 381 382
    end
    module E : sig
      include Map.S with type key = Var.var
      val print : Format.formatter -> descr t -> unit
    end
383 384 385 386
    module ES : sig
      include Set.S with type elt = descr E.t
      val print : Format.formatter -> t -> unit
    end
387
    module S : sig
388 389 390 391 392 393 394 395
      type t = M.t list
      val empty : t
      val add : M.t -> t -> t
      val singleton : M.t -> t
      val union : t -> t -> t
      val elements : t -> M.t list
      val fold : (M.t -> 'b -> 'b) -> M.t list -> 'b -> 'b
      (*include Set.S with type elt = descr M.t*)
396 397 398 399
      val print : Format.formatter -> t -> unit
    end

    type s = S.t
400
    type m =  M.t
401
    type es = ES.t
402
    type sigma = t E.t
Pietro Abate's avatar
Pietro Abate committed
403
    type sl = sigma list
404

405 406
    val pp_s  : Format.formatter -> s -> unit
    val pp_m  : Format.formatter -> m -> unit
407
    val pp_e  : Format.formatter -> sigma -> unit
408
    val pp_sl : Format.formatter -> sl -> unit
409 410 411 412 413

    val merge : m -> m -> m
    val singleton : constr -> s
    val sat : s
    val unsat : s
Pietro Abate's avatar
Pietro Abate committed
414 415
    val union : s -> s -> s
    val prod : s -> s -> s
416 417
  end

418
  val norm : t -> CS.s
419
  val merge : CS.m -> CS.s
420
  val solve : CS.s -> CS.es
421
  val unify : CS.sigma -> CS.sigma
Pietro Abate's avatar
Pietro Abate committed
422
  val tallying : (t * t) list -> CS.sl
Pietro Abate's avatar
Pietro Abate committed
423
  val apply_subst : t -> CS.sigma -> t
424
  val domain : CS.sl -> Var.Set.t
425

426 427
end

Pietro Abate's avatar
Pietro Abate committed
428
val apply : t -> t -> Tallying.CS.sl
Kim Nguyễn's avatar
Kim Nguyễn committed
429
val apply_full : t -> t -> t
430
(** apply_raw s t returns the 4-tuple (subst,ss, tt, res) where
431 432 433 434
   subst is the set of substitution that make the application succeed,
   ss and tt are the expansions of s and t corresponding to that substitution
   and res is the type of the result of the application
*)
435 436 437
val apply_raw : t -> t -> Tallying.CS.sl * t * t * t
(** tallying sigma s < t *)
val abstr : t -> t -> Tallying.CS.sl