Map domain ordered by union over the set of bindings, so the bottom element is the empty map. Every element implicitly maps to bottom unless it is explicitly bound to something else. Uses PPMap as the underlying map

### Parameters

`ValueDomain : S`
`PPMap : InferStdlib.PrettyPrintable.PPMap`

### Signature

`include module type of PPMap with type PPMap.key = PPMap.key`
`type key``= PPMap.key```
`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 pp_key : InferStdlib.PrettyPrintable.F.formatter ‑> key ‑> unit`
`val pp : pp_value:(InferStdlib.PrettyPrintable.F.formatter ‑> 'a ‑> unit) ‑> InferStdlib.PrettyPrintable.F.formatter ‑> 'a t ‑> unit`
`include WithBottom with type astate = ValueDomain.astate t`
`include S`
`type astate`````
`val (<=) : lhs:astate ‑> rhs:astate ‑> bool`

the partial order induced by join

`val join : astate ‑> astate ‑> astate`
`val widen : prev:astate ‑> next:astate ‑> num_iters:int ‑> astate`
`val pp : F.formatter ‑> astate ‑> unit`
`val empty : astate`

The bottom value of the domain. Naming it empty instead of bottom helps to bind the empty value for sets and maps to the natural definition for bottom

`val is_empty : astate ‑> bool`

Return true if this is the bottom value