Module type Core_map_intf.Accessors

module type Accessors = sig .. end

type ('a, 'b, 'comparator) t 
type 'a key 
val is_empty : ('a, 'b, 'c) t -> bool
Test whether a map is empty or not.
val length : ('a, 'b, 'c) t -> int
length map
Returns number of elements in map.
val add : ('k, 'v, 'comparator) t ->
key:'k key ->
data:'v -> ('k, 'v, 'comparator) t
returns a new map with the specified new binding; if the key was already bound, its previous binding disappears.
val add_multi : ('k, 'v list, 'comparator) t ->
key:'k key ->
data:'v -> ('k, 'v list, 'comparator) t
if key is not present then add a singleton list, otherwise, cons data on the head of the existing list.
val change : ('k, 'v, 'comparator) t ->
'k key ->
('v option -> 'v option) -> ('k, 'v, 'comparator) t
change map key f updates the given map by changing the value stored under key according to f. Thus, for example, one might write:

change m k (function None -> Some 0 | Some x -> Some (x + 1))

to produce a new map where the integer stored under key k is incremented by one (treating an unknown key as zero)

val find : ('k, 'v, 'a) t ->
'k key -> 'v option
returns the value bound to the given key, raising Not_found if none such exists
val find_exn : ('k, 'v, 'a) t ->
'k key -> 'v
val remove : ('k, 'v, 'comparator) t ->
'k key ->
('k, 'v, 'comparator) t
returns a new map with any binding for the key in question removed
val mem : ('k, 'a, 'b) t ->
'k key -> bool
mem key map tests whether map contains a binding for key
val iter : ('k, 'v, 'a) t ->
f:(key:'k key -> data:'v -> unit) -> unit
iterator for map
val map : ('k, 'v1, 'comparator) t ->
f:('v1 -> 'v2) -> ('k, 'v2, 'comparator) t
returns new map with bound values replaced by f applied to the bound values
val mapi : ('k, 'v1, 'comparator) t ->
f:(key:'k key -> data:'v1 -> 'v2) ->
('k, 'v2, 'comparator) t
like map, but function takes both key and data as arguments
val fold : ('k, 'v, 'b) t ->
init:'a ->
f:(key:'k key -> data:'v -> 'a -> 'a) -> 'a
folds over keys and data in map
val fold_right : ('k, 'v, 'b) t ->
init:'a ->
f:(key:'k key -> data:'v -> 'a -> 'a) -> 'a
folds over keys and data in map in reverse order
val filter : ('k, 'v, 'comparator) t ->
f:(key:'k key -> data:'v -> bool) ->
('k, 'v, 'comparator) t
val filter_map : ('k, 'v1, 'comparator) t ->
f:('v1 -> 'v2 option) -> ('k, 'v2, 'comparator) t
returns new map with bound values filtered by f applied to the bound values
val filter_mapi : ('k, 'v1, 'comparator) t ->
f:(key:'k key -> data:'v1 -> 'v2 option) ->
('k, 'v2, 'comparator) t
like filter_map, but function takes both key and data as arguments
val compare : ('v -> 'v -> int) ->
('k, 'v, 'comparator) t ->
('k, 'v, 'comparator) t -> int
Total ordering between maps. The first argument is a total ordering used to compare data associated with equal keys in the two maps.
val equal : ('v -> 'v -> bool) ->
('k, 'v, 'comparator) t ->
('k, 'v, 'comparator) t -> bool
equal cmp m1 m2 tests whether the maps m1 and m2 are equal, that is, contain equal keys and associate them with equal data. cmp is the equality predicate used to compare the data associated with the keys.
val keys : ('k, 'a, 'b) t -> 'k key list
returns list of keys in map
val data : ('a, 'v, 'b) t -> 'v list
returns list of data in map
val to_alist : ('k, 'v, 'a) t ->
('k key * 'v) list
creates association list from map. No guarantee about order.

Additional operations on maps

val merge : ('k, 'v1, 'comparator) t ->
('k, 'v2, 'comparator) t ->
f:(key:'k key ->
[ `Both of 'v1 * 'v2 | `Left of 'v1 | `Right of 'v2 ] -> 'v3 option) ->
('k, 'v3, 'comparator) t
merges two maps
val min_elt : ('k, 'v, 'a) t ->
('k key * 'v) option
min_elt map
Returns Some (key, data) pair corresponding to the minimum key in map, None if empty.
val min_elt_exn : ('k, 'v, 'a) t -> 'k key * 'v
val max_elt : ('k, 'v, 'a) t ->
('k key * 'v) option
max_elt map
Returns Some (key, data) pair corresponding to the maximum key in map, and None if map is empty.
val max_elt_exn : ('k, 'v, 'a) t -> 'k key * 'v
val for_all : ('k, 'v, 'a) t -> f:('v -> bool) -> bool
same semantics as similar functions in List
val exists : ('k, 'v, 'a) t -> f:('v -> bool) -> bool
val fold_range_inclusive : ('k, 'v, 'b) t ->
min:'k key ->
max:'k key ->
init:'a ->
f:(key:'k key -> data:'v -> 'a -> 'a) -> 'a
fold_range_inclusive t ~min ~max ~init ~f folds f (with initial value ~init) over all keys (and their associated values) that are in the range min, max (inclusive).
val range_to_alist : ('k, 'v, 'a) t ->
min:'k key ->
max:'k key ->
('k key * 'v) list
range_to_alist t ~min ~max returns an associative list of the elements whose keys lie in min, max (inclusive), with the smallest key being at the head of the list.
val prev_key : ('k, 'v, 'a) t ->
'k key ->
('k key * 'v) option
prev_key t k returns the largest (key, value) pair in t with key less than k

next_key t k returns the smallest (key, value) pair in t with key greater than k

val next_key : ('k, 'v, 'a) t ->
'k key ->
('k key * 'v) option
rank t k if k is in t, returns the number of keys strictly less than k in t, otherwise None
val rank : ('k, 'a, 'b) t ->
'k key -> int option
type ('a, 'b, 'comparator) tree 
tree t returns the underlying binary tree that represents the map. This is useful if you want to marshal a map between processes. Since the set contains a closure, it cannot be marshalled between processes that use different executables; however, the underlying tree can, so long as the tree type hasn't changed.
val to_tree : ('k, 'v, 'comparator) t ->
('k key, 'v, 'comparator)
tree