Using_comparator (base.Base.Set.Using

type nonrec (!'elt, !'cmp) t = ('elt, 'cmp) t

val sexp_of_t : 
  ('elt -> Sexplib0.Sexp.t) ->
  ('cmp -> Sexplib0.Sexp.t) ->
  ('elt, 'cmp) t ->
  Sexplib0.Sexp.t

val t_of_sexp_direct : 
  comparator:('elt, 'cmp) Base__.Comparator.t ->
  (Sexplib0.Sexp.t -> 'elt) ->
  Sexplib0.Sexp.t ->
  ('elt, 'cmp) t

module Tree : sig ... end

val length : ('a, 'b) t -> int

val is_empty : ('a, 'b) t -> bool

val iter : ('a, 'b) t -> f:('a -> unit) -> unit

val fold : ('a, 'b) t -> init:'acc -> f:('acc -> 'a -> 'acc) -> 'acc

val fold_result : 
  ('a, 'b) t ->
  init:'acc ->
  f:('acc -> 'a -> ('acc, 'e) result) ->
  ('acc, 'e) result

val exists : ('a, 'b) t -> f:('a -> bool) -> bool

val for_all : ('a, 'b) t -> f:('a -> bool) -> bool

val count : ('a, 'b) t -> f:('a -> bool) -> int

val sum : 
  (module Base__Container_intf.Summable with type t = 'sum) ->
  ('a, 'b) t ->
  f:('a -> 'sum) ->
  'sum

val find : ('a, 'b) t -> f:('a -> bool) -> 'a option

val find_map : ('a, 'c) t -> f:('a -> 'b option) -> 'b option

val to_list : ('a, 'b) t -> 'a list

val to_array : ('a, 'b) t -> 'a array

val invariants : ('a, 'cmp) t -> bool

val mem : ('a, 'cmp) t -> 'a -> bool

val add : ('a, 'cmp) t -> 'a -> ('a, 'cmp) t

val remove : ('a, 'cmp) t -> 'a -> ('a, 'cmp) t

val union : ('a, 'cmp) t -> ('a, 'cmp) t -> ('a, 'cmp) t

val inter : ('a, 'cmp) t -> ('a, 'cmp) t -> ('a, 'cmp) t

val diff : ('a, 'cmp) t -> ('a, 'cmp) t -> ('a, 'cmp) t

val symmetric_diff : 
  ('a, 'cmp) t ->
  ('a, 'cmp) t ->
  ('a, 'a) Base__.Either0.t Base__.Sequence.t

val compare_direct : ('a, 'cmp) t -> ('a, 'cmp) t -> int

val equal : ('a, 'cmp) t -> ('a, 'cmp) t -> bool

val is_subset : ('a, 'cmp) t -> of_:('a, 'cmp) t -> bool

val are_disjoint : ('a, 'cmp) t -> ('a, 'cmp) t -> bool

module Named : sig ... end

val fold_until : 
  ('a, 'b) t ->
  init:'acc ->
  f:('acc -> 'a -> ('acc, 'final) Base__.Container.Continue_or_stop.t) ->
  finish:('acc -> 'final) ->
  'final

val fold_right : ('a, 'b) t -> init:'acc -> f:('a -> 'acc -> 'acc) -> 'acc

val iter2 : 
  ('a, 'cmp) t ->
  ('a, 'cmp) t ->
  f:([ `Both of 'a * 'a | `Left of 'a | `Right of 'a ] -> unit) ->
  unit

val filter : ('a, 'cmp) t -> f:('a -> bool) -> ('a, 'cmp) t

val partition_tf : 
  ('a, 'cmp) t ->
  f:('a -> bool) ->
  ('a, 'cmp) t * ('a, 'cmp) t

val elements : ('a, 'b) t -> 'a list

val min_elt : ('a, 'b) t -> 'a option

val min_elt_exn : ('a, 'b) t -> 'a

val max_elt : ('a, 'b) t -> 'a option

val max_elt_exn : ('a, 'b) t -> 'a

val choose : ('a, 'b) t -> 'a option

val choose_exn : ('a, 'b) t -> 'a

val split : ('a, 'cmp) t -> 'a -> ('a, 'cmp) t * 'a option * ('a, 'cmp) t

val split_le_gt : ('a, 'cmp) t -> 'a -> ('a, 'cmp) t * ('a, 'cmp) t

val split_lt_ge : ('a, 'cmp) t -> 'a -> ('a, 'cmp) t * ('a, 'cmp) t

val group_by : ('a, 'cmp) t -> equiv:('a -> 'a -> bool) -> ('a, 'cmp) t list

val find_exn : ('a, 'b) t -> f:('a -> bool) -> 'a

val nth : ('a, 'b) t -> int -> 'a option

val remove_index : ('a, 'cmp) t -> int -> ('a, 'cmp) t

val to_tree : ('a, 'cmp) t -> ('a, 'cmp) Tree.t

val to_sequence : 
  ?order:[ `Decreasing | `Increasing ] ->
  ?greater_or_equal_to:'a ->
  ?less_or_equal_to:'a ->
  ('a, 'cmp) t ->
  'a Base__.Sequence.t

val binary_search : 
  ('a, 'cmp) t ->
  compare:('a -> 'key -> int) ->
  [ `First_equal_to
  | `First_greater_than_or_equal_to
  | `First_strictly_greater_than
  | `Last_equal_to
  | `Last_less_than_or_equal_to
  | `Last_strictly_less_than ] ->
  'key ->
  'a option

val binary_search_segmented : 
  ('a, 'cmp) t ->
  segment_of:('a -> [ `Left | `Right ]) ->
  [ `First_on_right | `Last_on_left ] ->
  'a option

val merge_to_sequence : 
  ?order:[ `Decreasing | `Increasing ] ->
  ?greater_or_equal_to:'a ->
  ?less_or_equal_to:'a ->
  ('a, 'cmp) t ->
  ('a, 'cmp) t ->
  ('a, 'a) Base__Set_intf.Merge_to_sequence_element.t Base__.Sequence.t

val empty : comparator:('a, 'cmp) Base__.Comparator.t -> ('a, 'cmp) t

val singleton : comparator:('a, 'cmp) Base__.Comparator.t -> 'a -> ('a, 'cmp) t

val union_list : 
  comparator:('a, 'cmp) Base__.Comparator.t ->
  ('a, 'cmp) t list ->
  ('a, 'cmp) t

val of_list : 
  comparator:('a, 'cmp) Base__.Comparator.t ->
  'a list ->
  ('a, 'cmp) t

val of_sequence : 
  comparator:('a, 'cmp) Base__.Comparator.t ->
  'a Base__.Sequence.t ->
  ('a, 'cmp) t

val of_array : 
  comparator:('a, 'cmp) Base__.Comparator.t ->
  'a array ->
  ('a, 'cmp) t

val of_sorted_array : 
  comparator:('a, 'cmp) Base__.Comparator.t ->
  'a array ->
  (('a, 'cmp) t, Base__.Info.t) result

val of_sorted_array_unchecked : 
  comparator:('a, 'cmp) Base__.Comparator.t ->
  'a array ->
  ('a, 'cmp) t

val of_increasing_iterator_unchecked : 
  comparator:('a, 'cmp) Base__.Comparator.t ->
  len:int ->
  f:(int -> 'a) ->
  ('a, 'cmp) t

val stable_dedup_list : 
  comparator:('a, 'b) Base__.Comparator.t ->
  'a list ->
  'a list

val map : 
  comparator:('b, 'cmp) Base__.Comparator.t ->
  ('a, 'c) t ->
  f:('a -> 'b) ->
  ('b, 'cmp) t

val filter_map : 
  comparator:('b, 'cmp) Base__.Comparator.t ->
  ('a, 'c) t ->
  f:('a -> 'b option) ->
  ('b, 'cmp) t

val of_tree : 
  comparator:('a, 'cmp) Base__.Comparator.t ->
  ('a, 'cmp) Tree.t ->
  ('a, 'cmp) t

val comparator_s : 
  ('a, 'cmp) t ->
  (module Base__.Comparator.S
  with type comparator_witness = 'cmp
   and type t = 'a)

val comparator : ('a, 'cmp) t -> ('a, 'cmp) Base__.Comparator.t

val hash_fold_direct : 
  (Base_internalhash_types.state -> 'elt -> Base_internalhash_types.state) ->
  Base_internalhash_types.state ->
  ('elt, 'cmp) t ->
  Base_internalhash_types.state

module Empty_without_value_restriction (Elt : sig ... end) : sig ... end