`sig
module Tree :
sig
type ('k, +'v, 'cmp) t
val empty : comparator:('a, 'cmp) Comparator.t -> ('a, 'b, '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 -> [ `Duplicate_key of 'a | `Ok of ('a, 'b, 'cmp) t ]
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) t -> ('a, 'b, 'cmp) t
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 change :
comparator:('a, 'cmp) Comparator.t ->
('a, 'b, 'cmp) t ->
'a -> ('b option -> 'b option) -> ('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 iter2 :
comparator:('a, 'cmp) Comparator.t ->
('a, 'b, 'cmp) t ->
('a, 'c, 'cmp) t ->
f:(key:'a ->
data:[ `Both of 'b * 'c | `Left of 'b | `Right of '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, 'd) t -> init:'c -> f:(key:'a -> data:'b -> 'c -> 'c) -> 'c
val fold_right :
('a, 'b, 'd) t -> init:'c -> f:(key:'a -> data:'b -> 'c -> 'c) -> 'c
val filter :
comparator:('a, 'cmp) Comparator.t ->
('a, 'b, 'cmp) t -> f:(key:'a -> data:'b -> 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 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, 'b, 'c) t -> 'a list
val data : ('a, 'b, 'c) t -> 'b list
val to_alist : ('a, 'b, 'c) t -> ('a * 'b) list
val validate :
name:('a -> string) ->
'b Validate.check -> ('a, 'b, 'c) t Validate.check
val merge :
comparator:('a, 'cmp) Comparator.t ->
('a, 'b, 'cmp) t ->
('a, 'c, 'cmp) t ->
f:(key:'a ->
[ `Both of 'b * 'c | `Left of 'b | `Right of '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 * [ `Left of 'b | `Right of 'b | `Unequal of 'b * 'b ])
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 exists : ('a, 'b, 'cmp) t -> f:('b -> bool) -> bool
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) t
val to_sequence :
comparator:('a, 'cmp) Comparator.t ->
?order:[ `Decreasing_key | `Increasing_key ] ->
?keys_greater_or_equal_to:'a ->
?keys_less_or_equal_to:'a -> ('a, 'b, 'cmp) t -> ('a * 'b) Sequence.t
val sexp_of_t :
('k -> Sexplib.Sexp.t) ->
('v -> Sexplib.Sexp.t) ->
('cmp -> Sexplib.Sexp.t) ->
('k, 'v, 'cmp) Core_map.Tree.t -> Sexplib.Sexp.t
end
type ('key, +'value, 'cmp) t
val invariants : ('a, 'b, 'c) Core_map.t -> bool
val comparator : ('a, 'b, 'cmp) Core_map.t -> ('a, 'cmp) Comparator.t
val empty : comparator:('a, 'cmp) Comparator.t -> ('a, 'b, 'cmp) Core_map.t
val singleton :
comparator:('a, 'cmp) Comparator.t ->
'a -> 'b -> ('a, 'b, 'cmp) Core_map.t
val of_alist :
comparator:('a, 'cmp) Comparator.t ->
('a * 'b) list ->
[ `Duplicate_key of 'a | `Ok of ('a, 'b, 'cmp) Core_map.t ]
val of_alist_or_error :
comparator:('a, 'cmp) Comparator.t ->
('a * 'b) list -> ('a, 'b, 'cmp) Core_map.t Or_error.t
val of_alist_exn :
comparator:('a, 'cmp) Comparator.t ->
('a * 'b) list -> ('a, 'b, 'cmp) Core_map.t
val of_alist_multi :
comparator:('a, 'cmp) Comparator.t ->
('a * 'b) list -> ('a, 'b list, 'cmp) Core_map.t
val of_alist_fold :
comparator:('a, 'cmp) Comparator.t ->
('a * 'b) list ->
init:'c -> f:('c -> 'b -> 'c) -> ('a, 'c, 'cmp) Core_map.t
val of_alist_reduce :
comparator:('a, 'cmp) Comparator.t ->
('a * 'b) list -> f:('b -> 'b -> 'b) -> ('a, 'b, 'cmp) Core_map.t
val to_tree : ('k, 'v, 'cmp) Core_map.t -> ('k, 'v, 'cmp) Core_map.Tree.t
val of_tree :
comparator:('k, 'cmp) Comparator.t ->
('k, 'v, 'cmp) Core_map.Tree.t -> ('k, 'v, 'cmp) Core_map.t
val of_sorted_array :
comparator:('a, 'cmp) Comparator.t ->
('a * 'b) array -> ('a, 'b, 'cmp) Core_map.t Or_error.t
val of_sorted_array_unchecked :
comparator:('a, 'cmp) Comparator.t ->
('a * 'b) array -> ('a, 'b, 'cmp) Core_map.t
val is_empty : ('a, 'b, 'c) Core_map.t -> bool
val length : ('a, 'b, 'c) Core_map.t -> int
val add :
('k, 'v, 'cmp) Core_map.t ->
key:'k -> data:'v -> ('k, 'v, 'cmp) Core_map.t
val add_multi :
('k, 'v list, 'cmp) Core_map.t ->
key:'k -> data:'v -> ('k, 'v list, 'cmp) Core_map.t
val change :
('k, 'v, 'cmp) Core_map.t ->
'k -> ('v option -> 'v option) -> ('k, 'v, 'cmp) Core_map.t
val find : ('k, 'v, 'cmp) Core_map.t -> 'k -> 'v option
val find_exn : ('k, 'v, 'cmp) Core_map.t -> 'k -> 'v
val remove : ('k, 'v, 'cmp) Core_map.t -> 'k -> ('k, 'v, 'cmp) Core_map.t
val mem : ('k, 'a, 'cmp) Core_map.t -> 'k -> bool
val iter : ('k, 'v, 'a) Core_map.t -> f:(key:'k -> data:'v -> unit) -> unit
val iter2 :
('k, 'v1, 'cmp) Core_map.t ->
('k, 'v2, 'cmp) Core_map.t ->
f:(key:'k ->
data:[ `Both of 'v1 * 'v2 | `Left of 'v1 | `Right of 'v2 ] -> unit) ->
unit
val map :
('k, 'v1, 'cmp) Core_map.t ->
f:('v1 -> 'v2) -> ('k, 'v2, 'cmp) Core_map.t
val mapi :
('k, 'v1, 'cmp) Core_map.t ->
f:(key:'k -> data:'v1 -> 'v2) -> ('k, 'v2, 'cmp) Core_map.t
val fold :
('k, 'v, 'b) Core_map.t ->
init:'a -> f:(key:'k -> data:'v -> 'a -> 'a) -> 'a
val fold_right :
('k, 'v, 'b) Core_map.t ->
init:'a -> f:(key:'k -> data:'v -> 'a -> 'a) -> 'a
val filter :
('k, 'v, 'cmp) Core_map.t ->
f:(key:'k -> data:'v -> bool) -> ('k, 'v, 'cmp) Core_map.t
val filter_map :
('k, 'v1, 'cmp) Core_map.t ->
f:('v1 -> 'v2 option) -> ('k, 'v2, 'cmp) Core_map.t
val filter_mapi :
('k, 'v1, 'cmp) Core_map.t ->
f:(key:'k -> data:'v1 -> 'v2 option) -> ('k, 'v2, 'cmp) Core_map.t
val compare_direct :
('v -> 'v -> int) ->
('k, 'v, 'cmp) Core_map.t -> ('k, 'v, 'cmp) Core_map.t -> int
val equal :
('v -> 'v -> bool) ->
('k, 'v, 'cmp) Core_map.t -> ('k, 'v, 'cmp) Core_map.t -> bool
val keys : ('k, 'a, 'b) Core_map.t -> 'k list
val data : ('a, 'v, 'b) Core_map.t -> 'v list
val to_alist : ('k, 'v, 'a) Core_map.t -> ('k * 'v) list
val validate :
name:('k -> string) ->
'v Validate.check -> ('k, 'v, 'a) Core_map.t Validate.check
val merge :
('k, 'v1, 'cmp) Core_map.t ->
('k, 'v2, 'cmp) Core_map.t ->
f:(key:'k ->
[ `Both of 'v1 * 'v2 | `Left of 'v1 | `Right of 'v2 ] -> 'v3 option) ->
('k, 'v3, 'cmp) Core_map.t
val symmetric_diff :
('k, 'v, 'cmp) Core_map.t ->
('k, 'v, 'cmp) Core_map.t ->
data_equal:('v -> 'v -> bool) ->
('k * [ `Left of 'v | `Right of 'v | `Unequal of 'v * 'v ]) Sequence.t
val min_elt : ('k, 'v, 'a) Core_map.t -> ('k * 'v) option
val min_elt_exn : ('k, 'v, 'a) Core_map.t -> 'k * 'v
val max_elt : ('k, 'v, 'a) Core_map.t -> ('k * 'v) option
val max_elt_exn : ('k, 'v, 'a) Core_map.t -> 'k * 'v
val for_all : ('k, 'v, 'a) Core_map.t -> f:('v -> bool) -> bool
val exists : ('k, 'v, 'a) Core_map.t -> f:('v -> bool) -> bool
val split :
('k, 'v, 'cmp) Core_map.t ->
'k ->
('k, 'v, 'cmp) Core_map.t * ('k * 'v) option * ('k, 'v, 'cmp) Core_map.t
val fold_range_inclusive :
('k, 'v, 'cmp) Core_map.t ->
min:'k -> max:'k -> init:'a -> f:(key:'k -> data:'v -> 'a -> 'a) -> 'a
val range_to_alist :
('k, 'v, 'cmp) Core_map.t -> min:'k -> max:'k -> ('k * 'v) list
val closest_key :
('k, 'v, 'cmp) Core_map.t ->
[ `Greater_or_equal_to | `Greater_than | `Less_or_equal_to | `Less_than ] ->
'k -> ('k * 'v) option
val nth : ('k, 'v, 'a) Core_map.t -> int -> ('k * 'v) option
val rank : ('k, 'v, 'cmp) Core_map.t -> 'k -> int option
val to_sequence :
?order:[ `Decreasing_key | `Increasing_key ] ->
?keys_greater_or_equal_to:'k ->
?keys_less_or_equal_to:'k ->
('k, 'v, 'cmp) Core_map.t -> ('k * 'v) Sequence.t
module Poly :
sig
type ('a, 'b, 'c) map = ('a, 'b, 'c) Core_map.t
module Tree :
sig
type ('k, 'v) t =
('k, 'v, Comparator.Poly.comparator_witness) Core_map.Tree.t
val empty : ('a, 'b) t
val singleton : 'a -> 'b -> ('a, 'b) t
val of_alist :
('a * 'b) list -> [ `Duplicate_key of 'a | `Ok of ('a, 'b) t ]
val of_alist_or_error : ('a * 'b) list -> ('a, 'b) t Or_error.t
val of_alist_exn : ('a * 'b) list -> ('a, 'b) t
val of_alist_multi : ('a * 'b) list -> ('a, 'b list) t
val of_alist_fold :
('a * 'b) list -> init:'c -> f:('c -> 'b -> 'c) -> ('a, 'c) t
val of_alist_reduce :
('a * 'b) list -> f:('b -> 'b -> 'b) -> ('a, 'b) t
val of_sorted_array : ('a * 'b) array -> ('a, 'b) t Or_error.t
val of_sorted_array_unchecked : ('a * 'b) array -> ('a, 'b) t
val of_tree : ('a, 'b) t -> ('a, 'b) t
val invariants : ('a, 'b) t -> bool
val is_empty : ('a, 'b) t -> bool
val length : ('a, 'b) t -> int
val add : ('a, 'b) t -> key:'a -> data:'b -> ('a, 'b) t
val add_multi :
('a, 'b list) t -> key:'a -> data:'b -> ('a, 'b list) t
val change :
('a, 'b) t -> 'a -> ('b option -> 'b option) -> ('a, 'b) t
val find : ('a, 'b) t -> 'a -> 'b option
val find_exn : ('a, 'b) t -> 'a -> 'b
val remove : ('a, 'b) t -> 'a -> ('a, 'b) t
val mem : ('a, 'b) t -> 'a -> bool
val iter : ('a, 'b) t -> f:(key:'a -> data:'b -> unit) -> unit
val iter2 :
('a, 'b) t ->
('a, 'c) t ->
f:(key:'a ->
data:[ `Both of 'b * 'c | `Left of 'b | `Right of 'c ] -> unit) ->
unit
val map : ('a, 'b) t -> f:('b -> 'c) -> ('a, 'c) t
val mapi : ('a, 'b) t -> f:(key:'a -> data:'b -> 'c) -> ('a, 'c) 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 filter :
('a, 'b) t -> f:(key:'a -> data:'b -> bool) -> ('a, 'b) t
val filter_map : ('a, 'b) t -> f:('b -> 'c option) -> ('a, 'c) t
val filter_mapi :
('a, 'b) t -> f:(key:'a -> data:'b -> 'c option) -> ('a, 'c) t
val compare_direct :
('b -> 'b -> int) -> ('a, 'b) t -> ('a, 'b) t -> int
val equal : ('b -> 'b -> bool) -> ('a, 'b) t -> ('a, 'b) t -> bool
val keys : ('a, 'b) t -> 'a list
val data : ('a, 'b) t -> 'b list
val to_alist : ('a, 'b) t -> ('a * 'b) list
val validate :
name:('a -> string) ->
'b Validate.check -> ('a, 'b) t Validate.check
val merge :
('a, 'b) t ->
('a, 'c) t ->
f:(key:'a ->
[ `Both of 'b * 'c | `Left of 'b | `Right of 'c ] -> 'd option) ->
('a, 'd) t
val symmetric_diff :
('a, 'b) t ->
('a, 'b) t ->
data_equal:('b -> 'b -> bool) ->
('a * [ `Left of 'b | `Right of 'b | `Unequal of 'b * 'b ])
Sequence.t
val min_elt : ('a, 'b) t -> ('a * 'b) option
val min_elt_exn : ('a, 'b) t -> 'a * 'b
val max_elt : ('a, 'b) t -> ('a * 'b) option
val max_elt_exn : ('a, 'b) t -> 'a * 'b
val for_all : ('a, 'b) t -> f:('b -> bool) -> bool
val exists : ('a, 'b) t -> f:('b -> bool) -> bool
val split :
('a, 'b) t -> 'a -> ('a, 'b) t * ('a * 'b) option * ('a, 'b) t
val fold_range_inclusive :
('a, 'b) t ->
min:'a ->
max:'a -> init:'c -> f:(key:'a -> data:'b -> 'c -> 'c) -> 'c
val range_to_alist :
('a, 'b) t -> min:'a -> max:'a -> ('a * 'b) list
val closest_key :
('a, 'b) t ->
[ `Greater_or_equal_to
| `Greater_than
| `Less_or_equal_to
| `Less_than ] -> 'a -> ('a * 'b) option
val nth : ('a, 'b) t -> int -> ('a * 'b) option
val rank : ('a, 'b) t -> 'a -> int option
val to_tree : ('a, 'b) t -> ('a, 'b) t
val to_sequence :
?order:[ `Decreasing_key | `Increasing_key ] ->
?keys_greater_or_equal_to:'a ->
?keys_less_or_equal_to:'a -> ('a, 'b) t -> ('a * 'b) Sequence.t
val t_of_sexp :
(Sexplib.Sexp.t -> 'k) ->
(Sexplib.Sexp.t -> 'v) ->
Sexplib.Sexp.t -> ('k, 'v) Core_map.Poly.Tree.t
val sexp_of_t :
('k -> Sexplib.Sexp.t) ->
('v -> Sexplib.Sexp.t) ->
('k, 'v) Core_map.Poly.Tree.t -> Sexplib.Sexp.t
end
type ('a, 'b) t =
('a, 'b, Comparator.Poly.comparator_witness) Core_map.Poly.map
val empty : ('a, 'b) t
val singleton : 'a -> 'b -> ('a, 'b) t
val of_alist :
('a * 'b) list -> [ `Duplicate_key of 'a | `Ok of ('a, 'b) t ]
val of_alist_or_error : ('a * 'b) list -> ('a, 'b) t Or_error.t
val of_alist_exn : ('a * 'b) list -> ('a, 'b) t
val of_alist_multi : ('a * 'b) list -> ('a, 'b list) t
val of_alist_fold :
('a * 'b) list -> init:'c -> f:('c -> 'b -> 'c) -> ('a, 'c) t
val of_alist_reduce :
('a * 'b) list -> f:('b -> 'b -> 'b) -> ('a, 'b) t
val of_sorted_array : ('a * 'b) array -> ('a, 'b) t Or_error.t
val of_sorted_array_unchecked : ('a * 'b) array -> ('a, 'b) t
val of_tree : ('a, 'b) Tree.t -> ('a, 'b) t
val invariants : ('a, 'b) t -> bool
val is_empty : ('a, 'b) t -> bool
val length : ('a, 'b) t -> int
val add : ('a, 'b) t -> key:'a -> data:'b -> ('a, 'b) t
val add_multi : ('a, 'b list) t -> key:'a -> data:'b -> ('a, 'b list) t
val change : ('a, 'b) t -> 'a -> ('b option -> 'b option) -> ('a, 'b) t
val find : ('a, 'b) t -> 'a -> 'b option
val find_exn : ('a, 'b) t -> 'a -> 'b
val remove : ('a, 'b) t -> 'a -> ('a, 'b) t
val mem : ('a, 'b) t -> 'a -> bool
val iter : ('a, 'b) t -> f:(key:'a -> data:'b -> unit) -> unit
val iter2 :
('a, 'b) t ->
('a, 'c) t ->
f:(key:'a ->
data:[ `Both of 'b * 'c | `Left of 'b | `Right of 'c ] -> unit) ->
unit
val map : ('a, 'b) t -> f:('b -> 'c) -> ('a, 'c) t
val mapi : ('a, 'b) t -> f:(key:'a -> data:'b -> 'c) -> ('a, 'c) 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 filter : ('a, 'b) t -> f:(key:'a -> data:'b -> bool) -> ('a, 'b) t
val filter_map : ('a, 'b) t -> f:('b -> 'c option) -> ('a, 'c) t
val filter_mapi :
('a, 'b) t -> f:(key:'a -> data:'b -> 'c option) -> ('a, 'c) t
val compare_direct :
('b -> 'b -> int) -> ('a, 'b) t -> ('a, 'b) t -> int
val equal : ('b -> 'b -> bool) -> ('a, 'b) t -> ('a, 'b) t -> bool
val keys : ('a, 'b) t -> 'a list
val data : ('a, 'b) t -> 'b list
val to_alist : ('a, 'b) t -> ('a * 'b) list
val validate :
name:('a -> string) -> 'b Validate.check -> ('a, 'b) t Validate.check
val merge :
('a, 'b) t ->
('a, 'c) t ->
f:(key:'a ->
[ `Both of 'b * 'c | `Left of 'b | `Right of 'c ] -> 'd option) ->
('a, 'd) t
val symmetric_diff :
('a, 'b) t ->
('a, 'b) t ->
data_equal:('b -> 'b -> bool) ->
('a * [ `Left of 'b | `Right of 'b | `Unequal of 'b * 'b ])
Sequence.t
val min_elt : ('a, 'b) t -> ('a * 'b) option
val min_elt_exn : ('a, 'b) t -> 'a * 'b
val max_elt : ('a, 'b) t -> ('a * 'b) option
val max_elt_exn : ('a, 'b) t -> 'a * 'b
val for_all : ('a, 'b) t -> f:('b -> bool) -> bool
val exists : ('a, 'b) t -> f:('b -> bool) -> bool
val split :
('a, 'b) t -> 'a -> ('a, 'b) t * ('a * 'b) option * ('a, 'b) t
val fold_range_inclusive :
('a, 'b) t ->
min:'a ->
max:'a -> init:'c -> f:(key:'a -> data:'b -> 'c -> 'c) -> 'c
val range_to_alist : ('a, 'b) t -> min:'a -> max:'a -> ('a * 'b) list
val closest_key :
('a, 'b) t ->
[ `Greater_or_equal_to
| `Greater_than
| `Less_or_equal_to
| `Less_than ] -> 'a -> ('a * 'b) option
val nth : ('a, 'b) t -> int -> ('a * 'b) option
val rank : ('a, 'b) t -> 'a -> int option
val to_tree : ('a, 'b) t -> ('a, 'b) Tree.t
val to_sequence :
?order:[ `Decreasing_key | `Increasing_key ] ->
?keys_greater_or_equal_to:'a ->
?keys_less_or_equal_to:'a -> ('a, 'b) t -> ('a * 'b) Sequence.t
val compare :
('a -> 'a -> int) ->
('b -> 'b -> int) ->
('a, 'b) Core_map.Poly.t -> ('a, 'b) Core_map.Poly.t -> int
val t_of_sexp :
(Sexplib.Sexp.t -> 'a) ->
(Sexplib.Sexp.t -> 'b) -> Sexplib.Sexp.t -> ('a, 'b) Core_map.Poly.t
val sexp_of_t :
('a -> Sexplib.Sexp.t) ->
('b -> Sexplib.Sexp.t) -> ('a, 'b) Core_map.Poly.t -> Sexplib.Sexp.t
val bin_t :
'a Bin_prot.Type_class.t ->
'b Bin_prot.Type_class.t ->
('a, 'b) Core_map.Poly.t Bin_prot.Type_class.t
val bin_read_t :
'a Bin_prot.Read.reader ->
'b Bin_prot.Read.reader ->
('a, 'b) Core_map.Poly.t Bin_prot.Read.reader
val __bin_read_t__ :
'a Bin_prot.Read.reader ->
'b Bin_prot.Read.reader ->
(int -> ('a, 'b) Core_map.Poly.t) Bin_prot.Read.reader
val bin_reader_t :
'a Bin_prot.Type_class.reader ->
'b Bin_prot.Type_class.reader ->
('a, 'b) Core_map.Poly.t Bin_prot.Type_class.reader
val bin_size_t :
'a Bin_prot.Size.sizer ->
'b Bin_prot.Size.sizer ->
('a, 'b) Core_map.Poly.t Bin_prot.Size.sizer
val bin_write_t :
'a Bin_prot.Write.writer ->
'b Bin_prot.Write.writer ->
('a, 'b) Core_map.Poly.t Bin_prot.Write.writer
val bin_writer_t :
'a Bin_prot.Type_class.writer ->
'b Bin_prot.Type_class.writer ->
('a, 'b) Core_map.Poly.t Bin_prot.Type_class.writer
end
module type Key = Core_map_intf.Key
module type Key_binable = Core_map_intf.Key_binable
module type S =
sig
module Key : Comparator.S
module Tree :
sig
type 'a t = (Key.t, 'a, Key.comparator_witness) Tree.t
val empty : 'a t
val singleton : Key.t -> 'a -> 'a t
val of_alist :
(Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ]
val of_alist_or_error : (Key.t * 'a) list -> 'a t Or_error.t
val of_alist_exn : (Key.t * 'a) list -> 'a t
val of_alist_multi : (Key.t * 'a) list -> 'a list t
val of_alist_fold :
(Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t
val of_alist_reduce :
(Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t
val of_sorted_array : (Key.t * 'a) array -> 'a t Or_error.t
val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t
val of_tree : 'a t -> 'a t
val invariants : 'a t -> bool
val is_empty : 'a t -> bool
val length : 'a t -> int
val add : 'a t -> key:Key.t -> data:'a -> 'a t
val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t
val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t
val find : 'a t -> Key.t -> 'a option
val find_exn : 'a t -> Key.t -> 'a
val remove : 'a t -> Key.t -> 'a t
val mem : 'a t -> Key.t -> bool
val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit
val iter2 :
'a t ->
'b t ->
f:(key:Key.t ->
data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) ->
unit
val map : 'a t -> f:('a -> 'b) -> 'b t
val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t
val fold :
'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
val fold_right :
'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t
val filter_map : 'a t -> f:('a -> 'b option) -> 'b t
val filter_mapi :
'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t
val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int
val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool
val keys : 'a t -> Key.t list
val data : 'a t -> 'a list
val to_alist : 'a t -> (Key.t * 'a) list
val validate :
name:(Key.t -> string) ->
'a Validate.check -> 'a t Validate.check
val merge :
'a t ->
'b t ->
f:(key:Key.t ->
[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) ->
'c t
val symmetric_diff :
'a t ->
'a t ->
data_equal:('a -> 'a -> bool) ->
(Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ])
Sequence.t
val min_elt : 'a t -> (Key.t * 'a) option
val min_elt_exn : 'a t -> Key.t * 'a
val max_elt : 'a t -> (Key.t * 'a) option
val max_elt_exn : 'a t -> Key.t * 'a
val for_all : 'a t -> f:('a -> bool) -> bool
val exists : 'a t -> f:('a -> bool) -> bool
val split : 'a t -> Key.t -> 'a t * (Key.t * 'a) option * 'a t
val fold_range_inclusive :
'a t ->
min:Key.t ->
max:Key.t ->
init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
val range_to_alist :
'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list
val closest_key :
'a t ->
[ `Greater_or_equal_to
| `Greater_than
| `Less_or_equal_to
| `Less_than ] -> Key.t -> (Key.t * 'a) option
val nth : 'a t -> int -> (Key.t * 'a) option
val rank : 'a t -> Key.t -> int option
val to_tree : 'a t -> 'a t
val to_sequence :
?order:[ `Decreasing_key | `Increasing_key ] ->
?keys_greater_or_equal_to:Key.t ->
?keys_less_or_equal_to:Key.t -> 'a t -> (Key.t * 'a) Sequence.t
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
end
type 'a t = (Key.t, 'a, Key.comparator_witness) t
val empty : 'a t
val singleton : Key.t -> 'a -> 'a t
val of_alist :
(Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ]
val of_alist_or_error : (Key.t * 'a) list -> 'a t Or_error.t
val of_alist_exn : (Key.t * 'a) list -> 'a t
val of_alist_multi : (Key.t * 'a) list -> 'a list t
val of_alist_fold :
(Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t
val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t
val of_sorted_array : (Key.t * 'a) array -> 'a t Or_error.t
val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t
val of_tree : 'a Tree.t -> 'a t
val invariants : 'a t -> bool
val is_empty : 'a t -> bool
val length : 'a t -> int
val add : 'a t -> key:Key.t -> data:'a -> 'a t
val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t
val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t
val find : 'a t -> Key.t -> 'a option
val find_exn : 'a t -> Key.t -> 'a
val remove : 'a t -> Key.t -> 'a t
val mem : 'a t -> Key.t -> bool
val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit
val iter2 :
'a t ->
'b t ->
f:(key:Key.t ->
data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) ->
unit
val map : 'a t -> f:('a -> 'b) -> 'b t
val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t
val fold :
'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
val fold_right :
'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t
val filter_map : 'a t -> f:('a -> 'b option) -> 'b t
val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t
val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int
val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool
val keys : 'a t -> Key.t list
val data : 'a t -> 'a list
val to_alist : 'a t -> (Key.t * 'a) list
val validate :
name:(Key.t -> string) -> 'a Validate.check -> 'a t Validate.check
val merge :
'a t ->
'b t ->
f:(key:Key.t ->
[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) ->
'c t
val symmetric_diff :
'a t ->
'a t ->
data_equal:('a -> 'a -> bool) ->
(Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ])
Sequence.t
val min_elt : 'a t -> (Key.t * 'a) option
val min_elt_exn : 'a t -> Key.t * 'a
val max_elt : 'a t -> (Key.t * 'a) option
val max_elt_exn : 'a t -> Key.t * 'a
val for_all : 'a t -> f:('a -> bool) -> bool
val exists : 'a t -> f:('a -> bool) -> bool
val split : 'a t -> Key.t -> 'a t * (Key.t * 'a) option * 'a t
val fold_range_inclusive :
'a t ->
min:Key.t ->
max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
val range_to_alist :
'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list
val closest_key :
'a t ->
[ `Greater_or_equal_to
| `Greater_than
| `Less_or_equal_to
| `Less_than ] -> Key.t -> (Key.t * 'a) option
val nth : 'a t -> int -> (Key.t * 'a) option
val rank : 'a t -> Key.t -> int option
val to_tree : 'a t -> 'a Tree.t
val to_sequence :
?order:[ `Decreasing_key | `Increasing_key ] ->
?keys_greater_or_equal_to:Key.t ->
?keys_less_or_equal_to:Key.t -> 'a t -> (Key.t * 'a) Sequence.t
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
end
module type S_binable =
sig
module Key : Comparator.S
module Tree :
sig
type 'a t = (Key.t, 'a, Key.comparator_witness) Tree.t
val empty : 'a t
val singleton : Key.t -> 'a -> 'a t
val of_alist :
(Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ]
val of_alist_or_error : (Key.t * 'a) list -> 'a t Or_error.t
val of_alist_exn : (Key.t * 'a) list -> 'a t
val of_alist_multi : (Key.t * 'a) list -> 'a list t
val of_alist_fold :
(Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t
val of_alist_reduce :
(Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t
val of_sorted_array : (Key.t * 'a) array -> 'a t Or_error.t
val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t
val of_tree : 'a t -> 'a t
val invariants : 'a t -> bool
val is_empty : 'a t -> bool
val length : 'a t -> int
val add : 'a t -> key:Key.t -> data:'a -> 'a t
val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t
val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t
val find : 'a t -> Key.t -> 'a option
val find_exn : 'a t -> Key.t -> 'a
val remove : 'a t -> Key.t -> 'a t
val mem : 'a t -> Key.t -> bool
val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit
val iter2 :
'a t ->
'b t ->
f:(key:Key.t ->
data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) ->
unit
val map : 'a t -> f:('a -> 'b) -> 'b t
val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t
val fold :
'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
val fold_right :
'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t
val filter_map : 'a t -> f:('a -> 'b option) -> 'b t
val filter_mapi :
'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t
val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int
val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool
val keys : 'a t -> Key.t list
val data : 'a t -> 'a list
val to_alist : 'a t -> (Key.t * 'a) list
val validate :
name:(Key.t -> string) ->
'a Validate.check -> 'a t Validate.check
val merge :
'a t ->
'b t ->
f:(key:Key.t ->
[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) ->
'c t
val symmetric_diff :
'a t ->
'a t ->
data_equal:('a -> 'a -> bool) ->
(Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ])
Sequence.t
val min_elt : 'a t -> (Key.t * 'a) option
val min_elt_exn : 'a t -> Key.t * 'a
val max_elt : 'a t -> (Key.t * 'a) option
val max_elt_exn : 'a t -> Key.t * 'a
val for_all : 'a t -> f:('a -> bool) -> bool
val exists : 'a t -> f:('a -> bool) -> bool
val split : 'a t -> Key.t -> 'a t * (Key.t * 'a) option * 'a t
val fold_range_inclusive :
'a t ->
min:Key.t ->
max:Key.t ->
init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
val range_to_alist :
'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list
val closest_key :
'a t ->
[ `Greater_or_equal_to
| `Greater_than
| `Less_or_equal_to
| `Less_than ] -> Key.t -> (Key.t * 'a) option
val nth : 'a t -> int -> (Key.t * 'a) option
val rank : 'a t -> Key.t -> int option
val to_tree : 'a t -> 'a t
val to_sequence :
?order:[ `Decreasing_key | `Increasing_key ] ->
?keys_greater_or_equal_to:Key.t ->
?keys_less_or_equal_to:Key.t -> 'a t -> (Key.t * 'a) Sequence.t
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
end
type 'a t = (Key.t, 'a, Key.comparator_witness) t
val empty : 'a t
val singleton : Key.t -> 'a -> 'a t
val of_alist :
(Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ]
val of_alist_or_error : (Key.t * 'a) list -> 'a t Or_error.t
val of_alist_exn : (Key.t * 'a) list -> 'a t
val of_alist_multi : (Key.t * 'a) list -> 'a list t
val of_alist_fold :
(Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t
val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t
val of_sorted_array : (Key.t * 'a) array -> 'a t Or_error.t
val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t
val of_tree : 'a Tree.t -> 'a t
val invariants : 'a t -> bool
val is_empty : 'a t -> bool
val length : 'a t -> int
val add : 'a t -> key:Key.t -> data:'a -> 'a t
val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t
val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t
val find : 'a t -> Key.t -> 'a option
val find_exn : 'a t -> Key.t -> 'a
val remove : 'a t -> Key.t -> 'a t
val mem : 'a t -> Key.t -> bool
val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit
val iter2 :
'a t ->
'b t ->
f:(key:Key.t ->
data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) ->
unit
val map : 'a t -> f:('a -> 'b) -> 'b t
val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t
val fold :
'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
val fold_right :
'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t
val filter_map : 'a t -> f:('a -> 'b option) -> 'b t
val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t
val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int
val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool
val keys : 'a t -> Key.t list
val data : 'a t -> 'a list
val to_alist : 'a t -> (Key.t * 'a) list
val validate :
name:(Key.t -> string) -> 'a Validate.check -> 'a t Validate.check
val merge :
'a t ->
'b t ->
f:(key:Key.t ->
[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) ->
'c t
val symmetric_diff :
'a t ->
'a t ->
data_equal:('a -> 'a -> bool) ->
(Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ])
Sequence.t
val min_elt : 'a t -> (Key.t * 'a) option
val min_elt_exn : 'a t -> Key.t * 'a
val max_elt : 'a t -> (Key.t * 'a) option
val max_elt_exn : 'a t -> Key.t * 'a
val for_all : 'a t -> f:('a -> bool) -> bool
val exists : 'a t -> f:('a -> bool) -> bool
val split : 'a t -> Key.t -> 'a t * (Key.t * 'a) option * 'a t
val fold_range_inclusive :
'a t ->
min:Key.t ->
max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
val range_to_alist :
'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list
val closest_key :
'a t ->
[ `Greater_or_equal_to
| `Greater_than
| `Less_or_equal_to
| `Less_than ] -> Key.t -> (Key.t * 'a) option
val nth : 'a t -> int -> (Key.t * 'a) option
val rank : 'a t -> Key.t -> int option
val to_tree : 'a t -> 'a Tree.t
val to_sequence :
?order:[ `Decreasing_key | `Increasing_key ] ->
?keys_greater_or_equal_to:Key.t ->
?keys_less_or_equal_to:Key.t -> 'a t -> (Key.t * 'a) Sequence.t
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
val bin_size_t : ('a, 'a t) Bin_prot.Size.sizer1
val bin_write_t : ('a, 'a t) Bin_prot.Write.writer1
val bin_read_t : ('a, 'a t) Bin_prot.Read.reader1
val __bin_read_t__ : ('a, int -> 'a t) Bin_prot.Read.reader1
val bin_writer_t : ('a, 'a t) Bin_prot.Type_class.S1.writer
val bin_reader_t : ('a, 'a t) Bin_prot.Type_class.S1.reader
val bin_t : ('a, 'a t) Bin_prot.Type_class.S1.t
end
module Make :
functor (Key : Key) ->
sig
module Key :
sig
type t = Key.t
type comparator_witness
val comparator : (t, comparator_witness) Comparator.comparator
end
module Tree :
sig
type 'a t = (Key.t, 'a, Key.comparator_witness) Tree.t
val empty : 'a t
val singleton : Key.t -> 'a -> 'a t
val of_alist :
(Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ]
val of_alist_or_error : (Key.t * 'a) list -> 'a t Or_error.t
val of_alist_exn : (Key.t * 'a) list -> 'a t
val of_alist_multi : (Key.t * 'a) list -> 'a list t
val of_alist_fold :
(Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t
val of_alist_reduce :
(Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t
val of_sorted_array : (Key.t * 'a) array -> 'a t Or_error.t
val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t
val of_tree : 'a t -> 'a t
val invariants : 'a t -> bool
val is_empty : 'a t -> bool
val length : 'a t -> int
val add : 'a t -> key:Key.t -> data:'a -> 'a t
val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t
val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t
val find : 'a t -> Key.t -> 'a option
val find_exn : 'a t -> Key.t -> 'a
val remove : 'a t -> Key.t -> 'a t
val mem : 'a t -> Key.t -> bool
val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit
val iter2 :
'a t ->
'b t ->
f:(key:Key.t ->
data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
unit) ->
unit
val map : 'a t -> f:('a -> 'b) -> 'b t
val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t
val fold :
'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
val fold_right :
'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t
val filter_map : 'a t -> f:('a -> 'b option) -> 'b t
val filter_mapi :
'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t
val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int
val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool
val keys : 'a t -> Key.t list
val data : 'a t -> 'a list
val to_alist : 'a t -> (Key.t * 'a) list
val validate :
name:(Key.t -> string) ->
'a Validate.check -> 'a t Validate.check
val merge :
'a t ->
'b t ->
f:(key:Key.t ->
[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
'c option) ->
'c t
val symmetric_diff :
'a t ->
'a t ->
data_equal:('a -> 'a -> bool) ->
(Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ])
Sequence.t
val min_elt : 'a t -> (Key.t * 'a) option
val min_elt_exn : 'a t -> Key.t * 'a
val max_elt : 'a t -> (Key.t * 'a) option
val max_elt_exn : 'a t -> Key.t * 'a
val for_all : 'a t -> f:('a -> bool) -> bool
val exists : 'a t -> f:('a -> bool) -> bool
val split : 'a t -> Key.t -> 'a t * (Key.t * 'a) option * 'a t
val fold_range_inclusive :
'a t ->
min:Key.t ->
max:Key.t ->
init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
val range_to_alist :
'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list
val closest_key :
'a t ->
[ `Greater_or_equal_to
| `Greater_than
| `Less_or_equal_to
| `Less_than ] -> Key.t -> (Key.t * 'a) option
val nth : 'a t -> int -> (Key.t * 'a) option
val rank : 'a t -> Key.t -> int option
val to_tree : 'a t -> 'a t
val to_sequence :
?order:[ `Decreasing_key | `Increasing_key ] ->
?keys_greater_or_equal_to:Key.t ->
?keys_less_or_equal_to:Key.t -> 'a t -> (Key.t * 'a) Sequence.t
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
end
type 'a t = (Key.t, 'a, Key.comparator_witness) t
val empty : 'a t
val singleton : Key.t -> 'a -> 'a t
val of_alist :
(Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ]
val of_alist_or_error : (Key.t * 'a) list -> 'a t Or_error.t
val of_alist_exn : (Key.t * 'a) list -> 'a t
val of_alist_multi : (Key.t * 'a) list -> 'a list t
val of_alist_fold :
(Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t
val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t
val of_sorted_array : (Key.t * 'a) array -> 'a t Or_error.t
val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t
val of_tree : 'a Tree.t -> 'a t
val invariants : 'a t -> bool
val is_empty : 'a t -> bool
val length : 'a t -> int
val add : 'a t -> key:Key.t -> data:'a -> 'a t
val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t
val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t
val find : 'a t -> Key.t -> 'a option
val find_exn : 'a t -> Key.t -> 'a
val remove : 'a t -> Key.t -> 'a t
val mem : 'a t -> Key.t -> bool
val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit
val iter2 :
'a t ->
'b t ->
f:(key:Key.t ->
data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) ->
unit
val map : 'a t -> f:('a -> 'b) -> 'b t
val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t
val fold :
'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
val fold_right :
'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t
val filter_map : 'a t -> f:('a -> 'b option) -> 'b t
val filter_mapi :
'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t
val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int
val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool
val keys : 'a t -> Key.t list
val data : 'a t -> 'a list
val to_alist : 'a t -> (Key.t * 'a) list
val validate :
name:(Key.t -> string) -> 'a Validate.check -> 'a t Validate.check
val merge :
'a t ->
'b t ->
f:(key:Key.t ->
[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) ->
'c t
val symmetric_diff :
'a t ->
'a t ->
data_equal:('a -> 'a -> bool) ->
(Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ])
Sequence.t
val min_elt : 'a t -> (Key.t * 'a) option
val min_elt_exn : 'a t -> Key.t * 'a
val max_elt : 'a t -> (Key.t * 'a) option
val max_elt_exn : 'a t -> Key.t * 'a
val for_all : 'a t -> f:('a -> bool) -> bool
val exists : 'a t -> f:('a -> bool) -> bool
val split : 'a t -> Key.t -> 'a t * (Key.t * 'a) option * 'a t
val fold_range_inclusive :
'a t ->
min:Key.t ->
max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
val range_to_alist :
'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list
val closest_key :
'a t ->
[ `Greater_or_equal_to
| `Greater_than
| `Less_or_equal_to
| `Less_than ] -> Key.t -> (Key.t * 'a) option
val nth : 'a t -> int -> (Key.t * 'a) option
val rank : 'a t -> Key.t -> int option
val to_tree : 'a t -> 'a Tree.t
val to_sequence :
?order:[ `Decreasing_key | `Increasing_key ] ->
?keys_greater_or_equal_to:Key.t ->
?keys_less_or_equal_to:Key.t -> 'a t -> (Key.t * 'a) Sequence.t
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
end
module Make_using_comparator :
functor
(Key : sig
type t
type comparator_witness
val comparator : (t, comparator_witness) Comparator.comparator
val t_of_sexp :
Sexplib.Sexp.t -> Core_map.Make_using_comparator.t
val sexp_of_t :
Core_map.Make_using_comparator.t -> Sexplib.Sexp.t
end) ->
sig
module Key :
sig
type t = Key.t
type comparator_witness = Key.comparator_witness
val comparator : (t, comparator_witness) Comparator.comparator
end
module Tree :
sig
type 'a t = (Key.t, 'a, Key.comparator_witness) Tree.t
val empty : 'a t
val singleton : Key.t -> 'a -> 'a t
val of_alist :
(Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ]
val of_alist_or_error : (Key.t * 'a) list -> 'a t Or_error.t
val of_alist_exn : (Key.t * 'a) list -> 'a t
val of_alist_multi : (Key.t * 'a) list -> 'a list t
val of_alist_fold :
(Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t
val of_alist_reduce :
(Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t
val of_sorted_array : (Key.t * 'a) array -> 'a t Or_error.t
val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t
val of_tree : 'a t -> 'a t
val invariants : 'a t -> bool
val is_empty : 'a t -> bool
val length : 'a t -> int
val add : 'a t -> key:Key.t -> data:'a -> 'a t
val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t
val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t
val find : 'a t -> Key.t -> 'a option
val find_exn : 'a t -> Key.t -> 'a
val remove : 'a t -> Key.t -> 'a t
val mem : 'a t -> Key.t -> bool
val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit
val iter2 :
'a t ->
'b t ->
f:(key:Key.t ->
data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
unit) ->
unit
val map : 'a t -> f:('a -> 'b) -> 'b t
val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t
val fold :
'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
val fold_right :
'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t
val filter_map : 'a t -> f:('a -> 'b option) -> 'b t
val filter_mapi :
'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t
val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int
val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool
val keys : 'a t -> Key.t list
val data : 'a t -> 'a list
val to_alist : 'a t -> (Key.t * 'a) list
val validate :
name:(Key.t -> string) ->
'a Validate.check -> 'a t Validate.check
val merge :
'a t ->
'b t ->
f:(key:Key.t ->
[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
'c option) ->
'c t
val symmetric_diff :
'a t ->
'a t ->
data_equal:('a -> 'a -> bool) ->
(Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ])
Sequence.t
val min_elt : 'a t -> (Key.t * 'a) option
val min_elt_exn : 'a t -> Key.t * 'a
val max_elt : 'a t -> (Key.t * 'a) option
val max_elt_exn : 'a t -> Key.t * 'a
val for_all : 'a t -> f:('a -> bool) -> bool
val exists : 'a t -> f:('a -> bool) -> bool
val split : 'a t -> Key.t -> 'a t * (Key.t * 'a) option * 'a t
val fold_range_inclusive :
'a t ->
min:Key.t ->
max:Key.t ->
init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
val range_to_alist :
'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list
val closest_key :
'a t ->
[ `Greater_or_equal_to
| `Greater_than
| `Less_or_equal_to
| `Less_than ] -> Key.t -> (Key.t * 'a) option
val nth : 'a t -> int -> (Key.t * 'a) option
val rank : 'a t -> Key.t -> int option
val to_tree : 'a t -> 'a t
val to_sequence :
?order:[ `Decreasing_key | `Increasing_key ] ->
?keys_greater_or_equal_to:Key.t ->
?keys_less_or_equal_to:Key.t -> 'a t -> (Key.t * 'a) Sequence.t
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
end
type 'a t = (Key.t, 'a, Key.comparator_witness) t
val empty : 'a t
val singleton : Key.t -> 'a -> 'a t
val of_alist :
(Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ]
val of_alist_or_error : (Key.t * 'a) list -> 'a t Or_error.t
val of_alist_exn : (Key.t * 'a) list -> 'a t
val of_alist_multi : (Key.t * 'a) list -> 'a list t
val of_alist_fold :
(Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t
val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t
val of_sorted_array : (Key.t * 'a) array -> 'a t Or_error.t
val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t
val of_tree : 'a Tree.t -> 'a t
val invariants : 'a t -> bool
val is_empty : 'a t -> bool
val length : 'a t -> int
val add : 'a t -> key:Key.t -> data:'a -> 'a t
val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t
val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t
val find : 'a t -> Key.t -> 'a option
val find_exn : 'a t -> Key.t -> 'a
val remove : 'a t -> Key.t -> 'a t
val mem : 'a t -> Key.t -> bool
val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit
val iter2 :
'a t ->
'b t ->
f:(key:Key.t ->
data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) ->
unit
val map : 'a t -> f:('a -> 'b) -> 'b t
val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t
val fold :
'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
val fold_right :
'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t
val filter_map : 'a t -> f:('a -> 'b option) -> 'b t
val filter_mapi :
'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t
val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int
val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool
val keys : 'a t -> Key.t list
val data : 'a t -> 'a list
val to_alist : 'a t -> (Key.t * 'a) list
val validate :
name:(Key.t -> string) -> 'a Validate.check -> 'a t Validate.check
val merge :
'a t ->
'b t ->
f:(key:Key.t ->
[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) ->
'c t
val symmetric_diff :
'a t ->
'a t ->
data_equal:('a -> 'a -> bool) ->
(Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ])
Sequence.t
val min_elt : 'a t -> (Key.t * 'a) option
val min_elt_exn : 'a t -> Key.t * 'a
val max_elt : 'a t -> (Key.t * 'a) option
val max_elt_exn : 'a t -> Key.t * 'a
val for_all : 'a t -> f:('a -> bool) -> bool
val exists : 'a t -> f:('a -> bool) -> bool
val split : 'a t -> Key.t -> 'a t * (Key.t * 'a) option * 'a t
val fold_range_inclusive :
'a t ->
min:Key.t ->
max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
val range_to_alist :
'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list
val closest_key :
'a t ->
[ `Greater_or_equal_to
| `Greater_than
| `Less_or_equal_to
| `Less_than ] -> Key.t -> (Key.t * 'a) option
val nth : 'a t -> int -> (Key.t * 'a) option
val rank : 'a t -> Key.t -> int option
val to_tree : 'a t -> 'a Tree.t
val to_sequence :
?order:[ `Decreasing_key | `Increasing_key ] ->
?keys_greater_or_equal_to:Key.t ->
?keys_less_or_equal_to:Key.t -> 'a t -> (Key.t * 'a) Sequence.t
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
end
module Make_binable :
functor (Key : Key_binable) ->
sig
module Key :
sig
type t = Key.t
type comparator_witness
val comparator : (t, comparator_witness) Comparator.comparator
end
module Tree :
sig
type 'a t = (Key.t, 'a, Key.comparator_witness) Tree.t
val empty : 'a t
val singleton : Key.t -> 'a -> 'a t
val of_alist :
(Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ]
val of_alist_or_error : (Key.t * 'a) list -> 'a t Or_error.t
val of_alist_exn : (Key.t * 'a) list -> 'a t
val of_alist_multi : (Key.t * 'a) list -> 'a list t
val of_alist_fold :
(Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t
val of_alist_reduce :
(Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t
val of_sorted_array : (Key.t * 'a) array -> 'a t Or_error.t
val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t
val of_tree : 'a t -> 'a t
val invariants : 'a t -> bool
val is_empty : 'a t -> bool
val length : 'a t -> int
val add : 'a t -> key:Key.t -> data:'a -> 'a t
val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t
val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t
val find : 'a t -> Key.t -> 'a option
val find_exn : 'a t -> Key.t -> 'a
val remove : 'a t -> Key.t -> 'a t
val mem : 'a t -> Key.t -> bool
val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit
val iter2 :
'a t ->
'b t ->
f:(key:Key.t ->
data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
unit) ->
unit
val map : 'a t -> f:('a -> 'b) -> 'b t
val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t
val fold :
'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
val fold_right :
'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t
val filter_map : 'a t -> f:('a -> 'b option) -> 'b t
val filter_mapi :
'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t
val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int
val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool
val keys : 'a t -> Key.t list
val data : 'a t -> 'a list
val to_alist : 'a t -> (Key.t * 'a) list
val validate :
name:(Key.t -> string) ->
'a Validate.check -> 'a t Validate.check
val merge :
'a t ->
'b t ->
f:(key:Key.t ->
[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
'c option) ->
'c t
val symmetric_diff :
'a t ->
'a t ->
data_equal:('a -> 'a -> bool) ->
(Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ])
Sequence.t
val min_elt : 'a t -> (Key.t * 'a) option
val min_elt_exn : 'a t -> Key.t * 'a
val max_elt : 'a t -> (Key.t * 'a) option
val max_elt_exn : 'a t -> Key.t * 'a
val for_all : 'a t -> f:('a -> bool) -> bool
val exists : 'a t -> f:('a -> bool) -> bool
val split : 'a t -> Key.t -> 'a t * (Key.t * 'a) option * 'a t
val fold_range_inclusive :
'a t ->
min:Key.t ->
max:Key.t ->
init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
val range_to_alist :
'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list
val closest_key :
'a t ->
[ `Greater_or_equal_to
| `Greater_than
| `Less_or_equal_to
| `Less_than ] -> Key.t -> (Key.t * 'a) option
val nth : 'a t -> int -> (Key.t * 'a) option
val rank : 'a t -> Key.t -> int option
val to_tree : 'a t -> 'a t
val to_sequence :
?order:[ `Decreasing_key | `Increasing_key ] ->
?keys_greater_or_equal_to:Key.t ->
?keys_less_or_equal_to:Key.t -> 'a t -> (Key.t * 'a) Sequence.t
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
end
type 'a t = (Key.t, 'a, Key.comparator_witness) t
val empty : 'a t
val singleton : Key.t -> 'a -> 'a t
val of_alist :
(Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ]
val of_alist_or_error : (Key.t * 'a) list -> 'a t Or_error.t
val of_alist_exn : (Key.t * 'a) list -> 'a t
val of_alist_multi : (Key.t * 'a) list -> 'a list t
val of_alist_fold :
(Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t
val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t
val of_sorted_array : (Key.t * 'a) array -> 'a t Or_error.t
val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t
val of_tree : 'a Tree.t -> 'a t
val invariants : 'a t -> bool
val is_empty : 'a t -> bool
val length : 'a t -> int
val add : 'a t -> key:Key.t -> data:'a -> 'a t
val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t
val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t
val find : 'a t -> Key.t -> 'a option
val find_exn : 'a t -> Key.t -> 'a
val remove : 'a t -> Key.t -> 'a t
val mem : 'a t -> Key.t -> bool
val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit
val iter2 :
'a t ->
'b t ->
f:(key:Key.t ->
data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) ->
unit
val map : 'a t -> f:('a -> 'b) -> 'b t
val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t
val fold :
'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
val fold_right :
'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t
val filter_map : 'a t -> f:('a -> 'b option) -> 'b t
val filter_mapi :
'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t
val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int
val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool
val keys : 'a t -> Key.t list
val data : 'a t -> 'a list
val to_alist : 'a t -> (Key.t * 'a) list
val validate :
name:(Key.t -> string) -> 'a Validate.check -> 'a t Validate.check
val merge :
'a t ->
'b t ->
f:(key:Key.t ->
[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) ->
'c t
val symmetric_diff :
'a t ->
'a t ->
data_equal:('a -> 'a -> bool) ->
(Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ])
Sequence.t
val min_elt : 'a t -> (Key.t * 'a) option
val min_elt_exn : 'a t -> Key.t * 'a
val max_elt : 'a t -> (Key.t * 'a) option
val max_elt_exn : 'a t -> Key.t * 'a
val for_all : 'a t -> f:('a -> bool) -> bool
val exists : 'a t -> f:('a -> bool) -> bool
val split : 'a t -> Key.t -> 'a t * (Key.t * 'a) option * 'a t
val fold_range_inclusive :
'a t ->
min:Key.t ->
max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
val range_to_alist :
'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list
val closest_key :
'a t ->
[ `Greater_or_equal_to
| `Greater_than
| `Less_or_equal_to
| `Less_than ] -> Key.t -> (Key.t * 'a) option
val nth : 'a t -> int -> (Key.t * 'a) option
val rank : 'a t -> Key.t -> int option
val to_tree : 'a t -> 'a Tree.t
val to_sequence :
?order:[ `Decreasing_key | `Increasing_key ] ->
?keys_greater_or_equal_to:Key.t ->
?keys_less_or_equal_to:Key.t -> 'a t -> (Key.t * 'a) Sequence.t
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
val bin_size_t : ('a, 'a t) Bin_prot.Size.sizer1
val bin_write_t : ('a, 'a t) Bin_prot.Write.writer1
val bin_read_t : ('a, 'a t) Bin_prot.Read.reader1
val __bin_read_t__ : ('a, int -> 'a t) Bin_prot.Read.reader1
val bin_writer_t : ('a, 'a t) Bin_prot.Type_class.S1.writer
val bin_reader_t : ('a, 'a t) Bin_prot.Type_class.S1.reader
val bin_t : ('a, 'a t) Bin_prot.Type_class.S1.t
end
module Make_binable_using_comparator :
functor
(Key : sig
type t
type comparator_witness
val comparator : (t, comparator_witness) Comparator.comparator
val t_of_sexp :
Sexplib.Sexp.t -> Core_map.Make_binable_using_comparator.t
val sexp_of_t :
Core_map.Make_binable_using_comparator.t -> Sexplib.Sexp.t
val bin_t :
Core_map.Make_binable_using_comparator.t
Bin_prot.Type_class.t
val bin_read_t :
Core_map.Make_binable_using_comparator.t
Bin_prot.Read.reader
val __bin_read_t__ :
(int -> Core_map.Make_binable_using_comparator.t)
Bin_prot.Read.reader
val bin_reader_t :
Core_map.Make_binable_using_comparator.t
Bin_prot.Type_class.reader
val bin_size_t :
Core_map.Make_binable_using_comparator.t Bin_prot.Size.sizer
val bin_write_t :
Core_map.Make_binable_using_comparator.t
Bin_prot.Write.writer
val bin_writer_t :
Core_map.Make_binable_using_comparator.t
Bin_prot.Type_class.writer
end) ->
sig
module Key :
sig
type t = Key.t
type comparator_witness = Key.comparator_witness
val comparator : (t, comparator_witness) Comparator.comparator
end
module Tree :
sig
type 'a t = (Key.t, 'a, Key.comparator_witness) Tree.t
val empty : 'a t
val singleton : Key.t -> 'a -> 'a t
val of_alist :
(Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ]
val of_alist_or_error : (Key.t * 'a) list -> 'a t Or_error.t
val of_alist_exn : (Key.t * 'a) list -> 'a t
val of_alist_multi : (Key.t * 'a) list -> 'a list t
val of_alist_fold :
(Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t
val of_alist_reduce :
(Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t
val of_sorted_array : (Key.t * 'a) array -> 'a t Or_error.t
val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t
val of_tree : 'a t -> 'a t
val invariants : 'a t -> bool
val is_empty : 'a t -> bool
val length : 'a t -> int
val add : 'a t -> key:Key.t -> data:'a -> 'a t
val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t
val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t
val find : 'a t -> Key.t -> 'a option
val find_exn : 'a t -> Key.t -> 'a
val remove : 'a t -> Key.t -> 'a t
val mem : 'a t -> Key.t -> bool
val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit
val iter2 :
'a t ->
'b t ->
f:(key:Key.t ->
data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
unit) ->
unit
val map : 'a t -> f:('a -> 'b) -> 'b t
val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t
val fold :
'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
val fold_right :
'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t
val filter_map : 'a t -> f:('a -> 'b option) -> 'b t
val filter_mapi :
'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t
val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int
val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool
val keys : 'a t -> Key.t list
val data : 'a t -> 'a list
val to_alist : 'a t -> (Key.t * 'a) list
val validate :
name:(Key.t -> string) ->
'a Validate.check -> 'a t Validate.check
val merge :
'a t ->
'b t ->
f:(key:Key.t ->
[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
'c option) ->
'c t
val symmetric_diff :
'a t ->
'a t ->
data_equal:('a -> 'a -> bool) ->
(Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ])
Sequence.t
val min_elt : 'a t -> (Key.t * 'a) option
val min_elt_exn : 'a t -> Key.t * 'a
val max_elt : 'a t -> (Key.t * 'a) option
val max_elt_exn : 'a t -> Key.t * 'a
val for_all : 'a t -> f:('a -> bool) -> bool
val exists : 'a t -> f:('a -> bool) -> bool
val split : 'a t -> Key.t -> 'a t * (Key.t * 'a) option * 'a t
val fold_range_inclusive :
'a t ->
min:Key.t ->
max:Key.t ->
init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
val range_to_alist :
'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list
val closest_key :
'a t ->
[ `Greater_or_equal_to
| `Greater_than
| `Less_or_equal_to
| `Less_than ] -> Key.t -> (Key.t * 'a) option
val nth : 'a t -> int -> (Key.t * 'a) option
val rank : 'a t -> Key.t -> int option
val to_tree : 'a t -> 'a t
val to_sequence :
?order:[ `Decreasing_key | `Increasing_key ] ->
?keys_greater_or_equal_to:Key.t ->
?keys_less_or_equal_to:Key.t -> 'a t -> (Key.t * 'a) Sequence.t
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
end
type 'a t = (Key.t, 'a, Key.comparator_witness) t
val empty : 'a t
val singleton : Key.t -> 'a -> 'a t
val of_alist :
(Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ]
val of_alist_or_error : (Key.t * 'a) list -> 'a t Or_error.t
val of_alist_exn : (Key.t * 'a) list -> 'a t
val of_alist_multi : (Key.t * 'a) list -> 'a list t
val of_alist_fold :
(Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t
val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t
val of_sorted_array : (Key.t * 'a) array -> 'a t Or_error.t
val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t
val of_tree : 'a Tree.t -> 'a t
val invariants : 'a t -> bool
val is_empty : 'a t -> bool
val length : 'a t -> int
val add : 'a t -> key:Key.t -> data:'a -> 'a t
val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t
val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t
val find : 'a t -> Key.t -> 'a option
val find_exn : 'a t -> Key.t -> 'a
val remove : 'a t -> Key.t -> 'a t
val mem : 'a t -> Key.t -> bool
val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit
val iter2 :
'a t ->
'b t ->
f:(key:Key.t ->
data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) ->
unit
val map : 'a t -> f:('a -> 'b) -> 'b t
val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t
val fold :
'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
val fold_right :
'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t
val filter_map : 'a t -> f:('a -> 'b option) -> 'b t
val filter_mapi :
'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t
val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int
val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool
val keys : 'a t -> Key.t list
val data : 'a t -> 'a list
val to_alist : 'a t -> (Key.t * 'a) list
val validate :
name:(Key.t -> string) -> 'a Validate.check -> 'a t Validate.check
val merge :
'a t ->
'b t ->
f:(key:Key.t ->
[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) ->
'c t
val symmetric_diff :
'a t ->
'a t ->
data_equal:('a -> 'a -> bool) ->
(Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ])
Sequence.t
val min_elt : 'a t -> (Key.t * 'a) option
val min_elt_exn : 'a t -> Key.t * 'a
val max_elt : 'a t -> (Key.t * 'a) option
val max_elt_exn : 'a t -> Key.t * 'a
val for_all : 'a t -> f:('a -> bool) -> bool
val exists : 'a t -> f:('a -> bool) -> bool
val split : 'a t -> Key.t -> 'a t * (Key.t * 'a) option * 'a t
val fold_range_inclusive :
'a t ->
min:Key.t ->
max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
val range_to_alist :
'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list
val closest_key :
'a t ->
[ `Greater_or_equal_to
| `Greater_than
| `Less_or_equal_to
| `Less_than ] -> Key.t -> (Key.t * 'a) option
val nth : 'a t -> int -> (Key.t * 'a) option
val rank : 'a t -> Key.t -> int option
val to_tree : 'a t -> 'a Tree.t
val to_sequence :
?order:[ `Decreasing_key | `Increasing_key ] ->
?keys_greater_or_equal_to:Key.t ->
?keys_less_or_equal_to:Key.t -> 'a t -> (Key.t * 'a) Sequence.t
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
val bin_size_t : ('a, 'a t) Bin_prot.Size.sizer1
val bin_write_t : ('a, 'a t) Bin_prot.Write.writer1
val bin_read_t : ('a, 'a t) Bin_prot.Read.reader1
val __bin_read_t__ : ('a, int -> 'a t) Bin_prot.Read.reader1
val bin_writer_t : ('a, 'a t) Bin_prot.Type_class.S1.writer
val bin_reader_t : ('a, 'a t) Bin_prot.Type_class.S1.reader
val bin_t : ('a, 'a t) Bin_prot.Type_class.S1.t
end
end`