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