functor
(Key : Hptmap.Id_Datatype) (KSet : sig
module O :
sig
type elt = Key.t
type 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 union : t -> t -> t
val inter : t -> t -> t
val diff : t -> t -> t
val subset : 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 choose : t -> elt
val find : elt -> t -> elt
val of_list : elt list -> t
val ty : t Type.t
val name : string
val descr : t Descr.t
val packed_descr :
Structural_descr.pack
val reprs : t list
val equal : t -> t -> bool
val compare : t -> t -> int
val hash : t -> int
val pretty_code :
Format.formatter -> t -> unit
val internal_pretty_code :
Type.precedence ->
Format.formatter -> t -> unit
val pretty :
Format.formatter -> t -> unit
val varname : t -> string
val mem_project :
(Project_skeleton.t -> bool) ->
t -> bool
val copy : t -> t
end
type t = private Set of O.t | Top
val ty : t Type.t
val name : string
val descr : t Descr.t
val packed_descr :
Structural_descr.pack
val reprs : t list
val equal : t -> t -> bool
val compare : t -> t -> int
val hash : t -> int
val pretty_code :
Format.formatter -> t -> unit
val internal_pretty_code :
Type.precedence ->
Format.formatter -> t -> unit
val pretty :
Format.formatter -> t -> unit
val varname : t -> string
val mem_project :
(Project_skeleton.t -> bool) ->
t -> bool
val copy : t -> t
val join : t -> t -> t
val is_included : t -> t -> bool
val bottom : t
val top : t
type widen_hint = O.t
val widen : widen_hint -> t -> t -> t
val cardinal_zero_or_one : t -> bool
val narrow : t -> t -> t
val link : t -> t -> t
val meet : t -> t -> t
val intersects : t -> t -> bool
val inject_singleton : O.elt -> t
val inject : O.t -> t
val empty : t
val apply2 :
(O.elt -> O.elt -> O.elt) ->
t -> t -> t
val apply1 :
(O.elt -> O.elt) -> t -> t
val fold :
(O.elt -> 'a -> 'a) -> t -> 'a -> 'a
val iter :
(O.elt -> unit) -> t -> unit
val exists :
(O.elt -> bool) -> t -> bool
val for_all :
(O.elt -> bool) -> t -> bool
val filter : (O.elt -> bool) -> t -> t
val project : t -> O.t
val mem : O.elt -> t -> bool
end) (Value : Value) (KVMap : sig
type key =
Key.t
type v =
Value.t
type
'a shape
type prefix
type t
module Set :
sig
type elt =
t
type 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 union :
t ->
t -> t
val inter :
t ->
t -> t
val disjoint :
t ->
t -> bool
val diff :
t ->
t -> t
val subset :
t ->
t -> bool
val iter :
(elt ->
unit) ->
t -> unit
val map :
(elt ->
elt) ->
t -> t
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 min_elt_opt :
t ->
elt
option
val max_elt :
t -> elt
val max_elt_opt :
t ->
elt
option
val choose :
t -> elt
val choose_opt :
t ->
elt
option
val split :
elt ->
t ->
t *
bool *
t
val find :
elt ->
t -> elt
val find_opt :
elt ->
t ->
elt
option
val find_first :
(elt ->
bool) ->
t -> elt
val find_first_opt :
(elt ->
bool) ->
t ->
elt
option
val find_last :
(elt ->
bool) ->
t -> elt
val find_last_opt :
(elt ->
bool) ->
t ->
elt
option
val of_list :
elt list ->
t
val to_seq_from :
elt ->
t ->
elt Seq.t
val to_seq :
t ->
elt Seq.t
val add_seq :
elt Seq.t ->
t -> t
val of_seq :
elt Seq.t ->
t
val nearest_elt_le :
elt ->
t -> elt
val nearest_elt_ge :
elt ->
t -> elt
val ty :
t Type.t
val name :
string
val descr :
t Descr.t
val packed_descr :
Structural_descr.pack
val reprs :
t list
val equal :
t ->
t -> bool
val compare :
t ->
t -> int
val hash :
t -> int
val pretty_code :
Format.formatter ->
t -> unit
val internal_pretty_code :
Type.precedence ->
Format.formatter ->
t -> unit
val pretty :
Format.formatter ->
t -> unit
val varname :
t ->
string
val mem_project :
(Project_skeleton.t ->
bool) ->
t -> bool
val copy :
t -> t
end
module Map :
sig
type key =
t
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 update :
key ->
('a
option ->
'a option) ->
'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 min_binding_opt :
'a t ->
(key * 'a)
option
val max_binding :
'a t ->
key * 'a
val max_binding_opt :
'a t ->
(key * 'a)
option
val choose :
'a t ->
key * 'a
val choose_opt :
'a t ->
(key * 'a)
option
val split :
key ->
'a t ->
'a t *
'a option *
'a t
val find :
key ->
'a t ->
'a
val find_opt :
key ->
'a t ->
'a option
val find_first :
(key ->
bool) ->
'a t ->
key * 'a
val find_first_opt :
(key ->
bool) ->
'a t ->
(key * 'a)
option
val find_last :
(key ->
bool) ->
'a t ->
key * 'a
val find_last_opt :
(key ->
bool) ->
'a t ->
(key * 'a)
option
val map :
('a -> 'b) ->
'a t ->
'b t
val mapi :
(key ->
'a -> 'b) ->
'a t ->
'b t
val to_seq :
'a t ->
(key * 'a)
Seq.t
val to_seq_from :
key ->
'a t ->
(key * 'a)
Seq.t
val add_seq :
(key * 'a)
Seq.t ->
'a t ->
'a t
val of_seq :
(key * 'a)
Seq.t ->
'a t
module Key :
sig
type t =
key
val ty :
t Type.t
val name :
string
val descr :
t Descr.t
val packed_descr :
Structural_descr.pack
val reprs :
t list
val equal :
t ->
t -> bool
val compare :
t ->
t -> int
val hash :
t -> int
val pretty_code :
Format.formatter ->
t -> unit
val internal_pretty_code :
Type.precedence ->
Format.formatter ->
t -> unit
val pretty :
Format.formatter ->
t -> unit
val varname :
t ->
string
val mem_project :
(Project_skeleton.t ->
bool) ->
t -> bool
val copy :
t -> t
end
module Make :
functor
(Data : Datatype.S) ->
sig
type t =
Data.t t
val ty :
t Type.t
val name :
string
val descr :
t Descr.t
val packed_descr :
Structural_descr.pack
val reprs :
t list
val equal :
t ->
t -> bool
val compare :
t ->
t -> int
val hash :
t -> int
val pretty_code :
Format.formatter ->
t -> unit
val internal_pretty_code :
Type.precedence ->
Format.formatter ->
t -> unit
val pretty :
Format.formatter ->
t -> unit
val varname :
t ->
string
val mem_project :
(Project_skeleton.t ->
bool) ->
t -> bool
val copy :
t -> t
end
end
module Hashtbl :
sig
type key =
t
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 ->
'b -> 'b) ->
'a t ->
'b -> 'b
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 iter_sorted :
?cmp:
(key ->
key ->
int) ->
(key ->
'a ->
unit) ->
'a t ->
unit
val fold_sorted :
?cmp:
(key ->
key ->
int) ->
(key ->
'a ->
'b -> 'b) ->
'a t ->
'b -> 'b
val iter_sorted_by_entry :
cmp:
(key * 'a ->
key * 'a ->
int) ->
(key ->
'a ->
unit) ->
'a t ->
unit
val fold_sorted_by_entry :
cmp:
(key * 'a ->
key * 'a ->
int) ->
(key ->
'a ->
'b -> 'b) ->
'a t ->
'b -> 'b
val iter_sorted_by_value :
cmp:
('a ->
'a -> int) ->
(key ->
'a ->
unit) ->
'a t ->
unit
val fold_sorted_by_value :
cmp:
('a ->
'a -> int) ->
(key ->
'a ->
'b -> 'b) ->
'a t ->
'b -> 'b
val find_opt :
'a t ->
key ->
'a option
val find_def :
'a t ->
key ->
'a -> 'a
val memo :
'a t ->
key ->
(key ->
'a) -> 'a
val structural_descr :
Structural_descr.t ->
Structural_descr.t
val make_type :
'a Type.t ->
'a t
Type.t
module Key :
sig
type t =
key
val ty :
t Type.t
val name :
string
val descr :
t Descr.t
val packed_descr :
Structural_descr.pack
val reprs :
t list
val equal :
t ->
t -> bool
val compare :
t ->
t -> int
val hash :
t -> int
val pretty_code :
Format.formatter ->
t -> unit
val internal_pretty_code :
Type.precedence ->
Format.formatter ->
t -> unit
val pretty :
Format.formatter ->
t -> unit
val varname :
t ->
string
val mem_project :
(Project_skeleton.t ->
bool) ->
t -> bool
val copy :
t -> t
end
module Make :
functor
(Data : Datatype.S) ->
sig
type t =
Data.t t
val ty :
t Type.t
val name :
string
val descr :
t Descr.t
val packed_descr :
Structural_descr.pack
val reprs :
t list
val equal :
t ->
t -> bool
val compare :
t ->
t -> int
val hash :
t -> int
val pretty_code :
Format.formatter ->
t -> unit
val internal_pretty_code :
Type.precedence ->
Format.formatter ->
t -> unit
val pretty :
Format.formatter ->
t -> unit
val varname :
t ->
string
val mem_project :
(Project_skeleton.t ->
bool) ->
t -> bool
val copy :
t -> t
end
end
val id :
t -> int
val self :
State.t
val empty :
t
val is_empty :
t -> bool
val add :
key ->
v ->
t -> t
val replace :
(v option ->
v option) ->
key ->
t -> t
val find :
key ->
t -> v
val find_check_missing :
key ->
t -> v
val find_key :
key ->
t -> key
val remove :
key ->
t -> t
val mem :
key ->
t -> bool
val iter :
(key ->
v -> unit) ->
t -> unit
val map :
(v -> v) ->
t -> t
val map' :
(key ->
v ->
v option) ->
t -> t
val filter :
(key ->
bool) ->
t -> t
val fold :
(key ->
v ->
'b -> 'b) ->
t ->
'b -> 'b
val fold_rev :
(key ->
v ->
'b -> 'b) ->
t ->
'b -> 'b
val for_all :
(key ->
v -> bool) ->
t -> bool
val exists :
(key ->
v -> bool) ->
t -> bool
type empty_action =
Neutral
| Absorbing
| Traversing of
(key ->
v ->
v option)
val merge :
cache:
Hptmap_sig.cache_type ->
symmetric:
bool ->
idempotent:
bool ->
decide_both:
(key ->
v ->
v ->
v option) ->
decide_left:
empty_action ->
decide_right:
empty_action ->
t ->
t -> t
val generic_join :
cache:
Hptmap_sig.cache_type ->
symmetric:
bool ->
idempotent:
bool ->
decide:
(key ->
v option ->
v option ->
v) ->
t ->
t -> t
val inter :
cache:
Hptmap_sig.cache_type ->
symmetric:
bool ->
idempotent:
bool ->
decide:
(key ->
v ->
v ->
v option) ->
t ->
t -> t
val inter_with_shape :
'a shape ->
t -> t
val diff_with_shape :
'a shape ->
t -> t
type decide_fast =
Done
| Unknown
val generic_predicate :
exn ->
cache:
string *
'a ->
decide_fast:
(t ->
t ->
decide_fast) ->
decide_fst:
(key ->
v -> unit) ->
decide_snd:
(key ->
v -> unit) ->
decide_both:
(v ->
v -> unit) ->
t ->
t -> unit
type predicate_type =
ExistentialPredicate
| UniversalPredicate
type predicate_result =
PTrue
| PFalse
| PUnknown
val binary_predicate :
Hptmap_sig.cache_type ->
predicate_type ->
decide_fast:
(t ->
t ->
predicate_result) ->
decide_fst:
(key ->
v -> bool) ->
decide_snd:
(key ->
v -> bool) ->
decide_both:
(key ->
v ->
v -> bool) ->
t ->
t -> bool
val generic_symmetric_predicate :
exn ->
decide_fast:
(t ->
t ->
decide_fast) ->
decide_one:
(key ->
v -> unit) ->
decide_both:
(v ->
v -> unit) ->
t ->
t -> unit
val symmetric_binary_predicate :
Hptmap_sig.cache_type ->
predicate_type ->
decide_fast:
(t ->
t ->
predicate_result) ->
decide_one:
(key ->
v -> bool) ->
decide_both:
(key ->
v ->
v -> bool) ->
t ->
t -> bool
val decide_fast_inclusion :
t ->
t ->
predicate_result
val decide_fast_intersection :
t ->
t ->
predicate_result
val cached_fold :
cache_name:
string ->
temporary:
bool ->
f:
(key ->
v -> 'b) ->
joiner:
('b ->
'b -> 'b) ->
empty:'b ->
t -> 'b
val cached_map :
cache:
string *
int ->
temporary:
bool ->
f:
(key ->
v -> v) ->
t -> t
val singleton :
key ->
v -> t
val is_singleton :
t ->
(key * v)
option
val on_singleton :
(key ->
v -> bool) ->
t -> bool
val cardinal :
t -> int
val min_binding :
t ->
key * v
val max_binding :
t ->
key * v
val compositional_bool :
t -> bool
val clear_caches :
unit ->
unit
val from_shape :
(key ->
'a -> v) ->
'a shape ->
t
val from_shape_id :
v shape ->
t
val shape :
t ->
v shape
val fold2_join_heterogeneous :
cache:
Hptmap_sig.cache_type ->
empty_left:
('a shape ->
'b) ->
empty_right:
(t -> 'b) ->
both:
(key ->
v ->
'a -> 'b) ->
join:
('b ->
'b -> 'b) ->
empty:'b ->
t ->
'a shape ->
'b
val pretty_debug :
Format.formatter ->
t -> unit
val comp_prefixes :
t ->
t -> unit
val pretty_prefix :
prefix ->
Format.formatter ->
t -> unit
type subtree
exception
Found_prefix of
prefix *
subtree *
subtree
val find_prefix :
t ->
prefix ->
subtree
option
val hash_subtree :
subtree ->
int
val equal_subtree :
subtree ->
subtree ->
bool
val ty :
t Type.t
val name :
string
val descr :
t Descr.t
val packed_descr :
Structural_descr.pack
val reprs :
t list
val equal :
t ->
t -> bool
val compare :
t ->
t -> int
val hash :
t -> int
val pretty_code :
Format.formatter ->
t -> unit
val internal_pretty_code :
Type.precedence ->
Format.formatter ->
t -> unit
val pretty :
Format.formatter ->
t -> unit
val varname :
t ->
string
val mem_project :
(Project_skeleton.t ->
bool) ->
t -> bool
val copy :
t -> t
val join :
t ->
t -> t
val is_included :
t ->
t -> bool
val bottom :
t
val narrow :
t ->
t -> t
val link :
t ->
t -> t
val meet :
t ->
t -> t
val intersects :
t ->
t -> bool
val diff :
t ->
t -> t
val find_or_bottom :
key ->
t -> v
val find_lonely_key :
t ->
key * v
end) ->
sig
type t = Top of KSet.t * Origin.t | Map of KVMap.t
module Set :
sig
type elt = t
type 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 union : t -> t -> t
val inter : t -> t -> t
val disjoint : t -> t -> bool
val diff : t -> t -> t
val subset : t -> t -> bool
val iter : (elt -> unit) -> t -> unit
val map : (elt -> elt) -> t -> t
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 min_elt_opt : t -> elt option
val max_elt : t -> elt
val max_elt_opt : t -> elt option
val choose : t -> elt
val choose_opt : t -> elt option
val split : elt -> t -> t * bool * t
val find : elt -> t -> elt
val find_opt : elt -> t -> elt option
val find_first : (elt -> bool) -> t -> elt
val find_first_opt : (elt -> bool) -> t -> elt option
val find_last : (elt -> bool) -> t -> elt
val find_last_opt : (elt -> bool) -> t -> elt option
val of_list : elt list -> t
val to_seq_from : elt -> t -> elt Seq.t
val to_seq : t -> elt Seq.t
val add_seq : elt Seq.t -> t -> t
val of_seq : elt Seq.t -> t
val nearest_elt_le : elt -> t -> elt
val nearest_elt_ge : elt -> t -> elt
val ty : t Type.t
val name : string
val descr : t Descr.t
val packed_descr : Structural_descr.pack
val reprs : t list
val equal : t -> t -> bool
val compare : t -> t -> int
val hash : t -> int
val pretty_code : Format.formatter -> t -> unit
val internal_pretty_code :
Type.precedence -> Format.formatter -> t -> unit
val pretty : Format.formatter -> t -> unit
val varname : t -> string
val mem_project : (Project_skeleton.t -> bool) -> t -> bool
val copy : t -> t
end
module Map :
sig
type key = t
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 update : key -> ('a option -> 'a option) -> '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 min_binding_opt : 'a t -> (key * 'a) option
val max_binding : 'a t -> key * 'a
val max_binding_opt : 'a t -> (key * 'a) option
val choose : 'a t -> key * 'a
val choose_opt : 'a t -> (key * 'a) option
val split : key -> 'a t -> 'a t * 'a option * 'a t
val find : key -> 'a t -> 'a
val find_opt : key -> 'a t -> 'a option
val find_first : (key -> bool) -> 'a t -> key * 'a
val find_first_opt : (key -> bool) -> 'a t -> (key * 'a) option
val find_last : (key -> bool) -> 'a t -> key * 'a
val find_last_opt : (key -> bool) -> 'a t -> (key * 'a) option
val map : ('a -> 'b) -> 'a t -> 'b t
val mapi : (key -> 'a -> 'b) -> 'a t -> 'b t
val to_seq : 'a t -> (key * 'a) Seq.t
val to_seq_from : key -> 'a t -> (key * 'a) Seq.t
val add_seq : (key * 'a) Seq.t -> 'a t -> 'a t
val of_seq : (key * 'a) Seq.t -> 'a t
module Key :
sig
type t = key
val ty : t Type.t
val name : string
val descr : t Descr.t
val packed_descr : Structural_descr.pack
val reprs : t list
val equal : t -> t -> bool
val compare : t -> t -> int
val hash : t -> int
val pretty_code : Format.formatter -> t -> unit
val internal_pretty_code :
Type.precedence -> Format.formatter -> t -> unit
val pretty : Format.formatter -> t -> unit
val varname : t -> string
val mem_project : (Project_skeleton.t -> bool) -> t -> bool
val copy : t -> t
end
module Make :
functor (Data : Datatype.S) ->
sig
type t = Data.t t
val ty : t Type.t
val name : string
val descr : t Descr.t
val packed_descr : Structural_descr.pack
val reprs : t list
val equal : t -> t -> bool
val compare : t -> t -> int
val hash : t -> int
val pretty_code : Format.formatter -> t -> unit
val internal_pretty_code :
Type.precedence -> Format.formatter -> t -> unit
val pretty : Format.formatter -> t -> unit
val varname : t -> string
val mem_project : (Project_skeleton.t -> bool) -> t -> bool
val copy : t -> t
end
end
module Hashtbl :
sig
type key = t
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 -> 'b -> 'b) -> 'a t -> 'b -> 'b
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 iter_sorted :
?cmp:(key -> key -> int) -> (key -> 'a -> unit) -> 'a t -> unit
val fold_sorted :
?cmp:(key -> key -> int) ->
(key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b
val iter_sorted_by_entry :
cmp:(key * 'a -> key * 'a -> int) ->
(key -> 'a -> unit) -> 'a t -> unit
val fold_sorted_by_entry :
cmp:(key * 'a -> key * 'a -> int) ->
(key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b
val iter_sorted_by_value :
cmp:('a -> 'a -> int) -> (key -> 'a -> unit) -> 'a t -> unit
val fold_sorted_by_value :
cmp:('a -> 'a -> int) ->
(key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b
val find_opt : 'a t -> key -> 'a option
val find_def : 'a t -> key -> 'a -> 'a
val memo : 'a t -> key -> (key -> 'a) -> 'a
val structural_descr : Structural_descr.t -> Structural_descr.t
val make_type : 'a Type.t -> 'a t Type.t
module Key :
sig
type t = key
val ty : t Type.t
val name : string
val descr : t Descr.t
val packed_descr : Structural_descr.pack
val reprs : t list
val equal : t -> t -> bool
val compare : t -> t -> int
val hash : t -> int
val pretty_code : Format.formatter -> t -> unit
val internal_pretty_code :
Type.precedence -> Format.formatter -> t -> unit
val pretty : Format.formatter -> t -> unit
val varname : t -> string
val mem_project : (Project_skeleton.t -> bool) -> t -> bool
val copy : t -> t
end
module Make :
functor (Data : Datatype.S) ->
sig
type t = Data.t t
val ty : t Type.t
val name : string
val descr : t Descr.t
val packed_descr : Structural_descr.pack
val reprs : t list
val equal : t -> t -> bool
val compare : t -> t -> int
val hash : t -> int
val pretty_code : Format.formatter -> t -> unit
val internal_pretty_code :
Type.precedence -> Format.formatter -> t -> unit
val pretty : Format.formatter -> t -> unit
val varname : t -> string
val mem_project : (Project_skeleton.t -> bool) -> t -> bool
val copy : t -> t
end
end
val ty : t Type.t
val name : string
val descr : t Descr.t
val packed_descr : Structural_descr.pack
val reprs : t list
val equal : t -> t -> bool
val compare : t -> t -> int
val hash : t -> int
val pretty_code : Format.formatter -> t -> unit
val internal_pretty_code :
Type.precedence -> Format.formatter -> t -> unit
val pretty : Format.formatter -> t -> unit
val varname : t -> string
val mem_project : (Project_skeleton.t -> bool) -> t -> bool
val copy : t -> t
val join : t -> t -> t
val is_included : t -> t -> bool
val narrow : t -> t -> t
val link : t -> t -> t
val meet : t -> t -> t
val intersects : t -> t -> bool
val diff : t -> t -> t
val bottom : t
val top : t
val add : Key.t -> Value.t -> t -> t
val find : Key.t -> t -> Value.t
val find_lonely_key : t -> Key.t * Value.t
val split : Key.t -> t -> Value.t * t
val inject : Key.t -> Value.t -> t
val get_keys : t -> KSet.t
val filter_keys : (Key.t -> bool) -> t -> t
val map : (Value.t -> Value.t) -> t -> t
val fold_keys : (Key.t -> 'a -> 'a) -> t -> 'a -> 'a
val fold : (Key.t -> Value.t -> 'a -> 'a) -> t -> 'a -> 'a
val cached_fold :
cache_name:string ->
temporary:bool ->
f:(Key.t -> Value.t -> 'a) ->
projection:(Key.t -> Value.t) ->
joiner:('a -> 'a -> 'a) -> empty:'a -> t -> 'a
val for_all : (Key.t -> Value.t -> bool) -> t -> bool
val exists : (Key.t -> Value.t -> bool) -> t -> bool
val pretty_debug : Format.formatter -> t -> unit
module With_Cardinality :
functor
(KVMap : sig
val cardinal_zero_or_one : KVMap.t -> bool
val diff_if_one : KVMap.t -> KVMap.t -> KVMap.t
val fold_enum :
(KVMap.t -> 'a -> 'a) -> KVMap.t -> 'a -> 'a
val cardinal_less_than : KVMap.t -> int -> int
val find_lonely_key : KVMap.t -> Key.t * Value.t
val find_lonely_binding : KVMap.t -> Key.t * Value.t
end) ->
sig
val cardinal_zero_or_one : t -> bool
val diff_if_one : t -> t -> t
val fold_enum : (t -> 'a -> 'a) -> t -> 'a -> 'a
val cardinal_less_than : t -> int -> int
val find_lonely_binding : t -> Key.t * Value.t
end
end