Functor Map_Lattice.Make

module Make: 
functor (K : Key) ->
functor (Top_Param : Lattice_Set with type O.elt=K.t) ->
functor (V : Abstract_interp.Lattice_With_Diff) ->
functor (L : sig
val v : (K.t * V.t) list list
end) ->
functor (Null_Behavior : sig
val zone : bool
end) -> sig .. end
Parameters:
K : Key
Top_Param : Lattice_Set with type O.elt=K.t
V : Abstract_interp.Lattice_With_Diff
L : sig val v : (K.t * V.t) list list end
Null_Behavior : sig val zone: bool end

module M: Hptmap.Make(K)(V)(Hptmap.Comp_unused)(sig
val v : (K.t * V.t) list list
end)(sig
val l : State.t list
end)
module Top_Param: Top_Param
type map_t = M.t 
type tt = 
| Top of Top_Param.t * Origin.t
| Map of map_t
type widen_hint = Top_Param.widen_hint * (K.t -> V.widen_hint) 
val top : tt
val hash : tt -> int
val add_or_bottom : M.key -> V.t -> M.t -> M.t
val bottom : tt
val inject : M.key -> V.t -> tt
val top_int : tt
val inject_top_origin : Origin.t -> Top_Param.O.t -> tt
val is_in_set : set:Top_Param.O.t ->
Top_Param.O.elt -> bool
val pretty : Format.formatter -> tt -> unit
val find_or_bottom : M.key -> M.t -> V.t
val split : Top_Param.O.elt ->
tt -> V.t * tt
val inject_map : map_t -> tt
val get_bases : M.t -> Top_Param.O.t
exception Error_Bottom
exception Error_Top
val decide_none : 'a -> 'b -> 'b
val decide_some : V.t -> V.t -> V.t
val equal : tt -> tt -> bool
val compare : tt -> tt -> int
val is_bottom : tt -> bool
val check_join_assert : int Pervasives.ref
val join : tt -> tt -> tt
val cached_fold : cache:string * int ->
temporary:bool ->
f:(M.key -> V.t -> 'a) ->
projection:(M.key -> V.t) ->
joiner:('a -> 'a -> 'a) -> empty:'a -> tt -> 'a
val map_offsets : (V.t -> V.t) -> tt -> tt
val filter_base : (Top_Param.O.elt -> bool) ->
tt -> tt
Over-approximation of the filter (in the case Top Top)
val meet : tt -> tt -> tt
val narrow : tt -> tt -> tt
val widen : 'a * (K.t -> V.widen_hint) ->
tt -> tt -> tt
val equal : tt -> tt -> bool
val decide_fst : 'a -> 'b -> 'c
val decide_snd : 'a -> 'b -> unit
val decide_both : V.t -> V.t -> unit
val is_included_exn : tt -> tt -> unit
val check_is_included_assert : int Pervasives.ref
val is_included : tt -> tt -> bool
val link : tt -> tt -> tt
val intersects : tt -> tt -> bool
val find_lonely_key : tt -> K.t * V.t
if there is only one key k in map m, then returns the pair k,v where v is the value associated to k.
Raises Not_found otherwise.
val find_lonely_binding : tt -> K.t * V.t
if there is only one binding k -> v in map m (that is, only one key k and cardinal_zero_or_one v), returns the pair k,v.
Raises Not_found otherwise
val cardinal_zero_or_one : tt -> bool
val cardinal_less_than : tt -> int -> int
the cardinal of a map m is the sum of the cardinals of the values bound to a key in m
val splitting_cardinal_less_than : split_non_enumerable:int -> tt -> int -> int
val diff_if_one : tt -> tt -> tt
val diff : tt -> tt -> tt
val map_i : (K.t -> V.t -> tt) ->
tt -> tt
val fold_bases : (Top_Param.O.elt -> 'a -> 'a) ->
tt -> 'a -> 'a
val fold_i : (K.t -> V.t -> 'a -> 'a) -> tt -> 'a -> 'a
fold_i f m acc folds f on the bindings in m.
Raises Error_Top if m is too imprecise for folding.
val fold_topset_ok : (Top_Param.O.elt -> V.t -> 'a -> 'a) ->
tt -> 'a -> 'a
val fold_enum : split_non_enumerable:int ->
(tt -> 'a -> 'a) -> tt -> 'a -> 'a
include struct ... end
val clear_caches : unit -> unit