This module defines interfaces used in Core.Std.Map. See the documentation in core_map.mli for a description of the approach.

CRs and comments about Map functions do not belong in this file. They belong next to the appropriate function in core_map.mli.

This module defines module types {Creators,Accessors}{1,2,3,_generic,_with_comparator}. It uses check functors to ensure that each module types is an instance of the corresponding _generic one.

We must treat Creators and Accessors separately, because we sometimes need to choose different instantiations of their options. In particular, Map itself matches Creators3_with_comparator but Accessors3 (without comparator).

module Binable : Binable0
module List : Core_list
module type Key = sig .. end
type t
val t_of_sexp : Sexplib.Sexp.t -> t
val sexp_of_t : t -> Sexplib.Sexp.t
val compare : t -> t -> int
module type Key_binable = sig .. end
type t
val t_of_sexp : Sexplib.Sexp.t -> t
val sexp_of_t : t -> Sexplib.Sexp.t
val compare : t -> t -> int
val bin_t : t Bin_prot.Type_class.t
val bin_read_t : t Bin_prot.Read.reader
val __bin_read_t__ : (int -> t) Bin_prot.Read.reader
val bin_reader_t : t Bin_prot.Type_class.reader
val bin_size_t : t Bin_prot.Size.sizer
val bin_write_t : t Bin_prot.Write.writer
val bin_writer_t : t Bin_prot.Type_class.writer
module Without_comparator : sig .. end
type ('key, 'cmp, 'z) t = 'z
module With_comparator : sig .. end
type ('key, 'cmp, 'z) t = comparator:('key, 'cmp) Comparator.t -> 'z
module type Accessors_generic = sig .. end
type ('a, 'b, 'cmp) t
type ('a, 'b, 'cmp) tree
type 'a key
type ('a, 'cmp, 'z) options
val invariants : ('k, 'cmp, ('k, 'v, 'cmp) t -> bool) options
val is_empty : ('a, 'b, 'c) t -> bool
val length : ('a, 'b, 'c) t -> int
val add : ('k, 'cmp, ('k, 'v, 'cmp) t -> key:'k key -> data:'v -> ('k, 'v, 'cmp) t)
options
val add_multi : ('k, 'cmp,
 ('k, 'v list, 'cmp) t -> key:'k key -> data:'v -> ('k, 'v list, 'cmp) t)
options
val change : ('k, 'cmp,
 ('k, 'v, 'cmp) t -> 'k key -> ('v option -> 'v option) -> ('k, 'v, 'cmp) t)
options
val find : ('k, 'cmp, ('k, 'v, 'cmp) t -> 'k key -> 'v option) options
val find_exn : ('k, 'cmp, ('k, 'v, 'cmp) t -> 'k key -> 'v) options
val remove : ('k, 'cmp, ('k, 'v, 'cmp) t -> 'k key -> ('k, 'v, 'cmp) t) options
val mem : ('k, 'cmp, ('k, 'a, 'cmp) t -> 'k key -> bool) options
val iter : ('k, 'v, 'a) t -> f:(key:'k key -> data:'v -> unit) -> unit
val iter2 : ('k, 'cmp,
 ('k, 'v1, 'cmp) t ->
 ('k, 'v2, 'cmp) t ->
 f:(key:'k key ->
    data:[ `Both of 'v1 * 'v2 | `Left of 'v1 | `Right of 'v2 ] -> unit) ->
 unit)
options
val map : ('k, 'v1, 'cmp) t -> f:('v1 -> 'v2) -> ('k, 'v2, 'cmp) t
val mapi : ('k, 'v1, 'cmp) t -> f:(key:'k key -> data:'v1 -> 'v2) -> ('k, 'v2, 'cmp) t
val fold : ('k, 'v, 'b) t -> init:'a -> f:(key:'k key -> data:'v -> 'a -> 'a) -> 'a
val fold_right : ('k, 'v, 'b) t -> init:'a -> f:(key:'k key -> data:'v -> 'a -> 'a) -> 'a
val filter : ('k, 'cmp,
 ('k, 'v, 'cmp) t -> f:(key:'k key -> data:'v -> bool) -> ('k, 'v, 'cmp) t)
options
val filter_map : ('k, 'cmp, ('k, 'v1, 'cmp) t -> f:('v1 -> 'v2 option) -> ('k, 'v2, 'cmp) t)
options
val filter_mapi : ('k, 'cmp,
 ('k, 'v1, 'cmp) t ->
 f:(key:'k key -> data:'v1 -> 'v2 option) -> ('k, 'v2, 'cmp) t)
options
val compare_direct : ('k, 'cmp, ('v -> 'v -> int) -> ('k, 'v, 'cmp) t -> ('k, 'v, 'cmp) t -> int)
options
val equal : ('k, 'cmp,
 ('v -> 'v -> bool) -> ('k, 'v, 'cmp) t -> ('k, 'v, 'cmp) t -> bool)
options
val keys : ('k, 'a, 'b) t -> 'k key list
val data : ('a, 'v, 'b) t -> 'v list
val to_alist : ('k, 'v, 'a) t -> ('k key * 'v) list
val validate : name:('k key -> string) -> 'v Validate.check -> ('k, 'v, 'a) t Validate.check
val merge : ('k, 'cmp,
 ('k, 'v1, 'cmp) t ->
 ('k, 'v2, 'cmp) t ->
 f:(key:'k key ->
    [ `Both of 'v1 * 'v2 | `Left of 'v1 | `Right of 'v2 ] -> 'v3 option) ->
 ('k, 'v3, 'cmp) t)
options
val symmetric_diff : ('k, 'cmp,
 ('k, 'v, 'cmp) t ->
 ('k, 'v, 'cmp) t ->
 data_equal:('v -> 'v -> bool) ->
 ('k key * [ `Left of 'v | `Right of 'v | `Unequal of 'v * 'v ]) list)
options
val min_elt : ('k, 'v, 'a) t -> ('k key * 'v) option
val min_elt_exn : ('k, 'v, 'a) t -> 'k key * 'v
val max_elt : ('k, 'v, 'a) t -> ('k key * 'v) option
val max_elt_exn : ('k, 'v, 'a) t -> 'k key * 'v
val for_all : ('k, 'v, 'a) t -> f:('v -> bool) -> bool
val exists : ('k, 'v, 'a) t -> f:('v -> bool) -> bool
val fold_range_inclusive : ('k, 'cmp,
 ('k, 'v, 'cmp) t ->
 min:'k key ->
 max:'k key -> init:'a -> f:(key:'k key -> data:'v -> 'a -> 'a) -> 'a)
options
val range_to_alist : ('k, 'cmp,
 ('k, 'v, 'cmp) t -> min:'k key -> max:'k key -> ('k key * 'v) list)
options
val prev_key : ('k, 'cmp, ('k, 'v, 'cmp) t -> 'k key -> ('k key * 'v) option) options
val next_key : ('k, 'cmp, ('k, 'v, 'cmp) t -> 'k key -> ('k key * 'v) option) options
val rank : ('k, 'cmp, ('k, 'a, 'cmp) t -> 'k key -> int option) options
val to_tree : ('k, 'v, 'cmp) t -> ('k key, 'v, 'cmp) tree
module type Accessors1 = sig .. end
type 'a t
type 'a tree
type key
val invariants : 'a t -> bool
val is_empty : 'a t -> bool
val length : 'a 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 change : 'a t -> key -> ('a option -> 'a option) -> '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 : 'a t -> key -> bool
val iter : 'a t -> f:(key:key -> data:'a -> unit) -> unit
val iter2 : 'a t ->
'b t ->
f:(key:key -> 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 -> 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 filter : 'a t -> f:(key:key -> data:'a -> 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 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 list
val data : 'a t -> 'a list
val to_alist : '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 -> [ `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 * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) list
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 exists : 'a t -> f:('a -> bool) -> bool
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 prev_key : 'a t -> key -> (key * 'a) option
val next_key : 'a t -> key -> (key * 'a) option
val rank : 'a t -> key -> int option
val to_tree : 'a t -> 'a tree
module type Accessors2 = sig .. end
type ('a, 'b) t
type ('a, 'b) tree
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 ]) list
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 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 prev_key : ('a, 'b) t -> 'a -> ('a * 'b) option
val next_key : ('a, 'b) t -> 'a -> ('a * 'b) option
val rank : ('a, 'b) t -> 'a -> int option
val to_tree : ('a, 'b) t -> ('a, 'b) tree
module type Accessors3 = sig .. end
type ('a, 'b, 'cmp) t
type ('a, 'b, 'cmp) tree
val invariants : ('a, 'b, 'c) t -> bool
val is_empty : ('a, 'b, 'c) t -> bool
val length : ('a, 'b, 'c) t -> int
val add : ('a, 'b, 'cmp) t -> key:'a -> data:'b -> ('a, 'b, 'cmp) t
val add_multi : ('a, 'b list, 'cmp) t -> key:'a -> data:'b -> ('a, 'b list, 'cmp) t
val change : ('a, 'b, 'cmp) t -> 'a -> ('b option -> 'b option) -> ('a, 'b, 'cmp) t
val find : ('a, 'b, 'cmp) t -> 'a -> 'b option
val find_exn : ('a, 'b, 'cmp) t -> 'a -> 'b
val remove : ('a, 'b, 'cmp) t -> 'a -> ('a, 'b, 'cmp) t
val mem : ('a, 'b, 'cmp) t -> 'a -> bool
val iter : ('a, 'b, 'cmp) t -> f:(key:'a -> data:'b -> unit) -> unit
val iter2 : ('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 : ('a, 'b, 'cmp) t -> f:(key:'a -> data:'b -> bool) -> ('a, 'b, 'cmp) t
val filter_map : ('a, 'b, 'cmp) t -> f:('b -> 'c option) -> ('a, 'c, 'cmp) t
val filter_mapi : ('a, 'b, 'cmp) t -> f:(key:'a -> data:'b -> 'c option) -> ('a, 'c, 'cmp) t
val compare_direct : ('b -> 'b -> int) -> ('a, 'b, 'cmp) t -> ('a, 'b, 'cmp) t -> int
val equal : ('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 : ('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 : ('a, 'b, 'cmp) t ->
('a, 'b, 'cmp) t ->
data_equal:('b -> 'b -> bool) ->
('a * [ `Left of 'b | `Right of 'b | `Unequal of 'b * 'b ]) list
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, 'c) t -> f:('b -> bool) -> bool
val exists : ('a, 'b, 'c) t -> f:('b -> bool) -> bool
val fold_range_inclusive : ('a, 'b, 'd) t ->
min:'a -> max:'a -> init:'c -> f:(key:'a -> data:'b -> 'c -> 'c) -> 'c
val range_to_alist : ('a, 'b, 'c) t -> min:'a -> max:'a -> ('a * 'b) list
val prev_key : ('a, 'b, 'c) t -> 'a -> ('a * 'b) option
val next_key : ('a, 'b, 'c) t -> 'a -> ('a * 'b) option
val rank : ('a, 'b, 'c) t -> 'a -> int option
val to_tree : ('a, 'b, 'cmp) t -> ('a, 'b, 'cmp) tree
module type Accessors3_with_comparator = sig .. end
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 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 ]) list
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 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 prev_key : comparator:('a, 'cmp) Comparator.t ->
('a, 'b, 'cmp) t -> 'a -> ('a * 'b) option
val next_key : comparator:('a, 'cmp) Comparator.t ->
('a, 'b, 'cmp) t -> 'a -> ('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
module Check_accessors : 
functor (T : T.T3) ->
functor (Tree : T.T3) ->
functor (Key : T.T1) ->
functor (Options : T.T3) ->
functor (M : Accessors_generic with type options := ('a, 'b, 'c) Options.t with type t := ('a, 'b, 'c) T.t with type tree := ('a, 'b, 'c) Tree.t with type key := 'a Key.t) -> sig .. end
module Check_accessors1 : 
functor (M : Accessors1) -> Check_accessors(sig .. end)(sig .. end)(sig .. end)(Without_comparator)(M)
module Check_accessors2 : 
functor (M : Accessors2) -> Check_accessors(sig .. end)(sig .. end)(sig .. end)(Without_comparator)(M)
module Check_accessors3 : 
functor (M : Accessors3) -> Check_accessors(sig .. end)(sig .. end)(sig .. end)(Without_comparator)(M)
module Check_accessors3_with_comparator : 
functor (M : Accessors3_with_comparator) -> Check_accessors(sig .. end)(sig .. end)(sig .. end)(With_comparator)(M)
module type Creators_generic = sig .. end
type ('k, 'v, 'cmp) t
type ('k, 'v, 'cmp) tree
type 'k key
type ('a, 'cmp, 'z) options
val empty : ('k, 'cmp, ('k, 'a, 'cmp) t) options
val singleton : ('k, 'cmp, 'k key -> 'v -> ('k, 'v, 'cmp) t) options
val of_sorted_array : ('k, 'cmp, ('k key * 'v) array -> ('k, 'v, 'cmp) t Or_error.t) options
val of_sorted_array_unchecked : ('k, 'cmp, ('k key * 'v) array -> ('k, 'v, 'cmp) t) options
val of_alist : ('k, 'cmp,
 ('k key * 'v) list -> [ `Duplicate_key of 'k key | `Ok of ('k, 'v, 'cmp) t ])
options
val of_alist_or_error : ('k, 'cmp, ('k key * 'v) list -> ('k, 'v, 'cmp) t Or_error.t) options
val of_alist_exn : ('k, 'cmp, ('k key * 'v) list -> ('k, 'v, 'cmp) t) options
val of_alist_multi : ('k, 'cmp, ('k key * 'v) list -> ('k, 'v list, 'cmp) t) options
val of_alist_fold : ('k, 'cmp,
 ('k key * 'v1) list ->
 init:'v2 -> f:('v2 -> 'v1 -> 'v2) -> ('k, 'v2, 'cmp) t)
options
val of_alist_reduce : ('k, 'cmp, ('k key * 'v) list -> f:('v -> 'v -> 'v) -> ('k, 'v, 'cmp) t)
options
val of_tree : ('k, 'cmp, ('k key, 'v, 'cmp) tree -> ('k, 'v, 'cmp) t) options
module type Creators1 = sig .. end
type 'a t
type 'a tree
type key
val empty : 'a t
val singleton : key -> 'a -> 'a t
val of_alist : (key * 'a) list -> [ `Duplicate_key of key | `Ok of 'a t ]
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
module type Creators2 = sig .. end
type ('a, 'b) t
type ('a, 'b) tree
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 -> ('a, 'b) t
module type Creators3_with_comparator = sig .. end
type ('a, 'b, 'cmp) t
type ('a, 'b, 'cmp) tree
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) tree -> ('a, 'b, 'cmp) t
module Check_creators : 
functor (T : T.T3) ->
functor (Tree : T.T3) ->
functor (Key : T.T1) ->
functor (Options : T.T3) ->
functor (M : Creators_generic with type options := ('a, 'b, 'c) Options.t with type t := ('a, 'b, 'c) T.t with type tree := ('a, 'b, 'c) Tree.t with type key := 'a Key.t) -> sig .. end
module Check_creators1 : 
functor (M : Creators1) -> Check_creators(sig .. end)(sig .. end)(sig .. end)(Without_comparator)(M)
module Check_creators2 : 
functor (M : Creators2) -> Check_creators(sig .. end)(sig .. end)(sig .. end)(Without_comparator)(M)
module Check_creators3_with_comparator : 
functor (M : Creators3_with_comparator) -> Check_creators(sig .. end)(sig .. end)(sig .. end)(With_comparator)(M)
module type Creators_and_accessors_generic = sig .. end
include Creators_generic
include Accessors_generic with type t := ('a, 'b, 'c) t with type tree := ('a, 'b, 'c) tree with type key := 'a key with type options := ('a, 'b, 'c) options
module type Creators_and_accessors1 = sig .. end
include Creators1
include Accessors1 with type t := 'a t with type tree := 'a tree with type key := key
module type Creators_and_accessors2 = sig .. end
include Creators2
include Accessors2 with type t := ('a, 'b) t with type tree := ('a, 'b) tree
module type Creators_and_accessors3_with_comparator = sig .. end
include Creators3_with_comparator
include Accessors3_with_comparator with type t := ('a, 'b, 'c) t with type tree := ('a, 'b, 'c) tree
module type S = sig .. end
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) tree
include Creators_and_accessors1 with type t := 'a t with type tree := 'a t with type key := Key.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
type +'a t = (Key.t, 'a, Key.comparator_witness) map
include Creators_and_accessors1 with type t := 'a t with type tree := 'a Tree.t with type key := Key.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
module type S_binable = sig .. end
include S
include Binable.S1 with type t := 'a t