Up  Next

Functor Map_Lattice.Make_without_cardinal

module Make_without_cardinal: 
functor (K : Key) -> 
functor (Top_Param : Lattice_type.Lattice_Hashconsed_Set  with type O.elt=K.t) -> 
functor (V : sig
include Lattice_type.Full_Lattice



val pretty_debug : t Pretty_utils.formatter
end) -> 
functor (Comp : sig


val e : bool

See Hptmap for the documentation of this option





val f : K.t -> V.t -> bool


val compose : bool -> bool -> bool


val default : bool
end) -> 
functor (L : sig


val v : (K.t * V.t) list list
end) -> sig .. end
Parameters:
K : Key
Top_Param : Lattice_type.Lattice_Hashconsed_Set with type O.elt=K.t
V : sig include Lattice_type.Full_Lattice val pretty_debug: t Pretty_utils.formatter end
Comp : sig (** See {!Hptmap} for the documentation of this option *) val e: bool val f : K.t -> V.t -> bool val compose : bool -> bool -> bool val default:bool end
L : sig val v : (K.t * V.t) list list end 
module M: Hptmap.Make(K)(V)(Comp)(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 t =
| Top of Top_Param.t * Origin.t
| Map of map_t (*
No function of this module creates a Top out of a Map. Top are always derived from an existing Top value.
*) 
val top : t
val hash : t -> int
val add_or_bottom : M.key ->
       M.v ->
       M.t ->
       M.t
val add : Top_Param.O.elt ->
       M.v ->
       t -> t
val bottom : t
val inject : M.key ->
       M.v -> t
val pretty : Format.formatter -> t -> unit
val pretty_debug : Format.formatter -> t -> unit
val find_or_bottom : M.key ->
       M.t ->
       M.v
val split : Top_Param.O.elt ->
       t ->
       M.v * t
val inject_map : map_t ->
       t
val get_bases : M.t ->
       Top_Param.O.t
exception Error_Top
val equal : t ->
       t -> bool
val compare : t ->
       t -> int
val is_bottom : t -> bool
val check_join_assert : int Pervasives.ref
val join : t ->
       t -> t
val cached_fold : cache_name:string ->
       temporary:bool ->
       f:(M.key ->
          M.v -> 'a) ->
       projection:(M.key ->
                   M.v) ->
       joiner:('a -> 'a -> 'a) ->
       empty:'a -> t -> 'a
val map_offsets : (M.v ->
        M.v) ->
       t -> t
val filter_base : (Top_Param.O.elt -> bool) ->
       t -> t
Over-approximation of the filter (in the case Top Top)
val meet : t ->
       t -> t
val narrow : t ->
       t -> t
val is_included : t ->
       t -> bool
val join_and_is_included : t ->
       t ->
       t * bool
val link : t ->
       t -> t
val intersects : t ->
       t -> bool
val find : Top_Param.O.elt ->
       t -> M.v
val find_lonely_key : t ->
       M.key *
       M.v
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 diff : t ->
       t -> t
val map_i : (M.key ->
        M.v -> t) ->
       t -> t
val fold_bases : (Top_Param.O.elt -> 'a -> 'a) ->
       t -> 'a -> 'a
val fold_i : (M.key ->
        M.v -> 'a -> 'a) ->
       t -> '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 : (M.key ->
        M.v -> 'a -> 'a) ->
       t -> 'a -> 'a
include struct ... end
val clear_caches : unit -> unit