sig
module type Value =
sig
type 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
val top : t
val bottom : t
end
module type Lattice =
sig
type 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
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
end
module type Lattice_with_cardinality =
sig
type t
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
end
module type Map_Lattice =
sig
type key
type v
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 filter_map : (elt -> elt option) -> 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 filter_map : (key -> 'a -> 'b option) -> 'a t -> 'b 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
val partition_with_shape : 'a shape -> t -> 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 replace_key :
decide:(key -> v -> v -> v) -> key shape -> t -> bool * t
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
module type Map_Lattice_with_cardinality =
sig
type t
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
type key
type v
val find_lonely_key :
t ->
Map_lattice.Map_Lattice_with_cardinality.key *
Map_lattice.Map_Lattice_with_cardinality.v
val find_lonely_binding :
t ->
Map_lattice.Map_Lattice_with_cardinality.key *
Map_lattice.Map_Lattice_with_cardinality.v
end
module type MapSet_Lattice =
sig
type set
type map
type t =
Top of Map_lattice.MapSet_Lattice.set * Origin.t
| Map of Map_lattice.MapSet_Lattice.map
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 filter_map : (elt -> elt option) -> 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 filter_map : (key -> 'a -> 'b option) -> 'a t -> 'b 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 : Map_lattice.MapSet_Lattice.t
val top : Map_lattice.MapSet_Lattice.t
type key
type v
val add :
Map_lattice.MapSet_Lattice.key ->
Map_lattice.MapSet_Lattice.v ->
Map_lattice.MapSet_Lattice.t -> Map_lattice.MapSet_Lattice.t
val find :
Map_lattice.MapSet_Lattice.key ->
Map_lattice.MapSet_Lattice.t -> Map_lattice.MapSet_Lattice.v
val find_lonely_key :
Map_lattice.MapSet_Lattice.t ->
Map_lattice.MapSet_Lattice.key * Map_lattice.MapSet_Lattice.v
val split :
Map_lattice.MapSet_Lattice.key ->
Map_lattice.MapSet_Lattice.t ->
Map_lattice.MapSet_Lattice.v * Map_lattice.MapSet_Lattice.t
val inject :
Map_lattice.MapSet_Lattice.key ->
Map_lattice.MapSet_Lattice.v -> Map_lattice.MapSet_Lattice.t
val get_keys :
Map_lattice.MapSet_Lattice.t -> Map_lattice.MapSet_Lattice.set
val filter_keys :
(Map_lattice.MapSet_Lattice.key -> bool) ->
Map_lattice.MapSet_Lattice.t -> Map_lattice.MapSet_Lattice.t
val map :
(Map_lattice.MapSet_Lattice.v -> Map_lattice.MapSet_Lattice.v) ->
Map_lattice.MapSet_Lattice.t -> Map_lattice.MapSet_Lattice.t
val fold_keys :
(Map_lattice.MapSet_Lattice.key -> 'a -> 'a) ->
Map_lattice.MapSet_Lattice.t -> 'a -> 'a
val fold :
(Map_lattice.MapSet_Lattice.key ->
Map_lattice.MapSet_Lattice.v -> 'a -> 'a) ->
Map_lattice.MapSet_Lattice.t -> 'a -> 'a
val cached_fold :
cache_name:string ->
temporary:bool ->
f:(Map_lattice.MapSet_Lattice.key ->
Map_lattice.MapSet_Lattice.v -> 'a) ->
projection:(Map_lattice.MapSet_Lattice.key ->
Map_lattice.MapSet_Lattice.v) ->
joiner:('a -> 'a -> 'a) ->
empty:'a -> Map_lattice.MapSet_Lattice.t -> 'a
val for_all :
(Map_lattice.MapSet_Lattice.key ->
Map_lattice.MapSet_Lattice.v -> bool) ->
Map_lattice.MapSet_Lattice.t -> bool
val exists :
(Map_lattice.MapSet_Lattice.key ->
Map_lattice.MapSet_Lattice.v -> bool) ->
Map_lattice.MapSet_Lattice.t -> bool
val pretty_debug :
Stdlib.Format.formatter -> Map_lattice.MapSet_Lattice.t -> unit
end
module type MapSet_Lattice_with_cardinality =
sig
type t
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
type key
type v
val find_lonely_binding :
t ->
Map_lattice.MapSet_Lattice_with_cardinality.key *
Map_lattice.MapSet_Lattice_with_cardinality.v
end
module Make_Map_Lattice :
functor (Key : Hptmap.Id_Datatype) (Value : Lattice_type.Full_Lattice)
(KVMap : sig
type key = Key.t
type v = Value.t
type 'a shape
type prefix
type 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
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 filter_map : (elt -> elt option) -> 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 filter_map :
(key -> 'a -> 'b option) -> 'a t -> 'b 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 join :
cache:Hptmap_sig.cache_type ->
symmetric:bool ->
idempotent:bool ->
decide:(key -> v -> v -> 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
val partition_with_shape : 'a shape -> t -> 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 replace_key :
decide:(key -> v -> v -> v) -> key shape -> t -> bool * t
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
end)
->
sig
type key = Key.t
type v = Value.t
type 'a shape
type prefix
type t = 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 filter_map : (elt -> elt option) -> 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 filter_map : (key -> 'a -> 'b option) -> 'a t -> 'b 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
val partition_with_shape : 'a shape -> t -> 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 replace_key :
decide:(key -> v -> v -> v) -> key shape -> t -> bool * t
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
module With_Cardinality :
functor (K : sig val is_summary : Key.t -> bool end)
(Value : sig
val ty : Value.t Type.t
val name : string
val descr : Value.t Descr.t
val packed_descr : Structural_descr.pack
val reprs : Value.t list
val equal : Value.t -> Value.t -> bool
val compare : Value.t -> Value.t -> int
val hash : Value.t -> int
val pretty_code : Format.formatter -> Value.t -> unit
val internal_pretty_code :
Type.precedence ->
Format.formatter -> Value.t -> unit
val pretty : Format.formatter -> Value.t -> unit
val varname : Value.t -> string
val mem_project :
(Project_skeleton.t -> bool) -> Value.t -> bool
val copy : Value.t -> Value.t
val join : Value.t -> Value.t -> Value.t
val is_included : Value.t -> Value.t -> bool
val bottom : Value.t
val top : Value.t
type widen_hint
val widen :
widen_hint -> Value.t -> Value.t -> Value.t
val cardinal_zero_or_one : Value.t -> bool
val narrow : Value.t -> Value.t -> Value.t
val link : Value.t -> Value.t -> Value.t
val meet : Value.t -> Value.t -> Value.t
val intersects : Value.t -> Value.t -> bool
val diff : Value.t -> Value.t -> Value.t
val diff_if_one : Value.t -> Value.t -> Value.t
val fold_enum :
(Value.t -> 'a -> 'a) -> Value.t -> 'a -> 'a
val cardinal_less_than : Value.t -> int -> int
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_key : t -> key * v
val find_lonely_binding : t -> key * v
end
end
module Make_MapSet_Lattice :
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 filter_map : (elt -> elt option) -> 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 filter_map :
(key -> 'a -> 'b option) -> 'a t -> 'b 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
val partition_with_shape : 'a shape -> t -> 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 replace_key :
decide:(key -> v -> v -> v) -> key shape -> t -> bool * t
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 filter_map : (elt -> elt option) -> 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 filter_map : (key -> 'a -> 'b option) -> 'a t -> 'b 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
end