Up
Module type
S
=
Core_map_intf.S
with
type
('a, 'b, 'c)
map
:= ('a, 'b, 'c)
t
with
type
('a, 'b, 'c)
tree
:= ('a, 'b, 'c)
Tree.t
Signature
type
('k, +'v, 'cmp) map
type
('k, +'v, 'cmp) tree
module
Key
:
Comparator.S
module
Tree
: sig .. end
type
+'a t = (
Key.t
, 'a,
Key.comparator_witness
)
map
val
t_of_sexp : (
Sexplib.Sexp.t
-> 'a) ->
Sexplib.Sexp.t
-> 'a
t
val
sexp_of_t : ('a ->
Sexplib.Sexp.t
) -> 'a
t
->
Sexplib.Sexp.t
val
compare : ('a -> 'a -> int) -> 'a
t
-> 'a
t
-> int
include
Core_map_intf.Creators_and_accessors1
with
type
'a
t
:= 'a
t
with
type
'a
tree
:= 'a
Tree.t
with
type
key
:=
Key.t
include
Core_map_intf.Creators1
type
'a t
type
'a tree
type
key
val
empty : _
t
val
singleton :
key
-> 'a -> 'a
t
val
of_alist : (
key
* 'a) list -> [
| `Ok
of
'a
t
| `Duplicate_key
of
key
]
val
of_alist_or_error : (
key
* 'a) list -> 'a
t
Or_error.t
val
of_alist_exn : (
key
* 'a) list -> 'a
t
val
of_alist_multi : (
key
* 'a) list -> 'a list
t
val
of_alist_fold : (
key
* 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b
t
val
of_alist_reduce : (
key
* 'a) list -> f:('a -> 'a -> 'a) -> 'a
t
val
of_sorted_array : (
key
* 'a) array -> 'a
t
Or_error.t
val
of_sorted_array_unchecked : (
key
* 'a) array -> 'a
t
val
of_tree : 'a
tree
-> 'a
t
val
gen :
key
Quickcheck.Generator.t
-> 'a
Quickcheck.Generator.t
-> 'a
t
Quickcheck.Generator.t
include
Core_map_intf.Accessors1
with
type
'a
t
:= 'a
t
with
type
'a
tree
:= 'a
tree
with
type
key
:=
key
type
'a t
type
'a tree
type
key
val
invariants : _
t
-> bool
val
is_empty : _
t
-> bool
val
length : _
t
-> int
val
add : 'a
t
-> key:
key
-> data:'a -> 'a
t
val
add_multi : 'a list
t
-> key:
key
-> data:'a -> 'a list
t
val
remove_multi : 'a list
t
->
key
-> 'a list
t
val
change : 'a
t
->
key
-> f:('a option -> 'a option) -> 'a
t
val
update : 'a
t
->
key
-> f:('a option -> 'a) -> 'a
t
val
find : 'a
t
->
key
-> 'a option
val
find_exn : 'a
t
->
key
-> 'a
val
remove : 'a
t
->
key
-> 'a
t
val
mem : _
t
->
key
-> bool
val
iter : 'a
t
-> f:(key:
key
-> data:'a -> unit) -> unit
val
iteri : 'a
t
-> f:(key:
key
-> data:'a -> unit) -> unit
val
iter_keys : _
t
-> f:(
key
-> unit) -> unit
val
iter2 : 'a
t
-> 'b
t
-> f:(key:
key
-> data:[
| `Left
of
'a
| `Right
of
'b
| `Both
of
'a * 'b
] -> unit) -> unit
val
map : 'a
t
-> f:('a -> 'b) -> 'b
t
val
mapi : 'a
t
-> f:(key:
key
-> data:'a -> 'b) -> 'b
t
val
fold : 'a
t
-> init:'b -> f:(key:
key
-> data:'a -> 'b -> 'b) -> 'b
val
fold_right : 'a
t
-> init:'b -> f:(key:
key
-> data:'a -> 'b -> 'b) -> 'b
val
fold2 : 'a
t
-> 'b
t
-> init:'c -> f:(key:
key
-> data:[
| `Left
of
'a
| `Right
of
'b
| `Both
of
'a * 'b
] -> 'c -> 'c) -> 'c
val
filter : 'a
t
-> f:(key:
key
-> data:'a -> bool) -> 'a
t
val
filteri : 'a
t
-> f:(key:
key
-> data:'a -> bool) -> 'a
t
val
filter_keys : 'a
t
-> f:(
key
-> bool) -> 'a
t
val
filter_map : 'a
t
-> f:('a -> 'b option) -> 'b
t
val
filter_mapi : 'a
t
-> f:(key:
key
-> data:'a -> 'b option) -> 'b
t
val
partition_mapi : 'a
t
-> f:(key:
key
-> data:'a -> [
| `Fst
of
'b
| `Snd
of
'c
]) -> 'b
t
* 'c
t
val
partition_map : 'a
t
-> f:('a -> [
| `Fst
of
'b
| `Snd
of
'c
]) -> 'b
t
* 'c
t
val
partitioni_tf : 'a
t
-> f:(key:
key
-> data:'a -> bool) -> 'a
t
* 'a
t
val
partition_tf : 'a
t
-> f:('a -> bool) -> 'a
t
* 'a
t
val
compare_direct : ('a -> 'a -> int) -> 'a
t
-> 'a
t
-> int
val
equal : ('a -> 'a -> bool) -> 'a
t
-> 'a
t
-> bool
val
keys : _
t
->
key
list
val
data : 'a
t
-> 'a list
val
to_alist : ?key_order:[
| `Increasing
| `Decreasing
] -> 'a
t
-> (
key
* 'a) list
val
validate : name:(
key
-> string) -> 'a
Validate.check
-> 'a
t
Validate.check
val
merge : 'a
t
-> 'b
t
-> f:(key:
key
-> [
| `Left
of
'a
| `Right
of
'b
| `Both
of
'a * 'b
] -> 'c option) -> 'c
t
val
symmetric_diff : 'a
t
-> 'a
t
-> data_equal:('a -> 'a -> bool) -> (
key
, 'a)
Core_map_intf.Symmetric_diff_element.t
Sequence.t
val
min_elt : 'a
t
-> (
key
* 'a) option
val
min_elt_exn : 'a
t
->
key
* 'a
val
max_elt : 'a
t
-> (
key
* 'a) option
val
max_elt_exn : 'a
t
->
key
* 'a
val
for_all : 'a
t
-> f:('a -> bool) -> bool
val
for_alli : 'a
t
-> f:(key:
key
-> data:'a -> bool) -> bool
val
exists : 'a
t
-> f:('a -> bool) -> bool
val
existsi : 'a
t
-> f:(key:
key
-> data:'a -> bool) -> bool
val
count : 'a
t
-> f:('a -> bool) -> int
val
counti : 'a
t
-> f:(key:
key
-> data:'a -> bool) -> int
val
split : 'a
t
->
key
-> 'a
t
* (
key
* 'a) option * 'a
t
val
fold_range_inclusive : 'a
t
-> min:
key
-> max:
key
-> init:'b -> f:(key:
key
-> data:'a -> 'b -> 'b) -> 'b
val
range_to_alist : 'a
t
-> min:
key
-> max:
key
-> (
key
* 'a) list
val
closest_key : 'a
t
-> [
| `Greater_or_equal_to
| `Greater_than
| `Less_or_equal_to
| `Less_than
] ->
key
-> (
key
* 'a) option
val
nth : 'a
t
-> int -> (
key
* 'a) option
val
rank : _
t
->
key
-> int option
val
to_tree : 'a
t
-> 'a
tree
val
to_sequence : ?order:[
| `Increasing_key
| `Decreasing_key
] -> ?keys_greater_or_equal_to:
key
-> ?keys_less_or_equal_to:
key
-> 'a
t
-> (
key
* 'a)
Sequence.t
val
obs :
key
Quickcheck.Observer.t
-> 'v
Quickcheck.Observer.t
-> 'v
t
Quickcheck.Observer.t
val
shrinker :
key
Quickcheck.Shrinker.t
-> 'v
Quickcheck.Shrinker.t
-> 'v
t
Quickcheck.Shrinker.t