`sig
module type Infix = Comparable_intf.Infix
module type Map_and_set_binable = Comparable_intf.Map_and_set_binable
module type S = Comparable_intf.S
module type S_binable = Comparable_intf.S_binable
module type S_common = Comparable_intf.S_common
module type Validate = Comparable_intf.Validate
module type With_zero = Comparable_intf.With_zero
type 'a bound =
'a Comparable_intf.bound =
Incl of 'a
| Excl of 'a
| Unbounded
val lexicographic : ('a -> 'a -> int) list -> 'a -> 'a -> int
module Inherit :
functor
(C : sig
type t
val compare :
Comparable.Inherit.t -> Comparable.Inherit.t -> int
end) (T : sig
type t
val component : Comparable.Inherit.t -> C.t
val t_of_sexp : Sexplib.Sexp.t -> Comparable.Inherit.t
val sexp_of_t : Comparable.Inherit.t -> Sexplib.Sexp.t
end) ->
sig
val ( >= ) : T.t -> T.t -> bool
val ( <= ) : T.t -> T.t -> bool
val ( = ) : T.t -> T.t -> bool
val ( > ) : T.t -> T.t -> bool
val ( < ) : T.t -> T.t -> bool
val ( <> ) : T.t -> T.t -> bool
val equal : T.t -> T.t -> bool
val compare : T.t -> T.t -> int
val min : T.t -> T.t -> T.t
val max : T.t -> T.t -> T.t
val ascending : T.t -> T.t -> int
val descending : T.t -> T.t -> int
val between : T.t -> low:T.t -> high:T.t -> bool
module Replace_polymorphic_compare :
sig
val ( >= ) : T.t -> T.t -> bool
val ( <= ) : T.t -> T.t -> bool
val ( = ) : T.t -> T.t -> bool
val ( > ) : T.t -> T.t -> bool
val ( < ) : T.t -> T.t -> bool
val ( <> ) : T.t -> T.t -> bool
val equal : T.t -> T.t -> bool
val compare : T.t -> T.t -> int
val min : T.t -> T.t -> T.t
val max : T.t -> T.t -> T.t
val _squelch_unused_module_warning_ : unit
end
type comparator_witness
val comparator : (T.t, comparator_witness) Comparator.comparator
val validate_lbound :
min:T.t Comparable_intf.bound -> T.t Validate.check
val validate_ubound :
max:T.t Comparable_intf.bound -> T.t Validate.check
val validate_bound :
min:T.t Comparable_intf.bound ->
max:T.t Comparable_intf.bound -> T.t Validate.check
module Map :
sig
module Key :
sig
type t = T.t
type comparator_witness = comparator_witness
val comparator :
(t, comparator_witness) Comparator.comparator
end
module Tree :
sig
type 'a t =
(Key.t, 'a, Key.comparator_witness) Core_map.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) Core_map.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 Set :
sig
module Elt :
sig
type t = T.t
type comparator_witness = comparator_witness
val comparator :
(t, comparator_witness) Comparator.comparator
val t_of_sexp : Sexplib.Sexp.t -> t
val sexp_of_t : t -> Sexplib.Sexp.t
end
module Tree :
sig
type t = (Elt.t, Elt.comparator_witness) Core_set.Tree.t
val length : t -> int
val is_empty : t -> bool
val iter : t -> f:(Elt.t -> unit) -> unit
val fold :
t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum
val exists : t -> f:(Elt.t -> bool) -> bool
val for_all : t -> f:(Elt.t -> bool) -> bool
val count : t -> f:(Elt.t -> bool) -> int
val sum :
(module Commutative_group.S with type t = 'sum) ->
t -> f:(Elt.t -> 'sum) -> 'sum
val find : t -> f:(Elt.t -> bool) -> Elt.t option
val find_map : t -> f:(Elt.t -> 'a option) -> 'a option
val to_list : t -> Elt.t list
val to_array : t -> Elt.t array
val invariants : t -> bool
val mem : t -> Elt.t -> bool
val add : t -> Elt.t -> t
val remove : t -> Elt.t -> t
val union : t -> t -> t
val inter : t -> t -> t
val diff : t -> t -> t
val symmetric_diff :
t -> t -> (Elt.t, Elt.t) Either.t Sequence.t
val compare_direct : t -> t -> int
val equal : t -> t -> bool
val subset : t -> t -> bool
val fold_until :
t ->
init:'b ->
f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b
val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b
val iter2 :
t ->
t ->
f:([ `Both of Elt.t * Elt.t
| `Left of Elt.t
| `Right of Elt.t ] -> unit) ->
unit
val filter : t -> f:(Elt.t -> bool) -> t
val partition_tf : t -> f:(Elt.t -> bool) -> t * t
val elements : t -> Elt.t list
val min_elt : t -> Elt.t option
val min_elt_exn : t -> Elt.t
val max_elt : t -> Elt.t option
val max_elt_exn : t -> Elt.t
val choose : t -> Elt.t option
val choose_exn : t -> Elt.t
val split : t -> Elt.t -> t * Elt.t option * t
val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list
val find_exn : t -> f:(Elt.t -> bool) -> Elt.t
val find_index : t -> int -> Elt.t option
val remove_index : t -> int -> t
val to_tree : t -> t
val to_sequence :
?order:[ `Decreasing | `Increasing ] ->
?greater_or_equal_to:Elt.t ->
?less_or_equal_to:Elt.t -> t -> Elt.t Sequence.t
val to_map :
t ->
f:(Elt.t -> 'data) ->
(Elt.t, 'data, Elt.comparator_witness) Core_set_intf.Map.t
val empty : t
val singleton : Elt.t -> t
val union_list : t list -> t
val of_list : Elt.t list -> t
val of_array : Elt.t array -> t
val of_sorted_array : Elt.t array -> t Or_error.t
val of_sorted_array_unchecked : Elt.t array -> t
val stable_dedup_list : Elt.t list -> Elt.t list
val map : ('a, 'b) Core_set.Tree.t -> f:('a -> Elt.t) -> t
val filter_map :
('a, 'b) Core_set.Tree.t -> f:('a -> Elt.t option) -> t
val of_tree : t -> t
val of_map_keys :
(Elt.t, 'a, Elt.comparator_witness) Core_set_intf.Map.t ->
t
val t_of_sexp : Sexplib.Sexp.t -> t
val sexp_of_t : t -> Sexplib.Sexp.t
val compare : t -> t -> int
end
type t = (Elt.t, Elt.comparator_witness) Core_set.t
val length : t -> int
val is_empty : t -> bool
val iter : t -> f:(Elt.t -> unit) -> unit
val fold :
t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum
val exists : t -> f:(Elt.t -> bool) -> bool
val for_all : t -> f:(Elt.t -> bool) -> bool
val count : t -> f:(Elt.t -> bool) -> int
val sum :
(module Commutative_group.S with type t = 'sum) ->
t -> f:(Elt.t -> 'sum) -> 'sum
val find : t -> f:(Elt.t -> bool) -> Elt.t option
val find_map : t -> f:(Elt.t -> 'a option) -> 'a option
val to_list : t -> Elt.t list
val to_array : t -> Elt.t array
val invariants : t -> bool
val mem : t -> Elt.t -> bool
val add : t -> Elt.t -> t
val remove : t -> Elt.t -> t
val union : t -> t -> t
val inter : t -> t -> t
val diff : t -> t -> t
val symmetric_diff : t -> t -> (Elt.t, Elt.t) Either.t Sequence.t
val compare_direct : t -> t -> int
val equal : t -> t -> bool
val subset : t -> t -> bool
val fold_until :
t ->
init:'b ->
f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b
val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b
val iter2 :
t ->
t ->
f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] ->
unit) ->
unit
val filter : t -> f:(Elt.t -> bool) -> t
val partition_tf : t -> f:(Elt.t -> bool) -> t * t
val elements : t -> Elt.t list
val min_elt : t -> Elt.t option
val min_elt_exn : t -> Elt.t
val max_elt : t -> Elt.t option
val max_elt_exn : t -> Elt.t
val choose : t -> Elt.t option
val choose_exn : t -> Elt.t
val split : t -> Elt.t -> t * Elt.t option * t
val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list
val find_exn : t -> f:(Elt.t -> bool) -> Elt.t
val find_index : t -> int -> Elt.t option
val remove_index : t -> int -> t
val to_tree : t -> Tree.t
val to_sequence :
?order:[ `Decreasing | `Increasing ] ->
?greater_or_equal_to:Elt.t ->
?less_or_equal_to:Elt.t -> t -> Elt.t Sequence.t
val to_map :
t ->
f:(Elt.t -> 'data) ->
(Elt.t, 'data, Elt.comparator_witness) Core_set_intf.Map.t
val empty : t
val singleton : Elt.t -> t
val union_list : t list -> t
val of_list : Elt.t list -> t
val of_array : Elt.t array -> t
val of_sorted_array : Elt.t array -> t Or_error.t
val of_sorted_array_unchecked : Elt.t array -> t
val stable_dedup_list : Elt.t list -> Elt.t list
val map : ('a, 'b) Core_set.t -> f:('a -> Elt.t) -> t
val filter_map :
('a, 'b) Core_set.t -> f:('a -> Elt.t option) -> t
val of_tree : Tree.t -> t
val of_map_keys :
(Elt.t, 'a, Elt.comparator_witness) Core_set_intf.Map.t -> t
val t_of_sexp : Sexplib.Sexp.t -> t
val sexp_of_t : t -> Sexplib.Sexp.t
val compare : t -> t -> int
end
end
module Make :
functor
(T : sig
type t
val t_of_sexp : Sexplib.Sexp.t -> Comparable.Make.t
val sexp_of_t : Comparable.Make.t -> Sexplib.Sexp.t
val compare : Comparable.Make.t -> Comparable.Make.t -> int
end) ->
sig
val ( >= ) : T.t -> T.t -> bool
val ( <= ) : T.t -> T.t -> bool
val ( = ) : T.t -> T.t -> bool
val ( > ) : T.t -> T.t -> bool
val ( < ) : T.t -> T.t -> bool
val ( <> ) : T.t -> T.t -> bool
val equal : T.t -> T.t -> bool
val compare : T.t -> T.t -> int
val min : T.t -> T.t -> T.t
val max : T.t -> T.t -> T.t
val ascending : T.t -> T.t -> int
val descending : T.t -> T.t -> int
val between : T.t -> low:T.t -> high:T.t -> bool
module Replace_polymorphic_compare :
sig
val ( >= ) : T.t -> T.t -> bool
val ( <= ) : T.t -> T.t -> bool
val ( = ) : T.t -> T.t -> bool
val ( > ) : T.t -> T.t -> bool
val ( < ) : T.t -> T.t -> bool
val ( <> ) : T.t -> T.t -> bool
val equal : T.t -> T.t -> bool
val compare : T.t -> T.t -> int
val min : T.t -> T.t -> T.t
val max : T.t -> T.t -> T.t
val _squelch_unused_module_warning_ : unit
end
type comparator_witness
val comparator : (T.t, comparator_witness) Comparator.comparator
val validate_lbound :
min:T.t Comparable_intf.bound -> T.t Validate.check
val validate_ubound :
max:T.t Comparable_intf.bound -> T.t Validate.check
val validate_bound :
min:T.t Comparable_intf.bound ->
max:T.t Comparable_intf.bound -> T.t Validate.check
module Map :
sig
module Key :
sig
type t = T.t
type comparator_witness = comparator_witness
val comparator :
(t, comparator_witness) Comparator.comparator
end
module Tree :
sig
type 'a t =
(Key.t, 'a, Key.comparator_witness) Core_map.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) Core_map.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 Set :
sig
module Elt :
sig
type t = T.t
type comparator_witness = comparator_witness
val comparator :
(t, comparator_witness) Comparator.comparator
val t_of_sexp : Sexplib.Sexp.t -> t
val sexp_of_t : t -> Sexplib.Sexp.t
end
module Tree :
sig
type t = (Elt.t, Elt.comparator_witness) Core_set.Tree.t
val length : t -> int
val is_empty : t -> bool
val iter : t -> f:(Elt.t -> unit) -> unit
val fold :
t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum
val exists : t -> f:(Elt.t -> bool) -> bool
val for_all : t -> f:(Elt.t -> bool) -> bool
val count : t -> f:(Elt.t -> bool) -> int
val sum :
(module Commutative_group.S with type t = 'sum) ->
t -> f:(Elt.t -> 'sum) -> 'sum
val find : t -> f:(Elt.t -> bool) -> Elt.t option
val find_map : t -> f:(Elt.t -> 'a option) -> 'a option
val to_list : t -> Elt.t list
val to_array : t -> Elt.t array
val invariants : t -> bool
val mem : t -> Elt.t -> bool
val add : t -> Elt.t -> t
val remove : t -> Elt.t -> t
val union : t -> t -> t
val inter : t -> t -> t
val diff : t -> t -> t
val symmetric_diff :
t -> t -> (Elt.t, Elt.t) Either.t Sequence.t
val compare_direct : t -> t -> int
val equal : t -> t -> bool
val subset : t -> t -> bool
val fold_until :
t ->
init:'b ->
f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b
val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b
val iter2 :
t ->
t ->
f:([ `Both of Elt.t * Elt.t
| `Left of Elt.t
| `Right of Elt.t ] -> unit) ->
unit
val filter : t -> f:(Elt.t -> bool) -> t
val partition_tf : t -> f:(Elt.t -> bool) -> t * t
val elements : t -> Elt.t list
val min_elt : t -> Elt.t option
val min_elt_exn : t -> Elt.t
val max_elt : t -> Elt.t option
val max_elt_exn : t -> Elt.t
val choose : t -> Elt.t option
val choose_exn : t -> Elt.t
val split : t -> Elt.t -> t * Elt.t option * t
val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list
val find_exn : t -> f:(Elt.t -> bool) -> Elt.t
val find_index : t -> int -> Elt.t option
val remove_index : t -> int -> t
val to_tree : t -> t
val to_sequence :
?order:[ `Decreasing | `Increasing ] ->
?greater_or_equal_to:Elt.t ->
?less_or_equal_to:Elt.t -> t -> Elt.t Sequence.t
val to_map :
t ->
f:(Elt.t -> 'data) ->
(Elt.t, 'data, Elt.comparator_witness) Core_set_intf.Map.t
val empty : t
val singleton : Elt.t -> t
val union_list : t list -> t
val of_list : Elt.t list -> t
val of_array : Elt.t array -> t
val of_sorted_array : Elt.t array -> t Or_error.t
val of_sorted_array_unchecked : Elt.t array -> t
val stable_dedup_list : Elt.t list -> Elt.t list
val map : ('a, 'b) Core_set.Tree.t -> f:('a -> Elt.t) -> t
val filter_map :
('a, 'b) Core_set.Tree.t -> f:('a -> Elt.t option) -> t
val of_tree : t -> t
val of_map_keys :
(Elt.t, 'a, Elt.comparator_witness) Core_set_intf.Map.t ->
t
val t_of_sexp : Sexplib.Sexp.t -> t
val sexp_of_t : t -> Sexplib.Sexp.t
val compare : t -> t -> int
end
type t = (Elt.t, Elt.comparator_witness) Core_set.t
val length : t -> int
val is_empty : t -> bool
val iter : t -> f:(Elt.t -> unit) -> unit
val fold :
t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum
val exists : t -> f:(Elt.t -> bool) -> bool
val for_all : t -> f:(Elt.t -> bool) -> bool
val count : t -> f:(Elt.t -> bool) -> int
val sum :
(module Commutative_group.S with type t = 'sum) ->
t -> f:(Elt.t -> 'sum) -> 'sum
val find : t -> f:(Elt.t -> bool) -> Elt.t option
val find_map : t -> f:(Elt.t -> 'a option) -> 'a option
val to_list : t -> Elt.t list
val to_array : t -> Elt.t array
val invariants : t -> bool
val mem : t -> Elt.t -> bool
val add : t -> Elt.t -> t
val remove : t -> Elt.t -> t
val union : t -> t -> t
val inter : t -> t -> t
val diff : t -> t -> t
val symmetric_diff : t -> t -> (Elt.t, Elt.t) Either.t Sequence.t
val compare_direct : t -> t -> int
val equal : t -> t -> bool
val subset : t -> t -> bool
val fold_until :
t ->
init:'b ->
f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b
val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b
val iter2 :
t ->
t ->
f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] ->
unit) ->
unit
val filter : t -> f:(Elt.t -> bool) -> t
val partition_tf : t -> f:(Elt.t -> bool) -> t * t
val elements : t -> Elt.t list
val min_elt : t -> Elt.t option
val min_elt_exn : t -> Elt.t
val max_elt : t -> Elt.t option
val max_elt_exn : t -> Elt.t
val choose : t -> Elt.t option
val choose_exn : t -> Elt.t
val split : t -> Elt.t -> t * Elt.t option * t
val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list
val find_exn : t -> f:(Elt.t -> bool) -> Elt.t
val find_index : t -> int -> Elt.t option
val remove_index : t -> int -> t
val to_tree : t -> Tree.t
val to_sequence :
?order:[ `Decreasing | `Increasing ] ->
?greater_or_equal_to:Elt.t ->
?less_or_equal_to:Elt.t -> t -> Elt.t Sequence.t
val to_map :
t ->
f:(Elt.t -> 'data) ->
(Elt.t, 'data, Elt.comparator_witness) Core_set_intf.Map.t
val empty : t
val singleton : Elt.t -> t
val union_list : t list -> t
val of_list : Elt.t list -> t
val of_array : Elt.t array -> t
val of_sorted_array : Elt.t array -> t Or_error.t
val of_sorted_array_unchecked : Elt.t array -> t
val stable_dedup_list : Elt.t list -> Elt.t list
val map : ('a, 'b) Core_set.t -> f:('a -> Elt.t) -> t
val filter_map :
('a, 'b) Core_set.t -> f:('a -> Elt.t option) -> t
val of_tree : Tree.t -> t
val of_map_keys :
(Elt.t, 'a, Elt.comparator_witness) Core_set_intf.Map.t -> t
val t_of_sexp : Sexplib.Sexp.t -> t
val sexp_of_t : t -> Sexplib.Sexp.t
val compare : t -> t -> int
end
end
module Make_binable :
functor
(T : sig
type t
val t_of_sexp : Sexplib.Sexp.t -> Comparable.Make_binable.t
val sexp_of_t : Comparable.Make_binable.t -> Sexplib.Sexp.t
val compare :
Comparable.Make_binable.t -> Comparable.Make_binable.t -> int
val bin_t : Comparable.Make_binable.t Bin_prot.Type_class.t
val bin_read_t : Comparable.Make_binable.t Bin_prot.Read.reader
val __bin_read_t__ :
(int -> Comparable.Make_binable.t) Bin_prot.Read.reader
val bin_reader_t :
Comparable.Make_binable.t Bin_prot.Type_class.reader
val bin_size_t : Comparable.Make_binable.t Bin_prot.Size.sizer
val bin_write_t :
Comparable.Make_binable.t Bin_prot.Write.writer
val bin_writer_t :
Comparable.Make_binable.t Bin_prot.Type_class.writer
end) ->
sig
val ( >= ) : T.t -> T.t -> bool
val ( <= ) : T.t -> T.t -> bool
val ( = ) : T.t -> T.t -> bool
val ( > ) : T.t -> T.t -> bool
val ( < ) : T.t -> T.t -> bool
val ( <> ) : T.t -> T.t -> bool
val equal : T.t -> T.t -> bool
val compare : T.t -> T.t -> int
val min : T.t -> T.t -> T.t
val max : T.t -> T.t -> T.t
val ascending : T.t -> T.t -> int
val descending : T.t -> T.t -> int
val between : T.t -> low:T.t -> high:T.t -> bool
module Replace_polymorphic_compare :
sig
val ( >= ) : T.t -> T.t -> bool
val ( <= ) : T.t -> T.t -> bool
val ( = ) : T.t -> T.t -> bool
val ( > ) : T.t -> T.t -> bool
val ( < ) : T.t -> T.t -> bool
val ( <> ) : T.t -> T.t -> bool
val equal : T.t -> T.t -> bool
val compare : T.t -> T.t -> int
val min : T.t -> T.t -> T.t
val max : T.t -> T.t -> T.t
val _squelch_unused_module_warning_ : unit
end
type comparator_witness
val validate_lbound :
min:T.t Comparable_intf.bound -> T.t Validate.check
val validate_ubound :
max:T.t Comparable_intf.bound -> T.t Validate.check
val validate_bound :
min:T.t Comparable_intf.bound ->
max:T.t Comparable_intf.bound -> T.t Validate.check
val comparator : (T.t, comparator_witness) Comparator.comparator
module Map :
sig
module Key :
sig
type t = T.t
type comparator_witness = comparator_witness
val comparator :
(t, comparator_witness) Comparator.comparator
end
module Tree :
sig
type 'a t =
(Key.t, 'a, Key.comparator_witness) Core_map.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) Core_map.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 Set :
sig
module Elt :
sig
type t = T.t
type comparator_witness = comparator_witness
val comparator :
(t, comparator_witness) Comparator.comparator
val t_of_sexp : Sexplib.Sexp.t -> t
val sexp_of_t : t -> Sexplib.Sexp.t
end
module Tree :
sig
type t = (Elt.t, Elt.comparator_witness) Core_set.Tree.t
val length : t -> int
val is_empty : t -> bool
val iter : t -> f:(Elt.t -> unit) -> unit
val fold :
t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum
val exists : t -> f:(Elt.t -> bool) -> bool
val for_all : t -> f:(Elt.t -> bool) -> bool
val count : t -> f:(Elt.t -> bool) -> int
val sum :
(module Commutative_group.S with type t = 'sum) ->
t -> f:(Elt.t -> 'sum) -> 'sum
val find : t -> f:(Elt.t -> bool) -> Elt.t option
val find_map : t -> f:(Elt.t -> 'a option) -> 'a option
val to_list : t -> Elt.t list
val to_array : t -> Elt.t array
val invariants : t -> bool
val mem : t -> Elt.t -> bool
val add : t -> Elt.t -> t
val remove : t -> Elt.t -> t
val union : t -> t -> t
val inter : t -> t -> t
val diff : t -> t -> t
val symmetric_diff :
t -> t -> (Elt.t, Elt.t) Either.t Sequence.t
val compare_direct : t -> t -> int
val equal : t -> t -> bool
val subset : t -> t -> bool
val fold_until :
t ->
init:'b ->
f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b
val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b
val iter2 :
t ->
t ->
f:([ `Both of Elt.t * Elt.t
| `Left of Elt.t
| `Right of Elt.t ] -> unit) ->
unit
val filter : t -> f:(Elt.t -> bool) -> t
val partition_tf : t -> f:(Elt.t -> bool) -> t * t
val elements : t -> Elt.t list
val min_elt : t -> Elt.t option
val min_elt_exn : t -> Elt.t
val max_elt : t -> Elt.t option
val max_elt_exn : t -> Elt.t
val choose : t -> Elt.t option
val choose_exn : t -> Elt.t
val split : t -> Elt.t -> t * Elt.t option * t
val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list
val find_exn : t -> f:(Elt.t -> bool) -> Elt.t
val find_index : t -> int -> Elt.t option
val remove_index : t -> int -> t
val to_tree : t -> t
val to_sequence :
?order:[ `Decreasing | `Increasing ] ->
?greater_or_equal_to:Elt.t ->
?less_or_equal_to:Elt.t -> t -> Elt.t Sequence.t
val to_map :
t ->
f:(Elt.t -> 'data) ->
(Elt.t, 'data, Elt.comparator_witness) Core_set_intf.Map.t
val empty : t
val singleton : Elt.t -> t
val union_list : t list -> t
val of_list : Elt.t list -> t
val of_array : Elt.t array -> t
val of_sorted_array : Elt.t array -> t Or_error.t
val of_sorted_array_unchecked : Elt.t array -> t
val stable_dedup_list : Elt.t list -> Elt.t list
val map : ('a, 'b) Core_set.Tree.t -> f:('a -> Elt.t) -> t
val filter_map :
('a, 'b) Core_set.Tree.t -> f:('a -> Elt.t option) -> t
val of_tree : t -> t
val of_map_keys :
(Elt.t, 'a, Elt.comparator_witness) Core_set_intf.Map.t ->
t
val t_of_sexp : Sexplib.Sexp.t -> t
val sexp_of_t : t -> Sexplib.Sexp.t
val compare : t -> t -> int
end
type t = (Elt.t, Elt.comparator_witness) Core_set.t
val length : t -> int
val is_empty : t -> bool
val iter : t -> f:(Elt.t -> unit) -> unit
val fold :
t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum
val exists : t -> f:(Elt.t -> bool) -> bool
val for_all : t -> f:(Elt.t -> bool) -> bool
val count : t -> f:(Elt.t -> bool) -> int
val sum :
(module Commutative_group.S with type t = 'sum) ->
t -> f:(Elt.t -> 'sum) -> 'sum
val find : t -> f:(Elt.t -> bool) -> Elt.t option
val find_map : t -> f:(Elt.t -> 'a option) -> 'a option
val to_list : t -> Elt.t list
val to_array : t -> Elt.t array
val invariants : t -> bool
val mem : t -> Elt.t -> bool
val add : t -> Elt.t -> t
val remove : t -> Elt.t -> t
val union : t -> t -> t
val inter : t -> t -> t
val diff : t -> t -> t
val symmetric_diff : t -> t -> (Elt.t, Elt.t) Either.t Sequence.t
val compare_direct : t -> t -> int
val equal : t -> t -> bool
val subset : t -> t -> bool
val fold_until :
t ->
init:'b ->
f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b
val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b
val iter2 :
t ->
t ->
f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] ->
unit) ->
unit
val filter : t -> f:(Elt.t -> bool) -> t
val partition_tf : t -> f:(Elt.t -> bool) -> t * t
val elements : t -> Elt.t list
val min_elt : t -> Elt.t option
val min_elt_exn : t -> Elt.t
val max_elt : t -> Elt.t option
val max_elt_exn : t -> Elt.t
val choose : t -> Elt.t option
val choose_exn : t -> Elt.t
val split : t -> Elt.t -> t * Elt.t option * t
val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list
val find_exn : t -> f:(Elt.t -> bool) -> Elt.t
val find_index : t -> int -> Elt.t option
val remove_index : t -> int -> t
val to_tree : t -> Tree.t
val to_sequence :
?order:[ `Decreasing | `Increasing ] ->
?greater_or_equal_to:Elt.t ->
?less_or_equal_to:Elt.t -> t -> Elt.t Sequence.t
val to_map :
t ->
f:(Elt.t -> 'data) ->
(Elt.t, 'data, Elt.comparator_witness) Core_set_intf.Map.t
val empty : t
val singleton : Elt.t -> t
val union_list : t list -> t
val of_list : Elt.t list -> t
val of_array : Elt.t array -> t
val of_sorted_array : Elt.t array -> t Or_error.t
val of_sorted_array_unchecked : Elt.t array -> t
val stable_dedup_list : Elt.t list -> Elt.t list
val map : ('a, 'b) Core_set.t -> f:('a -> Elt.t) -> t
val filter_map :
('a, 'b) Core_set.t -> f:('a -> Elt.t option) -> t
val of_tree : Tree.t -> t
val of_map_keys :
(Elt.t, 'a, Elt.comparator_witness) Core_set_intf.Map.t -> t
val t_of_sexp : Sexplib.Sexp.t -> t
val sexp_of_t : t -> Sexplib.Sexp.t
val compare : t -> t -> int
val bin_size_t : t Bin_prot.Size.sizer
val bin_write_t : t Bin_prot.Write.writer
val bin_read_t : t Bin_prot.Read.reader
val __bin_read_t__ : (int -> t) Bin_prot.Read.reader
val bin_writer_t : t Bin_prot.Type_class.writer
val bin_reader_t : t Bin_prot.Type_class.reader
val bin_t : t Bin_prot.Type_class.t
end
end
module Map_and_set_binable :
functor
(T : sig
type t
val t_of_sexp :
Sexplib.Sexp.t -> Comparable.Map_and_set_binable.t
val sexp_of_t :
Comparable.Map_and_set_binable.t -> Sexplib.Sexp.t
val compare :
Comparable.Map_and_set_binable.t ->
Comparable.Map_and_set_binable.t -> int
val bin_t :
Comparable.Map_and_set_binable.t Bin_prot.Type_class.t
val bin_read_t :
Comparable.Map_and_set_binable.t Bin_prot.Read.reader
val __bin_read_t__ :
(int -> Comparable.Map_and_set_binable.t) Bin_prot.Read.reader
val bin_reader_t :
Comparable.Map_and_set_binable.t Bin_prot.Type_class.reader
val bin_size_t :
Comparable.Map_and_set_binable.t Bin_prot.Size.sizer
val bin_write_t :
Comparable.Map_and_set_binable.t Bin_prot.Write.writer
val bin_writer_t :
Comparable.Map_and_set_binable.t Bin_prot.Type_class.writer
end) ->
sig
type comparator_witness
val comparator : (T.t, comparator_witness) Comparator.comparator
module Map :
sig
module Key :
sig
type t = T.t
type comparator_witness = comparator_witness
val comparator :
(t, comparator_witness) Comparator.comparator
end
module Tree :
sig
type 'a t =
(Key.t, 'a, Key.comparator_witness) Core_map.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) Core_map.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 Set :
sig
module Elt :
sig
type t = T.t
type comparator_witness = comparator_witness
val comparator :
(t, comparator_witness) Comparator.comparator
val t_of_sexp : Sexplib.Sexp.t -> t
val sexp_of_t : t -> Sexplib.Sexp.t
end
module Tree :
sig
type t = (Elt.t, Elt.comparator_witness) Core_set.Tree.t
val length : t -> int
val is_empty : t -> bool
val iter : t -> f:(Elt.t -> unit) -> unit
val fold :
t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum
val exists : t -> f:(Elt.t -> bool) -> bool
val for_all : t -> f:(Elt.t -> bool) -> bool
val count : t -> f:(Elt.t -> bool) -> int
val sum :
(module Commutative_group.S with type t = 'sum) ->
t -> f:(Elt.t -> 'sum) -> 'sum
val find : t -> f:(Elt.t -> bool) -> Elt.t option
val find_map : t -> f:(Elt.t -> 'a option) -> 'a option
val to_list : t -> Elt.t list
val to_array : t -> Elt.t array
val invariants : t -> bool
val mem : t -> Elt.t -> bool
val add : t -> Elt.t -> t
val remove : t -> Elt.t -> t
val union : t -> t -> t
val inter : t -> t -> t
val diff : t -> t -> t
val symmetric_diff :
t -> t -> (Elt.t, Elt.t) Either.t Sequence.t
val compare_direct : t -> t -> int
val equal : t -> t -> bool
val subset : t -> t -> bool
val fold_until :
t ->
init:'b ->
f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b
val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b
val iter2 :
t ->
t ->
f:([ `Both of Elt.t * Elt.t
| `Left of Elt.t
| `Right of Elt.t ] -> unit) ->
unit
val filter : t -> f:(Elt.t -> bool) -> t
val partition_tf : t -> f:(Elt.t -> bool) -> t * t
val elements : t -> Elt.t list
val min_elt : t -> Elt.t option
val min_elt_exn : t -> Elt.t
val max_elt : t -> Elt.t option
val max_elt_exn : t -> Elt.t
val choose : t -> Elt.t option
val choose_exn : t -> Elt.t
val split : t -> Elt.t -> t * Elt.t option * t
val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list
val find_exn : t -> f:(Elt.t -> bool) -> Elt.t
val find_index : t -> int -> Elt.t option
val remove_index : t -> int -> t
val to_tree : t -> t
val to_sequence :
?order:[ `Decreasing | `Increasing ] ->
?greater_or_equal_to:Elt.t ->
?less_or_equal_to:Elt.t -> t -> Elt.t Sequence.t
val to_map :
t ->
f:(Elt.t -> 'data) ->
(Elt.t, 'data, Elt.comparator_witness) Core_set_intf.Map.t
val empty : t
val singleton : Elt.t -> t
val union_list : t list -> t
val of_list : Elt.t list -> t
val of_array : Elt.t array -> t
val of_sorted_array : Elt.t array -> t Or_error.t
val of_sorted_array_unchecked : Elt.t array -> t
val stable_dedup_list : Elt.t list -> Elt.t list
val map : ('a, 'b) Core_set.Tree.t -> f:('a -> Elt.t) -> t
val filter_map :
('a, 'b) Core_set.Tree.t -> f:('a -> Elt.t option) -> t
val of_tree : t -> t
val of_map_keys :
(Elt.t, 'a, Elt.comparator_witness) Core_set_intf.Map.t ->
t
val t_of_sexp : Sexplib.Sexp.t -> t
val sexp_of_t : t -> Sexplib.Sexp.t
val compare : t -> t -> int
end
type t = (Elt.t, Elt.comparator_witness) Core_set.t
val length : t -> int
val is_empty : t -> bool
val iter : t -> f:(Elt.t -> unit) -> unit
val fold :
t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum
val exists : t -> f:(Elt.t -> bool) -> bool
val for_all : t -> f:(Elt.t -> bool) -> bool
val count : t -> f:(Elt.t -> bool) -> int
val sum :
(module Commutative_group.S with type t = 'sum) ->
t -> f:(Elt.t -> 'sum) -> 'sum
val find : t -> f:(Elt.t -> bool) -> Elt.t option
val find_map : t -> f:(Elt.t -> 'a option) -> 'a option
val to_list : t -> Elt.t list
val to_array : t -> Elt.t array
val invariants : t -> bool
val mem : t -> Elt.t -> bool
val add : t -> Elt.t -> t
val remove : t -> Elt.t -> t
val union : t -> t -> t
val inter : t -> t -> t
val diff : t -> t -> t
val symmetric_diff : t -> t -> (Elt.t, Elt.t) Either.t Sequence.t
val compare_direct : t -> t -> int
val equal : t -> t -> bool
val subset : t -> t -> bool
val fold_until :
t ->
init:'b ->
f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b
val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b
val iter2 :
t ->
t ->
f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] ->
unit) ->
unit
val filter : t -> f:(Elt.t -> bool) -> t
val partition_tf : t -> f:(Elt.t -> bool) -> t * t
val elements : t -> Elt.t list
val min_elt : t -> Elt.t option
val min_elt_exn : t -> Elt.t
val max_elt : t -> Elt.t option
val max_elt_exn : t -> Elt.t
val choose : t -> Elt.t option
val choose_exn : t -> Elt.t
val split : t -> Elt.t -> t * Elt.t option * t
val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list
val find_exn : t -> f:(Elt.t -> bool) -> Elt.t
val find_index : t -> int -> Elt.t option
val remove_index : t -> int -> t
val to_tree : t -> Tree.t
val to_sequence :
?order:[ `Decreasing | `Increasing ] ->
?greater_or_equal_to:Elt.t ->
?less_or_equal_to:Elt.t -> t -> Elt.t Sequence.t
val to_map :
t ->
f:(Elt.t -> 'data) ->
(Elt.t, 'data, Elt.comparator_witness) Core_set_intf.Map.t
val empty : t
val singleton : Elt.t -> t
val union_list : t list -> t
val of_list : Elt.t list -> t
val of_array : Elt.t array -> t
val of_sorted_array : Elt.t array -> t Or_error.t
val of_sorted_array_unchecked : Elt.t array -> t
val stable_dedup_list : Elt.t list -> Elt.t list
val map : ('a, 'b) Core_set.t -> f:('a -> Elt.t) -> t
val filter_map :
('a, 'b) Core_set.t -> f:('a -> Elt.t option) -> t
val of_tree : Tree.t -> t
val of_map_keys :
(Elt.t, 'a, Elt.comparator_witness) Core_set_intf.Map.t -> t
val t_of_sexp : Sexplib.Sexp.t -> t
val sexp_of_t : t -> Sexplib.Sexp.t
val compare : t -> t -> int
val bin_size_t : t Bin_prot.Size.sizer
val bin_write_t : t Bin_prot.Write.writer
val bin_read_t : t Bin_prot.Read.reader
val __bin_read_t__ : (int -> t) Bin_prot.Read.reader
val bin_writer_t : t Bin_prot.Type_class.writer
val bin_reader_t : t Bin_prot.Type_class.reader
val bin_t : t Bin_prot.Type_class.t
end
end
module Poly :
functor
(T : sig
type t
val t_of_sexp : Sexplib.Sexp.t -> Comparable.Poly.t
val sexp_of_t : Comparable.Poly.t -> Sexplib.Sexp.t
end) ->
sig
val ( >= ) : T.t -> T.t -> bool
val ( <= ) : T.t -> T.t -> bool
val ( = ) : T.t -> T.t -> bool
val ( > ) : T.t -> T.t -> bool
val ( < ) : T.t -> T.t -> bool
val ( <> ) : T.t -> T.t -> bool
val equal : T.t -> T.t -> bool
val compare : T.t -> T.t -> int
val min : T.t -> T.t -> T.t
val max : T.t -> T.t -> T.t
val ascending : T.t -> T.t -> int
val descending : T.t -> T.t -> int
val between : T.t -> low:T.t -> high:T.t -> bool
module Replace_polymorphic_compare :
sig
val ( >= ) : T.t -> T.t -> bool
val ( <= ) : T.t -> T.t -> bool
val ( = ) : T.t -> T.t -> bool
val ( > ) : T.t -> T.t -> bool
val ( < ) : T.t -> T.t -> bool
val ( <> ) : T.t -> T.t -> bool
val equal : T.t -> T.t -> bool
val compare : T.t -> T.t -> int
val min : T.t -> T.t -> T.t
val max : T.t -> T.t -> T.t
val _squelch_unused_module_warning_ : unit
end
type comparator_witness
val comparator : (T.t, comparator_witness) Comparator.comparator
val validate_lbound :
min:T.t Comparable_intf.bound -> T.t Validate.check
val validate_ubound :
max:T.t Comparable_intf.bound -> T.t Validate.check
val validate_bound :
min:T.t Comparable_intf.bound ->
max:T.t Comparable_intf.bound -> T.t Validate.check
module Map :
sig
module Key :
sig
type t = T.t
type comparator_witness = comparator_witness
val comparator :
(t, comparator_witness) Comparator.comparator
end
module Tree :
sig
type 'a t =
(Key.t, 'a, Key.comparator_witness) Core_map.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) Core_map.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 Set :
sig
module Elt :
sig
type t = T.t
type comparator_witness = comparator_witness
val comparator :
(t, comparator_witness) Comparator.comparator
val t_of_sexp : Sexplib.Sexp.t -> t
val sexp_of_t : t -> Sexplib.Sexp.t
end
module Tree :
sig
type t = (Elt.t, Elt.comparator_witness) Core_set.Tree.t
val length : t -> int
val is_empty : t -> bool
val iter : t -> f:(Elt.t -> unit) -> unit
val fold :
t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum
val exists : t -> f:(Elt.t -> bool) -> bool
val for_all : t -> f:(Elt.t -> bool) -> bool
val count : t -> f:(Elt.t -> bool) -> int
val sum :
(module Commutative_group.S with type t = 'sum) ->
t -> f:(Elt.t -> 'sum) -> 'sum
val find : t -> f:(Elt.t -> bool) -> Elt.t option
val find_map : t -> f:(Elt.t -> 'a option) -> 'a option
val to_list : t -> Elt.t list
val to_array : t -> Elt.t array
val invariants : t -> bool
val mem : t -> Elt.t -> bool
val add : t -> Elt.t -> t
val remove : t -> Elt.t -> t
val union : t -> t -> t
val inter : t -> t -> t
val diff : t -> t -> t
val symmetric_diff :
t -> t -> (Elt.t, Elt.t) Either.t Sequence.t
val compare_direct : t -> t -> int
val equal : t -> t -> bool
val subset : t -> t -> bool
val fold_until :
t ->
init:'b ->
f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b
val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b
val iter2 :
t ->
t ->
f:([ `Both of Elt.t * Elt.t
| `Left of Elt.t
| `Right of Elt.t ] -> unit) ->
unit
val filter : t -> f:(Elt.t -> bool) -> t
val partition_tf : t -> f:(Elt.t -> bool) -> t * t
val elements : t -> Elt.t list
val min_elt : t -> Elt.t option
val min_elt_exn : t -> Elt.t
val max_elt : t -> Elt.t option
val max_elt_exn : t -> Elt.t
val choose : t -> Elt.t option
val choose_exn : t -> Elt.t
val split : t -> Elt.t -> t * Elt.t option * t
val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list
val find_exn : t -> f:(Elt.t -> bool) -> Elt.t
val find_index : t -> int -> Elt.t option
val remove_index : t -> int -> t
val to_tree : t -> t
val to_sequence :
?order:[ `Decreasing | `Increasing ] ->
?greater_or_equal_to:Elt.t ->
?less_or_equal_to:Elt.t -> t -> Elt.t Sequence.t
val to_map :
t ->
f:(Elt.t -> 'data) ->
(Elt.t, 'data, Elt.comparator_witness) Core_set_intf.Map.t
val empty : t
val singleton : Elt.t -> t
val union_list : t list -> t
val of_list : Elt.t list -> t
val of_array : Elt.t array -> t
val of_sorted_array : Elt.t array -> t Or_error.t
val of_sorted_array_unchecked : Elt.t array -> t
val stable_dedup_list : Elt.t list -> Elt.t list
val map : ('a, 'b) Core_set.Tree.t -> f:('a -> Elt.t) -> t
val filter_map :
('a, 'b) Core_set.Tree.t -> f:('a -> Elt.t option) -> t
val of_tree : t -> t
val of_map_keys :
(Elt.t, 'a, Elt.comparator_witness) Core_set_intf.Map.t ->
t
val t_of_sexp : Sexplib.Sexp.t -> t
val sexp_of_t : t -> Sexplib.Sexp.t
val compare : t -> t -> int
end
type t = (Elt.t, Elt.comparator_witness) Core_set.t
val length : t -> int
val is_empty : t -> bool
val iter : t -> f:(Elt.t -> unit) -> unit
val fold :
t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum
val exists : t -> f:(Elt.t -> bool) -> bool
val for_all : t -> f:(Elt.t -> bool) -> bool
val count : t -> f:(Elt.t -> bool) -> int
val sum :
(module Commutative_group.S with type t = 'sum) ->
t -> f:(Elt.t -> 'sum) -> 'sum
val find : t -> f:(Elt.t -> bool) -> Elt.t option
val find_map : t -> f:(Elt.t -> 'a option) -> 'a option
val to_list : t -> Elt.t list
val to_array : t -> Elt.t array
val invariants : t -> bool
val mem : t -> Elt.t -> bool
val add : t -> Elt.t -> t
val remove : t -> Elt.t -> t
val union : t -> t -> t
val inter : t -> t -> t
val diff : t -> t -> t
val symmetric_diff : t -> t -> (Elt.t, Elt.t) Either.t Sequence.t
val compare_direct : t -> t -> int
val equal : t -> t -> bool
val subset : t -> t -> bool
val fold_until :
t ->
init:'b ->
f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b
val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b
val iter2 :
t ->
t ->
f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] ->
unit) ->
unit
val filter : t -> f:(Elt.t -> bool) -> t
val partition_tf : t -> f:(Elt.t -> bool) -> t * t
val elements : t -> Elt.t list
val min_elt : t -> Elt.t option
val min_elt_exn : t -> Elt.t
val max_elt : t -> Elt.t option
val max_elt_exn : t -> Elt.t
val choose : t -> Elt.t option
val choose_exn : t -> Elt.t
val split : t -> Elt.t -> t * Elt.t option * t
val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list
val find_exn : t -> f:(Elt.t -> bool) -> Elt.t
val find_index : t -> int -> Elt.t option
val remove_index : t -> int -> t
val to_tree : t -> Tree.t
val to_sequence :
?order:[ `Decreasing | `Increasing ] ->
?greater_or_equal_to:Elt.t ->
?less_or_equal_to:Elt.t -> t -> Elt.t Sequence.t
val to_map :
t ->
f:(Elt.t -> 'data) ->
(Elt.t, 'data, Elt.comparator_witness) Core_set_intf.Map.t
val empty : t
val singleton : Elt.t -> t
val union_list : t list -> t
val of_list : Elt.t list -> t
val of_array : Elt.t array -> t
val of_sorted_array : Elt.t array -> t Or_error.t
val of_sorted_array_unchecked : Elt.t array -> t
val stable_dedup_list : Elt.t list -> Elt.t list
val map : ('a, 'b) Core_set.t -> f:('a -> Elt.t) -> t
val filter_map :
('a, 'b) Core_set.t -> f:('a -> Elt.t option) -> t
val of_tree : Tree.t -> t
val of_map_keys :
(Elt.t, 'a, Elt.comparator_witness) Core_set_intf.Map.t -> t
val t_of_sexp : Sexplib.Sexp.t -> t
val sexp_of_t : t -> Sexplib.Sexp.t
val compare : t -> t -> int
end
end
module Validate :
functor
(T : sig
type t
val t_of_sexp : Sexplib.Sexp.t -> Comparable.Validate.t
val sexp_of_t : Comparable.Validate.t -> Sexplib.Sexp.t
val compare :
Comparable.Validate.t -> Comparable.Validate.t -> int
end) ->
sig
val validate_lbound :
min:T.t Comparable_intf.bound -> T.t Validate.check
val validate_ubound :
max:T.t Comparable_intf.bound -> T.t Validate.check
val validate_bound :
min:T.t Comparable_intf.bound ->
max:T.t Comparable_intf.bound -> T.t Validate.check
end
module With_zero :
functor
(T : sig
type t
val zero : Comparable.With_zero.t
val validate_lbound :
min:t Comparable_intf.bound -> t Validate.check
val validate_ubound :
max:t Comparable_intf.bound -> t Validate.check
val validate_bound :
min:t Comparable_intf.bound ->
max:t Comparable_intf.bound -> t Validate.check
val t_of_sexp : Sexplib.Sexp.t -> Comparable.With_zero.t
val sexp_of_t : Comparable.With_zero.t -> Sexplib.Sexp.t
val compare :
Comparable.With_zero.t -> Comparable.With_zero.t -> int
end) ->
sig
val validate_positive : T.t Validate.check
val validate_non_negative : T.t Validate.check
val validate_negative : T.t Validate.check
val validate_non_positive : T.t Validate.check
val is_positive : T.t -> bool
val is_non_negative : T.t -> bool
val is_negative : T.t -> bool
val is_non_positive : T.t -> bool
end
module Validate_with_zero :
functor
(T : sig
type t
val zero : Comparable.Validate_with_zero.t
val t_of_sexp :
Sexplib.Sexp.t -> Comparable.Validate_with_zero.t
val sexp_of_t :
Comparable.Validate_with_zero.t -> Sexplib.Sexp.t
val compare :
Comparable.Validate_with_zero.t ->
Comparable.Validate_with_zero.t -> int
end) ->
sig
val validate_lbound :
min:T.t Comparable_intf.bound -> T.t Validate.check
val validate_ubound :
max:T.t Comparable_intf.bound -> T.t Validate.check
val validate_bound :
min:T.t Comparable_intf.bound ->
max:T.t Comparable_intf.bound -> T.t Validate.check
val validate_positive : T.t Validate.check
val validate_non_negative : T.t Validate.check
val validate_negative : T.t Validate.check
val validate_non_positive : T.t Validate.check
val is_positive : T.t -> bool
val is_non_negative : T.t -> bool
val is_negative : T.t -> bool
val is_non_positive : T.t -> bool
end
module Check_sexp_conversion :
functor
(M : sig
type t
val ( >= ) : t -> t -> bool
val ( <= ) : t -> t -> bool
val ( = ) : t -> t -> bool
val ( > ) : t -> t -> bool
val ( < ) : t -> t -> bool
val ( <> ) : t -> t -> bool
val equal : t -> t -> bool
val compare : t -> t -> int
val min : t -> t -> t
val max : t -> t -> t
val ascending : t -> t -> int
val descending : t -> t -> int
val between : t -> low:t -> high:t -> bool
module Replace_polymorphic_compare :
sig
val ( >= ) : t -> t -> bool
val ( <= ) : t -> t -> bool
val ( = ) : t -> t -> bool
val ( > ) : t -> t -> bool
val ( < ) : t -> t -> bool
val ( <> ) : t -> t -> bool
val equal : t -> t -> bool
val compare : t -> t -> int
val min : t -> t -> t
val max : t -> t -> t
val _squelch_unused_module_warning_ : unit
end
type comparator_witness
val comparator : (t, comparator_witness) Comparator.comparator
val validate_lbound :
min:t Comparable_intf.bound -> t Validate.check
val validate_ubound :
max:t Comparable_intf.bound -> t Validate.check
val validate_bound :
min:t Comparable_intf.bound ->
max:t Comparable_intf.bound -> t Validate.check
module Map :
sig
module Key :
sig
type t = t
type comparator_witness = comparator_witness
val comparator :
(t, comparator_witness) Comparator.comparator
end
module Tree :
sig
type 'a t =
(Key.t, 'a, Key.comparator_witness) Core_map.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) Core_map.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 Set :
sig
module Elt :
sig
type t = t
type comparator_witness = comparator_witness
val comparator :
(t, comparator_witness) Comparator.comparator
val t_of_sexp : Sexplib.Sexp.t -> t
val sexp_of_t : t -> Sexplib.Sexp.t
end
module Tree :
sig
type t = (Elt.t, Elt.comparator_witness) Core_set.Tree.t
val length : t -> int
val is_empty : t -> bool
val iter : t -> f:(Elt.t -> unit) -> unit
val fold :
t ->
init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum
val exists : t -> f:(Elt.t -> bool) -> bool
val for_all : t -> f:(Elt.t -> bool) -> bool
val count : t -> f:(Elt.t -> bool) -> int
val sum :
(module Commutative_group.S with type t = 'sum) ->
t -> f:(Elt.t -> 'sum) -> 'sum
val find : t -> f:(Elt.t -> bool) -> Elt.t option
val find_map : t -> f:(Elt.t -> 'a option) -> 'a option
val to_list : t -> Elt.t list
val to_array : t -> Elt.t array
val invariants : t -> bool
val mem : t -> Elt.t -> bool
val add : t -> Elt.t -> t
val remove : t -> Elt.t -> t
val union : t -> t -> t
val inter : t -> t -> t
val diff : t -> t -> t
val symmetric_diff :
t -> t -> (Elt.t, Elt.t) Either.t Sequence.t
val compare_direct : t -> t -> int
val equal : t -> t -> bool
val subset : t -> t -> bool
val fold_until :
t ->
init:'b ->
f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) ->
'b
val fold_right :
t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b
val iter2 :
t ->
t ->
f:([ `Both of Elt.t * Elt.t
| `Left of Elt.t
| `Right of Elt.t ] -> unit) ->
unit
val filter : t -> f:(Elt.t -> bool) -> t
val partition_tf : t -> f:(Elt.t -> bool) -> t * t
val elements : t -> Elt.t list
val min_elt : t -> Elt.t option
val min_elt_exn : t -> Elt.t
val max_elt : t -> Elt.t option
val max_elt_exn : t -> Elt.t
val choose : t -> Elt.t option
val choose_exn : t -> Elt.t
val split : t -> Elt.t -> t * Elt.t option * t
val group_by :
t -> equiv:(Elt.t -> Elt.t -> bool) -> t list
val find_exn : t -> f:(Elt.t -> bool) -> Elt.t
val find_index : t -> int -> Elt.t option
val remove_index : t -> int -> t
val to_tree : t -> t
val to_sequence :
?order:[ `Decreasing | `Increasing ] ->
?greater_or_equal_to:Elt.t ->
?less_or_equal_to:Elt.t -> t -> Elt.t Sequence.t
val to_map :
t ->
f:(Elt.t -> 'data) ->
(Elt.t, 'data, Elt.comparator_witness)
Core_set_intf.Map.t
val empty : t
val singleton : Elt.t -> t
val union_list : t list -> t
val of_list : Elt.t list -> t
val of_array : Elt.t array -> t
val of_sorted_array : Elt.t array -> t Or_error.t
val of_sorted_array_unchecked : Elt.t array -> t
val stable_dedup_list : Elt.t list -> Elt.t list
val map :
('a, 'b) Core_set.Tree.t -> f:('a -> Elt.t) -> t
val filter_map :
('a, 'b) Core_set.Tree.t ->
f:('a -> Elt.t option) -> t
val of_tree : t -> t
val of_map_keys :
(Elt.t, 'a, Elt.comparator_witness)
Core_set_intf.Map.t -> t
val t_of_sexp : Sexplib.Sexp.t -> t
val sexp_of_t : t -> Sexplib.Sexp.t
val compare : t -> t -> int
end
type t = (Elt.t, Elt.comparator_witness) Core_set.t
val length : t -> int
val is_empty : t -> bool
val iter : t -> f:(Elt.t -> unit) -> unit
val fold :
t ->
init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum
val exists : t -> f:(Elt.t -> bool) -> bool
val for_all : t -> f:(Elt.t -> bool) -> bool
val count : t -> f:(Elt.t -> bool) -> int
val sum :
(module Commutative_group.S with type t = 'sum) ->
t -> f:(Elt.t -> 'sum) -> 'sum
val find : t -> f:(Elt.t -> bool) -> Elt.t option
val find_map : t -> f:(Elt.t -> 'a option) -> 'a option
val to_list : t -> Elt.t list
val to_array : t -> Elt.t array
val invariants : t -> bool
val mem : t -> Elt.t -> bool
val add : t -> Elt.t -> t
val remove : t -> Elt.t -> t
val union : t -> t -> t
val inter : t -> t -> t
val diff : t -> t -> t
val symmetric_diff :
t -> t -> (Elt.t, Elt.t) Either.t Sequence.t
val compare_direct : t -> t -> int
val equal : t -> t -> bool
val subset : t -> t -> bool
val fold_until :
t ->
init:'b ->
f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b
val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b
val iter2 :
t ->
t ->
f:([ `Both of Elt.t * Elt.t
| `Left of Elt.t
| `Right of Elt.t ] -> unit) ->
unit
val filter : t -> f:(Elt.t -> bool) -> t
val partition_tf : t -> f:(Elt.t -> bool) -> t * t
val elements : t -> Elt.t list
val min_elt : t -> Elt.t option
val min_elt_exn : t -> Elt.t
val max_elt : t -> Elt.t option
val max_elt_exn : t -> Elt.t
val choose : t -> Elt.t option
val choose_exn : t -> Elt.t
val split : t -> Elt.t -> t * Elt.t option * t
val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list
val find_exn : t -> f:(Elt.t -> bool) -> Elt.t
val find_index : t -> int -> Elt.t option
val remove_index : t -> int -> t
val to_tree : t -> Tree.t
val to_sequence :
?order:[ `Decreasing | `Increasing ] ->
?greater_or_equal_to:Elt.t ->
?less_or_equal_to:Elt.t -> t -> Elt.t Sequence.t
val to_map :
t ->
f:(Elt.t -> 'data) ->
(Elt.t, 'data, Elt.comparator_witness) Core_set_intf.Map.t
val empty : t
val singleton : Elt.t -> t
val union_list : t list -> t
val of_list : Elt.t list -> t
val of_array : Elt.t array -> t
val of_sorted_array : Elt.t array -> t Or_error.t
val of_sorted_array_unchecked : Elt.t array -> t
val stable_dedup_list : Elt.t list -> Elt.t list
val map : ('a, 'b) Core_set.t -> f:('a -> Elt.t) -> t
val filter_map :
('a, 'b) Core_set.t -> f:('a -> Elt.t option) -> t
val of_tree : Tree.t -> t
val of_map_keys :
(Elt.t, 'a, Elt.comparator_witness) Core_set_intf.Map.t ->
t
val t_of_sexp : Sexplib.Sexp.t -> t
val sexp_of_t : t -> Sexplib.Sexp.t
val compare : t -> t -> int
end
val examples : Comparable.Check_sexp_conversion.t list
val sexp_of_t :
Comparable.Check_sexp_conversion.t -> Sexplib.Sexp.t
end) ->
sig end
end`