sig
type tvsymbol = private { tv_name : Ident.ident; }
module Mtv :
sig
type key = tvsymbol
type +'a t
val empty : 'a t
val is_empty : 'a t -> bool
val mem : key -> 'a t -> bool
val add : key -> 'a -> 'a t -> 'a t
val singleton : key -> 'a -> 'a t
val remove : key -> 'a t -> 'a t
val merge :
(key -> 'a option -> 'b option -> 'c option) -> 'a t -> 'b t -> 'c t
val union : (key -> 'a -> 'a -> 'a option) -> 'a t -> 'a t -> 'a t
val compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int
val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool
val iter : (key -> 'a -> unit) -> 'a t -> unit
val fold : (key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b
val for_all : (key -> 'a -> bool) -> 'a t -> bool
val exists : (key -> 'a -> bool) -> 'a t -> bool
val filter : (key -> 'a -> bool) -> 'a t -> 'a t
val partition : (key -> 'a -> bool) -> 'a t -> 'a t * 'a t
val cardinal : 'a t -> int
val bindings : 'a t -> (key * 'a) list
val min_binding : 'a t -> key * 'a
val max_binding : 'a t -> key * 'a
val choose : 'a t -> key * 'a
val split : key -> 'a t -> 'a t * 'a option * 'a t
val find : key -> 'a t -> 'a
val map : ('a -> 'b) -> 'a t -> 'b t
val mapi : (key -> 'a -> 'b) -> 'a t -> 'b t
val change : ('a option -> 'a option) -> key -> 'a t -> 'a t
val inter : (key -> 'a -> 'b -> 'c option) -> 'a t -> 'b t -> 'c t
val diff : (key -> 'a -> 'b -> 'a option) -> 'a t -> 'b t -> 'a t
val submap : (key -> 'a -> 'b -> bool) -> 'a t -> 'b t -> bool
val disjoint : (key -> 'a -> 'b -> bool) -> 'a t -> 'b t -> bool
val set_union : 'a t -> 'a t -> 'a t
val set_inter : 'a t -> 'b t -> 'a t
val set_diff : 'a t -> 'b t -> 'a t
val set_submap : 'a t -> 'b t -> bool
val set_disjoint : 'a t -> 'b t -> bool
val set_compare : 'a t -> 'b t -> int
val set_equal : 'a t -> 'b t -> bool
val find_def : 'a -> key -> 'a t -> 'a
val find_opt : key -> 'a t -> 'a option
val find_exn : exn -> key -> 'a t -> 'a
val map_filter : ('a -> 'b option) -> 'a t -> 'b t
val mapi_filter : (key -> 'a -> 'b option) -> 'a t -> 'b t
val mapi_fold :
(key -> 'a -> 'acc -> 'acc * 'b) -> 'a t -> 'acc -> 'acc * 'b t
val mapi_filter_fold :
(key -> 'a -> 'acc -> 'acc * 'b option) ->
'a t -> 'acc -> 'acc * 'b t
val fold_left : ('b -> key -> 'a -> 'b) -> 'b -> 'a t -> 'b
val fold_right : (key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b
val fold2_inter :
(key -> 'a -> 'b -> 'c -> 'c) -> 'a t -> 'b t -> 'c -> 'c
val fold2_union :
(key -> 'a option -> 'b option -> 'c -> 'c) ->
'a t -> 'b t -> 'c -> 'c
val translate : (key -> key) -> 'a t -> 'a t
val add_new : exn -> key -> 'a -> 'a t -> 'a t
val replace : exn -> key -> 'a -> 'a t -> 'a t
val keys : 'a t -> key list
val values : 'a t -> 'a list
val of_list : (key * 'a) list -> 'a t
val contains : 'a t -> key -> bool
val domain : 'a t -> unit t
val subdomain : (key -> 'a -> bool) -> 'a t -> unit t
val is_num_elt : int -> 'a t -> bool
type 'a enumeration
val val_enum : 'a enumeration -> (key * 'a) option
val start_enum : 'a t -> 'a enumeration
val next_enum : 'a enumeration -> 'a enumeration
val start_ge_enum : key -> 'a t -> 'a enumeration
val next_ge_enum : key -> 'a enumeration -> 'a enumeration
end
module Stv :
sig
module M :
sig
type key = tvsymbol
type 'a t = 'a Mtv.t
val empty : 'a t
val is_empty : 'a t -> bool
val mem : key -> 'a t -> bool
val add : key -> 'a -> 'a t -> 'a t
val singleton : key -> 'a -> 'a t
val remove : key -> 'a t -> 'a t
val merge :
(key -> 'a option -> 'b option -> 'c option) ->
'a t -> 'b t -> 'c t
val union : (key -> 'a -> 'a -> 'a option) -> 'a t -> 'a t -> 'a t
val compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int
val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool
val iter : (key -> 'a -> unit) -> 'a t -> unit
val fold : (key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b
val for_all : (key -> 'a -> bool) -> 'a t -> bool
val exists : (key -> 'a -> bool) -> 'a t -> bool
val filter : (key -> 'a -> bool) -> 'a t -> 'a t
val partition : (key -> 'a -> bool) -> 'a t -> 'a t * 'a t
val cardinal : 'a t -> int
val bindings : 'a t -> (key * 'a) list
val min_binding : 'a t -> key * 'a
val max_binding : 'a t -> key * 'a
val choose : 'a t -> key * 'a
val split : key -> 'a t -> 'a t * 'a option * 'a t
val find : key -> 'a t -> 'a
val map : ('a -> 'b) -> 'a t -> 'b t
val mapi : (key -> 'a -> 'b) -> 'a t -> 'b t
val change : ('a option -> 'a option) -> key -> 'a t -> 'a t
val inter : (key -> 'a -> 'b -> 'c option) -> 'a t -> 'b t -> 'c t
val diff : (key -> 'a -> 'b -> 'a option) -> 'a t -> 'b t -> 'a t
val submap : (key -> 'a -> 'b -> bool) -> 'a t -> 'b t -> bool
val disjoint : (key -> 'a -> 'b -> bool) -> 'a t -> 'b t -> bool
val set_union : 'a t -> 'a t -> 'a t
val set_inter : 'a t -> 'b t -> 'a t
val set_diff : 'a t -> 'b t -> 'a t
val set_submap : 'a t -> 'b t -> bool
val set_disjoint : 'a t -> 'b t -> bool
val set_compare : 'a t -> 'b t -> int
val set_equal : 'a t -> 'b t -> bool
val find_def : 'a -> key -> 'a t -> 'a
val find_opt : key -> 'a t -> 'a option
val find_exn : exn -> key -> 'a t -> 'a
val map_filter : ('a -> 'b option) -> 'a t -> 'b t
val mapi_filter : (key -> 'a -> 'b option) -> 'a t -> 'b t
val mapi_fold :
(key -> 'a -> 'acc -> 'acc * 'b) -> 'a t -> 'acc -> 'acc * 'b t
val mapi_filter_fold :
(key -> 'a -> 'acc -> 'acc * 'b option) ->
'a t -> 'acc -> 'acc * 'b t
val fold_left : ('b -> key -> 'a -> 'b) -> 'b -> 'a t -> 'b
val fold_right : (key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b
val fold2_inter :
(key -> 'a -> 'b -> 'c -> 'c) -> 'a t -> 'b t -> 'c -> 'c
val fold2_union :
(key -> 'a option -> 'b option -> 'c -> 'c) ->
'a t -> 'b t -> 'c -> 'c
val translate : (key -> key) -> 'a t -> 'a t
val add_new : exn -> key -> 'a -> 'a t -> 'a t
val replace : exn -> key -> 'a -> 'a t -> 'a t
val keys : 'a t -> key list
val values : 'a t -> 'a list
val of_list : (key * 'a) list -> 'a t
val contains : 'a t -> key -> bool
val domain : 'a t -> unit t
val subdomain : (key -> 'a -> bool) -> 'a t -> unit t
val is_num_elt : int -> 'a t -> bool
type 'a enumeration = 'a Mtv.enumeration
val val_enum : 'a enumeration -> (key * 'a) option
val start_enum : 'a t -> 'a enumeration
val next_enum : 'a enumeration -> 'a enumeration
val start_ge_enum : key -> 'a t -> 'a enumeration
val next_ge_enum : key -> 'a enumeration -> 'a enumeration
end
type elt = M.key
type t = unit M.t
val empty : t
val is_empty : t -> bool
val mem : elt -> t -> bool
val add : elt -> t -> t
val singleton : elt -> t
val remove : elt -> t -> t
val merge : (elt -> bool -> bool -> bool) -> t -> t -> t
val compare : t -> t -> int
val equal : t -> t -> bool
val subset : t -> t -> bool
val disjoint : t -> t -> bool
val iter : (elt -> unit) -> t -> unit
val fold : (elt -> 'a -> 'a) -> t -> 'a -> 'a
val for_all : (elt -> bool) -> t -> bool
val exists : (elt -> bool) -> t -> bool
val filter : (elt -> bool) -> t -> t
val partition : (elt -> bool) -> t -> t * t
val cardinal : t -> int
val elements : t -> elt list
val min_elt : t -> elt
val max_elt : t -> elt
val choose : t -> elt
val split : elt -> t -> t * bool * t
val change : (bool -> bool) -> elt -> t -> t
val union : t -> t -> t
val inter : t -> t -> t
val diff : t -> t -> t
val fold_left : ('b -> elt -> 'b) -> 'b -> t -> 'b
val fold_right : (elt -> 'a -> 'a) -> t -> 'a -> 'a
val fold2_inter : (elt -> 'a -> 'a) -> t -> t -> 'a -> 'a
val fold2_union : (elt -> 'a -> 'a) -> t -> t -> 'a -> 'a
val translate : (elt -> elt) -> t -> t
val add_new : exn -> elt -> t -> t
val is_num_elt : int -> t -> bool
val of_list : elt list -> t
val contains : t -> elt -> bool
val add_left : t -> elt -> t
val remove_left : t -> elt -> t
val print :
(Format.formatter -> elt -> unit) -> Format.formatter -> t -> unit
end
module Htv :
sig
type key = tvsymbol
type !'a t
val create : int -> 'a t
val clear : 'a t -> unit
val reset : 'a t -> unit
val copy : 'a t -> 'a t
val add : 'a t -> key -> 'a -> unit
val remove : 'a t -> key -> unit
val find : 'a t -> key -> 'a
val find_all : 'a t -> key -> 'a list
val replace : 'a t -> key -> 'a -> unit
val mem : 'a t -> key -> bool
val iter : (key -> 'a -> unit) -> 'a t -> unit
val filter_map_inplace : (key -> 'a -> 'a option) -> 'a t -> unit
val fold : (key -> 'a -> 'acc -> 'acc) -> 'a t -> 'acc -> 'acc
val length : 'a t -> int
val stats : 'a t -> Hashtbl.statistics
val to_seq : 'a t -> (key * 'a) Seq.t
val to_seq_keys : 'a t -> key Seq.t
val to_seq_values : 'a t -> 'a Seq.t
val add_seq : 'a t -> (key * 'a) Seq.t -> unit
val replace_seq : 'a t -> (key * 'a) Seq.t -> unit
val of_seq : (key * 'a) Seq.t -> 'a t
val find_def : 'a t -> 'a -> key -> 'a
val find_opt : 'a t -> key -> 'a option
val find_exn : 'a t -> exn -> key -> 'a
val map : (key -> 'a -> 'b) -> 'a t -> 'b t
val memo : int -> (key -> 'a) -> key -> 'a
val is_empty : 'a t -> bool
end
val tv_compare : Ty.tvsymbol -> Ty.tvsymbol -> int
val tv_equal : Ty.tvsymbol -> Ty.tvsymbol -> bool
val tv_hash : Ty.tvsymbol -> int
val create_tvsymbol : Ident.preid -> Ty.tvsymbol
val tv_of_string : string -> Ty.tvsymbol
type 'a type_def =
NoDef
| Alias of 'a
| Range of Number.int_range
| Float of Number.float_format
type tysymbol = private {
ts_name : Ident.ident;
ts_args : Ty.tvsymbol list;
ts_def : Ty.ty Ty.type_def;
}
and ty = private { ty_node : Ty.ty_node; ty_tag : Weakhtbl.tag; }
and ty_node = private
Tyvar of Ty.tvsymbol
| Tyapp of Ty.tysymbol * Ty.ty list
module Mts :
sig
type key = tysymbol
type +'a t
val empty : 'a t
val is_empty : 'a t -> bool
val mem : key -> 'a t -> bool
val add : key -> 'a -> 'a t -> 'a t
val singleton : key -> 'a -> 'a t
val remove : key -> 'a t -> 'a t
val merge :
(key -> 'a option -> 'b option -> 'c option) -> 'a t -> 'b t -> 'c t
val union : (key -> 'a -> 'a -> 'a option) -> 'a t -> 'a t -> 'a t
val compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int
val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool
val iter : (key -> 'a -> unit) -> 'a t -> unit
val fold : (key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b
val for_all : (key -> 'a -> bool) -> 'a t -> bool
val exists : (key -> 'a -> bool) -> 'a t -> bool
val filter : (key -> 'a -> bool) -> 'a t -> 'a t
val partition : (key -> 'a -> bool) -> 'a t -> 'a t * 'a t
val cardinal : 'a t -> int
val bindings : 'a t -> (key * 'a) list
val min_binding : 'a t -> key * 'a
val max_binding : 'a t -> key * 'a
val choose : 'a t -> key * 'a
val split : key -> 'a t -> 'a t * 'a option * 'a t
val find : key -> 'a t -> 'a
val map : ('a -> 'b) -> 'a t -> 'b t
val mapi : (key -> 'a -> 'b) -> 'a t -> 'b t
val change : ('a option -> 'a option) -> key -> 'a t -> 'a t
val inter : (key -> 'a -> 'b -> 'c option) -> 'a t -> 'b t -> 'c t
val diff : (key -> 'a -> 'b -> 'a option) -> 'a t -> 'b t -> 'a t
val submap : (key -> 'a -> 'b -> bool) -> 'a t -> 'b t -> bool
val disjoint : (key -> 'a -> 'b -> bool) -> 'a t -> 'b t -> bool
val set_union : 'a t -> 'a t -> 'a t
val set_inter : 'a t -> 'b t -> 'a t
val set_diff : 'a t -> 'b t -> 'a t
val set_submap : 'a t -> 'b t -> bool
val set_disjoint : 'a t -> 'b t -> bool
val set_compare : 'a t -> 'b t -> int
val set_equal : 'a t -> 'b t -> bool
val find_def : 'a -> key -> 'a t -> 'a
val find_opt : key -> 'a t -> 'a option
val find_exn : exn -> key -> 'a t -> 'a
val map_filter : ('a -> 'b option) -> 'a t -> 'b t
val mapi_filter : (key -> 'a -> 'b option) -> 'a t -> 'b t
val mapi_fold :
(key -> 'a -> 'acc -> 'acc * 'b) -> 'a t -> 'acc -> 'acc * 'b t
val mapi_filter_fold :
(key -> 'a -> 'acc -> 'acc * 'b option) ->
'a t -> 'acc -> 'acc * 'b t
val fold_left : ('b -> key -> 'a -> 'b) -> 'b -> 'a t -> 'b
val fold_right : (key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b
val fold2_inter :
(key -> 'a -> 'b -> 'c -> 'c) -> 'a t -> 'b t -> 'c -> 'c
val fold2_union :
(key -> 'a option -> 'b option -> 'c -> 'c) ->
'a t -> 'b t -> 'c -> 'c
val translate : (key -> key) -> 'a t -> 'a t
val add_new : exn -> key -> 'a -> 'a t -> 'a t
val replace : exn -> key -> 'a -> 'a t -> 'a t
val keys : 'a t -> key list
val values : 'a t -> 'a list
val of_list : (key * 'a) list -> 'a t
val contains : 'a t -> key -> bool
val domain : 'a t -> unit t
val subdomain : (key -> 'a -> bool) -> 'a t -> unit t
val is_num_elt : int -> 'a t -> bool
type 'a enumeration
val val_enum : 'a enumeration -> (key * 'a) option
val start_enum : 'a t -> 'a enumeration
val next_enum : 'a enumeration -> 'a enumeration
val start_ge_enum : key -> 'a t -> 'a enumeration
val next_ge_enum : key -> 'a enumeration -> 'a enumeration
end
module Sts :
sig
module M :
sig
type key = tysymbol
type 'a t = 'a Mts.t
val empty : 'a t
val is_empty : 'a t -> bool
val mem : key -> 'a t -> bool
val add : key -> 'a -> 'a t -> 'a t
val singleton : key -> 'a -> 'a t
val remove : key -> 'a t -> 'a t
val merge :
(key -> 'a option -> 'b option -> 'c option) ->
'a t -> 'b t -> 'c t
val union : (key -> 'a -> 'a -> 'a option) -> 'a t -> 'a t -> 'a t
val compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int
val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool
val iter : (key -> 'a -> unit) -> 'a t -> unit
val fold : (key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b
val for_all : (key -> 'a -> bool) -> 'a t -> bool
val exists : (key -> 'a -> bool) -> 'a t -> bool
val filter : (key -> 'a -> bool) -> 'a t -> 'a t
val partition : (key -> 'a -> bool) -> 'a t -> 'a t * 'a t
val cardinal : 'a t -> int
val bindings : 'a t -> (key * 'a) list
val min_binding : 'a t -> key * 'a
val max_binding : 'a t -> key * 'a
val choose : 'a t -> key * 'a
val split : key -> 'a t -> 'a t * 'a option * 'a t
val find : key -> 'a t -> 'a
val map : ('a -> 'b) -> 'a t -> 'b t
val mapi : (key -> 'a -> 'b) -> 'a t -> 'b t
val change : ('a option -> 'a option) -> key -> 'a t -> 'a t
val inter : (key -> 'a -> 'b -> 'c option) -> 'a t -> 'b t -> 'c t
val diff : (key -> 'a -> 'b -> 'a option) -> 'a t -> 'b t -> 'a t
val submap : (key -> 'a -> 'b -> bool) -> 'a t -> 'b t -> bool
val disjoint : (key -> 'a -> 'b -> bool) -> 'a t -> 'b t -> bool
val set_union : 'a t -> 'a t -> 'a t
val set_inter : 'a t -> 'b t -> 'a t
val set_diff : 'a t -> 'b t -> 'a t
val set_submap : 'a t -> 'b t -> bool
val set_disjoint : 'a t -> 'b t -> bool
val set_compare : 'a t -> 'b t -> int
val set_equal : 'a t -> 'b t -> bool
val find_def : 'a -> key -> 'a t -> 'a
val find_opt : key -> 'a t -> 'a option
val find_exn : exn -> key -> 'a t -> 'a
val map_filter : ('a -> 'b option) -> 'a t -> 'b t
val mapi_filter : (key -> 'a -> 'b option) -> 'a t -> 'b t
val mapi_fold :
(key -> 'a -> 'acc -> 'acc * 'b) -> 'a t -> 'acc -> 'acc * 'b t
val mapi_filter_fold :
(key -> 'a -> 'acc -> 'acc * 'b option) ->
'a t -> 'acc -> 'acc * 'b t
val fold_left : ('b -> key -> 'a -> 'b) -> 'b -> 'a t -> 'b
val fold_right : (key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b
val fold2_inter :
(key -> 'a -> 'b -> 'c -> 'c) -> 'a t -> 'b t -> 'c -> 'c
val fold2_union :
(key -> 'a option -> 'b option -> 'c -> 'c) ->
'a t -> 'b t -> 'c -> 'c
val translate : (key -> key) -> 'a t -> 'a t
val add_new : exn -> key -> 'a -> 'a t -> 'a t
val replace : exn -> key -> 'a -> 'a t -> 'a t
val keys : 'a t -> key list
val values : 'a t -> 'a list
val of_list : (key * 'a) list -> 'a t
val contains : 'a t -> key -> bool
val domain : 'a t -> unit t
val subdomain : (key -> 'a -> bool) -> 'a t -> unit t
val is_num_elt : int -> 'a t -> bool
type 'a enumeration = 'a Mts.enumeration
val val_enum : 'a enumeration -> (key * 'a) option
val start_enum : 'a t -> 'a enumeration
val next_enum : 'a enumeration -> 'a enumeration
val start_ge_enum : key -> 'a t -> 'a enumeration
val next_ge_enum : key -> 'a enumeration -> 'a enumeration
end
type elt = M.key
type t = unit M.t
val empty : t
val is_empty : t -> bool
val mem : elt -> t -> bool
val add : elt -> t -> t
val singleton : elt -> t
val remove : elt -> t -> t
val merge : (elt -> bool -> bool -> bool) -> t -> t -> t
val compare : t -> t -> int
val equal : t -> t -> bool
val subset : t -> t -> bool
val disjoint : t -> t -> bool
val iter : (elt -> unit) -> t -> unit
val fold : (elt -> 'a -> 'a) -> t -> 'a -> 'a
val for_all : (elt -> bool) -> t -> bool
val exists : (elt -> bool) -> t -> bool
val filter : (elt -> bool) -> t -> t
val partition : (elt -> bool) -> t -> t * t
val cardinal : t -> int
val elements : t -> elt list
val min_elt : t -> elt
val max_elt : t -> elt
val choose : t -> elt
val split : elt -> t -> t * bool * t
val change : (bool -> bool) -> elt -> t -> t
val union : t -> t -> t
val inter : t -> t -> t
val diff : t -> t -> t
val fold_left : ('b -> elt -> 'b) -> 'b -> t -> 'b
val fold_right : (elt -> 'a -> 'a) -> t -> 'a -> 'a
val fold2_inter : (elt -> 'a -> 'a) -> t -> t -> 'a -> 'a
val fold2_union : (elt -> 'a -> 'a) -> t -> t -> 'a -> 'a
val translate : (elt -> elt) -> t -> t
val add_new : exn -> elt -> t -> t
val is_num_elt : int -> t -> bool
val of_list : elt list -> t
val contains : t -> elt -> bool
val add_left : t -> elt -> t
val remove_left : t -> elt -> t
val print :
(Format.formatter -> elt -> unit) -> Format.formatter -> t -> unit
end
module Hts :
sig
type key = tysymbol
type !'a t
val create : int -> 'a t
val clear : 'a t -> unit
val reset : 'a t -> unit
val copy : 'a t -> 'a t
val add : 'a t -> key -> 'a -> unit
val remove : 'a t -> key -> unit
val find : 'a t -> key -> 'a
val find_all : 'a t -> key -> 'a list
val replace : 'a t -> key -> 'a -> unit
val mem : 'a t -> key -> bool
val iter : (key -> 'a -> unit) -> 'a t -> unit
val filter_map_inplace : (key -> 'a -> 'a option) -> 'a t -> unit
val fold : (key -> 'a -> 'acc -> 'acc) -> 'a t -> 'acc -> 'acc
val length : 'a t -> int
val stats : 'a t -> Hashtbl.statistics
val to_seq : 'a t -> (key * 'a) Seq.t
val to_seq_keys : 'a t -> key Seq.t
val to_seq_values : 'a t -> 'a Seq.t
val add_seq : 'a t -> (key * 'a) Seq.t -> unit
val replace_seq : 'a t -> (key * 'a) Seq.t -> unit
val of_seq : (key * 'a) Seq.t -> 'a t
val find_def : 'a t -> 'a -> key -> 'a
val find_opt : 'a t -> key -> 'a option
val find_exn : 'a t -> exn -> key -> 'a
val map : (key -> 'a -> 'b) -> 'a t -> 'b t
val memo : int -> (key -> 'a) -> key -> 'a
val is_empty : 'a t -> bool
end
module Wts :
sig
type key = tysymbol
type 'a t
val create : int -> 'a t
val clear : 'a t -> unit
val copy : 'a t -> 'a t
val find : 'a t -> key -> 'a
val mem : 'a t -> key -> bool
val set : 'a t -> key -> 'a -> unit
val remove : 'a t -> key -> unit
val length : 'a t -> int
val memoize : int -> (key -> 'a) -> key -> 'a
val memoize_rec : int -> ((key -> 'a) -> key -> 'a) -> key -> 'a
val memoize_option : int -> (key option -> 'a) -> key option -> 'a
end
module Mty :
sig
type key = ty
type +'a t
val empty : 'a t
val is_empty : 'a t -> bool
val mem : key -> 'a t -> bool
val add : key -> 'a -> 'a t -> 'a t
val singleton : key -> 'a -> 'a t
val remove : key -> 'a t -> 'a t
val merge :
(key -> 'a option -> 'b option -> 'c option) -> 'a t -> 'b t -> 'c t
val union : (key -> 'a -> 'a -> 'a option) -> 'a t -> 'a t -> 'a t
val compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int
val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool
val iter : (key -> 'a -> unit) -> 'a t -> unit
val fold : (key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b
val for_all : (key -> 'a -> bool) -> 'a t -> bool
val exists : (key -> 'a -> bool) -> 'a t -> bool
val filter : (key -> 'a -> bool) -> 'a t -> 'a t
val partition : (key -> 'a -> bool) -> 'a t -> 'a t * 'a t
val cardinal : 'a t -> int
val bindings : 'a t -> (key * 'a) list
val min_binding : 'a t -> key * 'a
val max_binding : 'a t -> key * 'a
val choose : 'a t -> key * 'a
val split : key -> 'a t -> 'a t * 'a option * 'a t
val find : key -> 'a t -> 'a
val map : ('a -> 'b) -> 'a t -> 'b t
val mapi : (key -> 'a -> 'b) -> 'a t -> 'b t
val change : ('a option -> 'a option) -> key -> 'a t -> 'a t
val inter : (key -> 'a -> 'b -> 'c option) -> 'a t -> 'b t -> 'c t
val diff : (key -> 'a -> 'b -> 'a option) -> 'a t -> 'b t -> 'a t
val submap : (key -> 'a -> 'b -> bool) -> 'a t -> 'b t -> bool
val disjoint : (key -> 'a -> 'b -> bool) -> 'a t -> 'b t -> bool
val set_union : 'a t -> 'a t -> 'a t
val set_inter : 'a t -> 'b t -> 'a t
val set_diff : 'a t -> 'b t -> 'a t
val set_submap : 'a t -> 'b t -> bool
val set_disjoint : 'a t -> 'b t -> bool
val set_compare : 'a t -> 'b t -> int
val set_equal : 'a t -> 'b t -> bool
val find_def : 'a -> key -> 'a t -> 'a
val find_opt : key -> 'a t -> 'a option
val find_exn : exn -> key -> 'a t -> 'a
val map_filter : ('a -> 'b option) -> 'a t -> 'b t
val mapi_filter : (key -> 'a -> 'b option) -> 'a t -> 'b t
val mapi_fold :
(key -> 'a -> 'acc -> 'acc * 'b) -> 'a t -> 'acc -> 'acc * 'b t
val mapi_filter_fold :
(key -> 'a -> 'acc -> 'acc * 'b option) ->
'a t -> 'acc -> 'acc * 'b t
val fold_left : ('b -> key -> 'a -> 'b) -> 'b -> 'a t -> 'b
val fold_right : (key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b
val fold2_inter :
(key -> 'a -> 'b -> 'c -> 'c) -> 'a t -> 'b t -> 'c -> 'c
val fold2_union :
(key -> 'a option -> 'b option -> 'c -> 'c) ->
'a t -> 'b t -> 'c -> 'c
val translate : (key -> key) -> 'a t -> 'a t
val add_new : exn -> key -> 'a -> 'a t -> 'a t
val replace : exn -> key -> 'a -> 'a t -> 'a t
val keys : 'a t -> key list
val values : 'a t -> 'a list
val of_list : (key * 'a) list -> 'a t
val contains : 'a t -> key -> bool
val domain : 'a t -> unit t
val subdomain : (key -> 'a -> bool) -> 'a t -> unit t
val is_num_elt : int -> 'a t -> bool
type 'a enumeration
val val_enum : 'a enumeration -> (key * 'a) option
val start_enum : 'a t -> 'a enumeration
val next_enum : 'a enumeration -> 'a enumeration
val start_ge_enum : key -> 'a t -> 'a enumeration
val next_ge_enum : key -> 'a enumeration -> 'a enumeration
end
module Sty :
sig
module M :
sig
type key = ty
type 'a t = 'a Mty.t
val empty : 'a t
val is_empty : 'a t -> bool
val mem : key -> 'a t -> bool
val add : key -> 'a -> 'a t -> 'a t
val singleton : key -> 'a -> 'a t
val remove : key -> 'a t -> 'a t
val merge :
(key -> 'a option -> 'b option -> 'c option) ->
'a t -> 'b t -> 'c t
val union : (key -> 'a -> 'a -> 'a option) -> 'a t -> 'a t -> 'a t
val compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int
val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool
val iter : (key -> 'a -> unit) -> 'a t -> unit
val fold : (key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b
val for_all : (key -> 'a -> bool) -> 'a t -> bool
val exists : (key -> 'a -> bool) -> 'a t -> bool
val filter : (key -> 'a -> bool) -> 'a t -> 'a t
val partition : (key -> 'a -> bool) -> 'a t -> 'a t * 'a t
val cardinal : 'a t -> int
val bindings : 'a t -> (key * 'a) list
val min_binding : 'a t -> key * 'a
val max_binding : 'a t -> key * 'a
val choose : 'a t -> key * 'a
val split : key -> 'a t -> 'a t * 'a option * 'a t
val find : key -> 'a t -> 'a
val map : ('a -> 'b) -> 'a t -> 'b t
val mapi : (key -> 'a -> 'b) -> 'a t -> 'b t
val change : ('a option -> 'a option) -> key -> 'a t -> 'a t
val inter : (key -> 'a -> 'b -> 'c option) -> 'a t -> 'b t -> 'c t
val diff : (key -> 'a -> 'b -> 'a option) -> 'a t -> 'b t -> 'a t
val submap : (key -> 'a -> 'b -> bool) -> 'a t -> 'b t -> bool
val disjoint : (key -> 'a -> 'b -> bool) -> 'a t -> 'b t -> bool
val set_union : 'a t -> 'a t -> 'a t
val set_inter : 'a t -> 'b t -> 'a t
val set_diff : 'a t -> 'b t -> 'a t
val set_submap : 'a t -> 'b t -> bool
val set_disjoint : 'a t -> 'b t -> bool
val set_compare : 'a t -> 'b t -> int
val set_equal : 'a t -> 'b t -> bool
val find_def : 'a -> key -> 'a t -> 'a
val find_opt : key -> 'a t -> 'a option
val find_exn : exn -> key -> 'a t -> 'a
val map_filter : ('a -> 'b option) -> 'a t -> 'b t
val mapi_filter : (key -> 'a -> 'b option) -> 'a t -> 'b t
val mapi_fold :
(key -> 'a -> 'acc -> 'acc * 'b) -> 'a t -> 'acc -> 'acc * 'b t
val mapi_filter_fold :
(key -> 'a -> 'acc -> 'acc * 'b option) ->
'a t -> 'acc -> 'acc * 'b t
val fold_left : ('b -> key -> 'a -> 'b) -> 'b -> 'a t -> 'b
val fold_right : (key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b
val fold2_inter :
(key -> 'a -> 'b -> 'c -> 'c) -> 'a t -> 'b t -> 'c -> 'c
val fold2_union :
(key -> 'a option -> 'b option -> 'c -> 'c) ->
'a t -> 'b t -> 'c -> 'c
val translate : (key -> key) -> 'a t -> 'a t
val add_new : exn -> key -> 'a -> 'a t -> 'a t
val replace : exn -> key -> 'a -> 'a t -> 'a t
val keys : 'a t -> key list
val values : 'a t -> 'a list
val of_list : (key * 'a) list -> 'a t
val contains : 'a t -> key -> bool
val domain : 'a t -> unit t
val subdomain : (key -> 'a -> bool) -> 'a t -> unit t
val is_num_elt : int -> 'a t -> bool
type 'a enumeration = 'a Mty.enumeration
val val_enum : 'a enumeration -> (key * 'a) option
val start_enum : 'a t -> 'a enumeration
val next_enum : 'a enumeration -> 'a enumeration
val start_ge_enum : key -> 'a t -> 'a enumeration
val next_ge_enum : key -> 'a enumeration -> 'a enumeration
end
type elt = M.key
type t = unit M.t
val empty : t
val is_empty : t -> bool
val mem : elt -> t -> bool
val add : elt -> t -> t
val singleton : elt -> t
val remove : elt -> t -> t
val merge : (elt -> bool -> bool -> bool) -> t -> t -> t
val compare : t -> t -> int
val equal : t -> t -> bool
val subset : t -> t -> bool
val disjoint : t -> t -> bool
val iter : (elt -> unit) -> t -> unit
val fold : (elt -> 'a -> 'a) -> t -> 'a -> 'a
val for_all : (elt -> bool) -> t -> bool
val exists : (elt -> bool) -> t -> bool
val filter : (elt -> bool) -> t -> t
val partition : (elt -> bool) -> t -> t * t
val cardinal : t -> int
val elements : t -> elt list
val min_elt : t -> elt
val max_elt : t -> elt
val choose : t -> elt
val split : elt -> t -> t * bool * t
val change : (bool -> bool) -> elt -> t -> t
val union : t -> t -> t
val inter : t -> t -> t
val diff : t -> t -> t
val fold_left : ('b -> elt -> 'b) -> 'b -> t -> 'b
val fold_right : (elt -> 'a -> 'a) -> t -> 'a -> 'a
val fold2_inter : (elt -> 'a -> 'a) -> t -> t -> 'a -> 'a
val fold2_union : (elt -> 'a -> 'a) -> t -> t -> 'a -> 'a
val translate : (elt -> elt) -> t -> t
val add_new : exn -> elt -> t -> t
val is_num_elt : int -> t -> bool
val of_list : elt list -> t
val contains : t -> elt -> bool
val add_left : t -> elt -> t
val remove_left : t -> elt -> t
val print :
(Format.formatter -> elt -> unit) -> Format.formatter -> t -> unit
end
module Hty :
sig
type key = ty
type !'a t
val create : int -> 'a t
val clear : 'a t -> unit
val reset : 'a t -> unit
val copy : 'a t -> 'a t
val add : 'a t -> key -> 'a -> unit
val remove : 'a t -> key -> unit
val find : 'a t -> key -> 'a
val find_all : 'a t -> key -> 'a list
val replace : 'a t -> key -> 'a -> unit
val mem : 'a t -> key -> bool
val iter : (key -> 'a -> unit) -> 'a t -> unit
val filter_map_inplace : (key -> 'a -> 'a option) -> 'a t -> unit
val fold : (key -> 'a -> 'acc -> 'acc) -> 'a t -> 'acc -> 'acc
val length : 'a t -> int
val stats : 'a t -> Hashtbl.statistics
val to_seq : 'a t -> (key * 'a) Seq.t
val to_seq_keys : 'a t -> key Seq.t
val to_seq_values : 'a t -> 'a Seq.t
val add_seq : 'a t -> (key * 'a) Seq.t -> unit
val replace_seq : 'a t -> (key * 'a) Seq.t -> unit
val of_seq : (key * 'a) Seq.t -> 'a t
val find_def : 'a t -> 'a -> key -> 'a
val find_opt : 'a t -> key -> 'a option
val find_exn : 'a t -> exn -> key -> 'a
val map : (key -> 'a -> 'b) -> 'a t -> 'b t
val memo : int -> (key -> 'a) -> key -> 'a
val is_empty : 'a t -> bool
end
module Wty :
sig
type key = ty
type 'a t
val create : int -> 'a t
val clear : 'a t -> unit
val copy : 'a t -> 'a t
val find : 'a t -> key -> 'a
val mem : 'a t -> key -> bool
val set : 'a t -> key -> 'a -> unit
val remove : 'a t -> key -> unit
val length : 'a t -> int
val memoize : int -> (key -> 'a) -> key -> 'a
val memoize_rec : int -> ((key -> 'a) -> key -> 'a) -> key -> 'a
val memoize_option : int -> (key option -> 'a) -> key option -> 'a
end
val ts_compare : Ty.tysymbol -> Ty.tysymbol -> int
val ty_compare : Ty.ty -> Ty.ty -> int
val ts_equal : Ty.tysymbol -> Ty.tysymbol -> bool
val ty_equal : Ty.ty -> Ty.ty -> bool
val ts_hash : Ty.tysymbol -> int
val ty_hash : Ty.ty -> int
exception BadTypeArity of Ty.tysymbol * int
exception DuplicateTypeVar of Ty.tvsymbol
exception UnboundTypeVar of Ty.tvsymbol
exception IllegalTypeParameters
exception BadFloatSpec
exception EmptyRange
val create_tysymbol :
Ident.preid -> Ty.tvsymbol list -> Ty.ty Ty.type_def -> Ty.tysymbol
val ty_var : Ty.tvsymbol -> Ty.ty
val ty_app : Ty.tysymbol -> Ty.ty list -> Ty.ty
val type_def_map : ('a -> 'a) -> 'a Ty.type_def -> 'a Ty.type_def
val type_def_fold : ('a -> 'b -> 'a) -> 'a -> 'b Ty.type_def -> 'a
val is_alias_type_def : 'a Ty.type_def -> bool
val is_range_type_def : 'a Ty.type_def -> bool
val is_float_type_def : 'a Ty.type_def -> bool
val ty_map : (Ty.ty -> Ty.ty) -> Ty.ty -> Ty.ty
val ty_fold : ('a -> Ty.ty -> 'a) -> 'a -> Ty.ty -> 'a
val ty_all : (Ty.ty -> bool) -> Ty.ty -> bool
val ty_any : (Ty.ty -> bool) -> Ty.ty -> bool
val ty_v_map : (Ty.tvsymbol -> Ty.ty) -> Ty.ty -> Ty.ty
val ty_v_fold : ('a -> Ty.tvsymbol -> 'a) -> 'a -> Ty.ty -> 'a
val ty_v_all : (Ty.tvsymbol -> bool) -> Ty.ty -> bool
val ty_v_any : (Ty.tvsymbol -> bool) -> Ty.ty -> bool
val ty_s_map : (Ty.tysymbol -> Ty.tysymbol) -> Ty.ty -> Ty.ty
val ty_s_fold : ('a -> Ty.tysymbol -> 'a) -> 'a -> Ty.ty -> 'a
val ty_s_all : (Ty.tysymbol -> bool) -> Ty.ty -> bool
val ty_s_any : (Ty.tysymbol -> bool) -> Ty.ty -> bool
exception TypeMismatch of Ty.ty * Ty.ty
val ty_match : Ty.ty Ty.Mtv.t -> Ty.ty -> Ty.ty -> Ty.ty Ty.Mtv.t
val ts_match_args : Ty.tysymbol -> Ty.ty list -> Ty.ty Ty.Mtv.t
val ty_match_args : Ty.ty -> Ty.ty Ty.Mtv.t
val ty_inst : Ty.ty Ty.Mtv.t -> Ty.ty -> Ty.ty
val ty_freevars : Ty.Stv.t -> Ty.ty -> Ty.Stv.t
val ty_closed : Ty.ty -> bool
val ty_equal_check : Ty.ty -> Ty.ty -> unit
val ts_int : Ty.tysymbol
val ts_real : Ty.tysymbol
val ts_bool : Ty.tysymbol
val ts_str : Ty.tysymbol
val ty_int : Ty.ty
val ty_real : Ty.ty
val ty_bool : Ty.ty
val ty_str : Ty.ty
val ts_func : Ty.tysymbol
val ty_func : Ty.ty -> Ty.ty -> Ty.ty
val ty_pred : Ty.ty -> Ty.ty
val ts_tuple : int -> Ty.tysymbol
val ty_tuple : Ty.ty list -> Ty.ty
val is_ts_tuple : Ty.tysymbol -> bool
val is_ts_tuple_id : Ident.ident -> int option
exception UnexpectedProp
val oty_compare : Ty.ty option -> Ty.ty option -> int
val oty_equal : Ty.ty option -> Ty.ty option -> bool
val oty_hash : Ty.ty option -> int
val oty_type : Ty.ty option -> Ty.ty
val oty_cons : Ty.ty list -> Ty.ty option -> Ty.ty list
val oty_match :
Ty.ty Ty.Mtv.t -> Ty.ty option -> Ty.ty option -> Ty.ty Ty.Mtv.t
val oty_inst : Ty.ty Ty.Mtv.t -> Ty.ty option -> Ty.ty option
val oty_freevars : Ty.Stv.t -> Ty.ty option -> Ty.Stv.t
end