`functor
(T : T.T3) (Tree : T.T3) (Key : T.T1) (Options : T.T3) (M : sig
val invariants :
('k, 'cmp,
('k, 'v,
'cmp)
T.t ->
bool)
Options.t
val is_empty :
('a, 'b,
'c)
T.t ->
bool
val length :
('a, 'b,
'c)
T.t ->
int
val add :
('k, 'cmp,
('k, 'v,
'cmp)
T.t ->
key:
'k Key.t ->
data:'v ->
('k, 'v,
'cmp)
T.t)
Options.t
val add_multi :
('k, 'cmp,
('k,
'v list,
'cmp)
T.t ->
key:
'k Key.t ->
data:'v ->
('k,
'v list,
'cmp)
T.t)
Options.t
val change :
('k, 'cmp,
('k, 'v,
'cmp)
T.t ->
'k Key.t ->
('v option ->
'v option) ->
('k, 'v,
'cmp)
T.t)
Options.t
val find :
('k, 'cmp,
('k, 'v,
'cmp)
T.t ->
'k Key.t ->
'v option)
Options.t
val find_exn :
('k, 'cmp,
('k, 'v,
'cmp)
T.t ->
'k Key.t ->
'v)
Options.t
val remove :
('k, 'cmp,
('k, 'v,
'cmp)
T.t ->
'k Key.t ->
('k, 'v,
'cmp)
T.t)
Options.t
val mem :
('k, 'cmp,
('k, 'a,
'cmp)
T.t ->
'k Key.t ->
bool)
Options.t
val iter :
('k, 'v,
'a)
T.t ->
f:(key:
'k Key.t ->
data:'v ->
unit) ->
unit
val iter2 :
('k, 'cmp,
('k, 'v1,
'cmp)
T.t ->
('k, 'v2,
'cmp)
T.t ->
f:
(key:
'k Key.t ->
data:[
`Both of
'v1 * 'v2
| `Left of
'v1
| `Right of
'v2 ] ->
unit) ->
unit)
Options.t
val map :
('k, 'v1,
'cmp)
T.t ->
f:('v1 ->
'v2) ->
('k, 'v2,
'cmp)
T.t
val mapi :
('k, 'v1,
'cmp)
T.t ->
f:(key:
'k Key.t ->
data:'v1 ->
'v2) ->
('k, 'v2,
'cmp)
T.t
val fold :
('k, 'v,
'b)
T.t ->
init:'a ->
f:(key:
'k Key.t ->
data:'v ->
'a -> 'a) ->
'a
val fold_right :
('k, 'v,
'b)
T.t ->
init:'a ->
f:(key:
'k Key.t ->
data:'v ->
'a -> 'a) ->
'a
val filter :
('k, 'cmp,
('k, 'v,
'cmp)
T.t ->
f:
(key:
'k Key.t ->
data:'v ->
bool) ->
('k, 'v,
'cmp)
T.t)
Options.t
val filter_map :
('k, 'cmp,
('k, 'v1,
'cmp)
T.t ->
f:
('v1 ->
'v2
option) ->
('k, 'v2,
'cmp)
T.t)
Options.t
val filter_mapi :
('k, 'cmp,
('k, 'v1,
'cmp)
T.t ->
f:
(key:
'k Key.t ->
data:'v1 ->
'v2
option) ->
('k, 'v2,
'cmp)
T.t)
Options.t
val compare_direct :
('k, 'cmp,
('v ->
'v -> int) ->
('k, 'v,
'cmp)
T.t ->
('k, 'v,
'cmp)
T.t ->
int)
Options.t
val equal :
('k, 'cmp,
('v ->
'v ->
bool) ->
('k, 'v,
'cmp)
T.t ->
('k, 'v,
'cmp)
T.t ->
bool)
Options.t
val keys :
('k, 'a,
'b)
T.t ->
'k Key.t
list
val data :
('a, 'v,
'b)
T.t ->
'v list
val to_alist :
('k, 'v,
'a)
T.t ->
('k Key.t *
'v)
list
val validate :
name:
('k Key.t ->
string) ->
'v
Validate.check ->
('k, 'v,
'a)
T.t
Validate.check
val merge :
('k, 'cmp,
('k, 'v1,
'cmp)
T.t ->
('k, 'v2,
'cmp)
T.t ->
f:
(key:
'k Key.t ->
[
`Both of
'v1 * 'v2
| `Left of
'v1
| `Right of
'v2 ] ->
'v3
option) ->
('k, 'v3,
'cmp)
T.t)
Options.t
val symmetric_diff :
('k, 'cmp,
('k, 'v,
'cmp)
T.t ->
('k, 'v,
'cmp)
T.t ->
data_equal:
('v ->
'v ->
bool) ->
('k Key.t *
[
`Left of
'v
| `Right of
'v
| `Unequal of
'v * 'v ])
Sequence.t)
Options.t
val min_elt :
('k, 'v,
'a)
T.t ->
('k Key.t *
'v)
option
val min_elt_exn :
('k, 'v,
'a)
T.t ->
'k Key.t *
'v
val max_elt :
('k, 'v,
'a)
T.t ->
('k Key.t *
'v)
option
val max_elt_exn :
('k, 'v,
'a)
T.t ->
'k Key.t *
'v
val for_all :
('k, 'v,
'a)
T.t ->
f:('v ->
bool) ->
bool
val exists :
('k, 'v,
'a)
T.t ->
f:('v ->
bool) ->
bool
val split :
('k, 'cmp,
('k, 'v,
'cmp)
T.t ->
'k Key.t ->
('k, 'v,
'cmp)
T.t *
('k Key.t *
'v)
option *
('k, 'v,
'cmp)
T.t)
Options.t
val fold_range_inclusive :
('k, 'cmp,
('k, 'v,
'cmp)
T.t ->
min:
'k Key.t ->
max:
'k Key.t ->
init:'a ->
f:
(key:
'k Key.t ->
data:'v ->
'a -> 'a) ->
'a)
Options.t
val range_to_alist :
('k, 'cmp,
('k, 'v,
'cmp)
T.t ->
min:
'k Key.t ->
max:
'k Key.t ->
('k Key.t *
'v)
list)
Options.t
val closest_key :
('k, 'cmp,
('k, 'v,
'cmp)
T.t ->
[
`Greater_or_equal_to
| `Greater_than
| `Less_or_equal_to
| `Less_than ] ->
'k Key.t ->
('k Key.t *
'v)
option)
Options.t
val nth :
('k, 'cmp,
('k, 'v,
'cmp)
T.t ->
int ->
('k Key.t *
'v)
option)
Options.t
val rank :
('k, 'cmp,
('k, 'a,
'cmp)
T.t ->
'k Key.t ->
int option)
Options.t
val to_tree :
('k, 'v,
'cmp)
T.t ->
('k Key.t,
'v, 'cmp)
Tree.t
val to_sequence :
('k, 'cmp,
?order:[
`Decreasing_key
| `Increasing_key ] ->
?keys_greater_or_equal_to:
'k Key.t ->
?keys_less_or_equal_to:
'k Key.t ->
('k, 'v,
'cmp)
T.t ->
('k Key.t *
'v)
Sequence.t)
Options.t
end) ->
sig end`