Poly (stanc.Core.Set.Poly)

type !'elt t = ('elt, Base__.Comparator.Poly.comparator_witness) Base__Set.t

val length : 'a t -> int

val is_empty : 'a t -> bool

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

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

val fold_result : 
  'a t ->
  init:'acc ->
  f:('acc -> 'a -> ('acc, 'e) Base__.Result.t) ->
  ('acc, 'e) Base__.Result.t

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

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

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

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

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

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

val to_list : 'a t -> 'a list

val to_array : 'a t -> 'a array

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

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

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

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

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

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

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

val symmetric_diff : 
  ('a, 'cmp, 'a t -> 'a t -> ('a, 'a) Base__.Either.t Base__.Sequence.t)
    Base__Set_intf.Without_comparator.t

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

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

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

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

module Named : sig ... end

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

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

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

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

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

val elements : 'a t -> 'a list

val min_elt : 'a t -> 'a option

val min_elt_exn : 'a t -> 'a

val max_elt : 'a t -> 'a option

val max_elt_exn : 'a t -> 'a

val choose : 'a t -> 'a option

val choose_exn : 'a t -> 'a

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

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

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

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

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

val nth : 'a t -> int -> 'a option

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

val to_tree : 
  'a t ->
  ('a, Base__.Comparator.Poly.comparator_witness)
    Base__Set.Using_comparator.Tree.t

val to_sequence : 
  ('a,
    'cmp,
    ?order:??? ->
    ?greater_or_equal_to:??? ->
    ?less_or_equal_to:??? ->
    'a t ->
    'a Base__.Sequence.t)
    Base__Set_intf.Without_comparator.t

val binary_search : 
  ('a,
    'cmp,
    'a t ->
    compare:('a -> 'key -> int) ->
    Base__.Binary_searchable.Which_target_by_key.t ->
    'key ->
    'a option)
    Base__Set_intf.Without_comparator.t

val binary_search_segmented : 
  ('a,
    'cmp,
    'a t ->
    segment_of:('a -> [ `Left | `Right ]) ->
    Base__.Binary_searchable.Which_target_by_segment.t ->
    'a option)
    Base__Set_intf.Without_comparator.t

val merge_to_sequence : 
  ('a,
    'cmp,
    ?order:??? ->
    ?greater_or_equal_to:??? ->
    ?less_or_equal_to:??? ->
    'a t ->
    'a t ->
    ('a, 'a) Base__Set_intf.Merge_to_sequence_element.t Base__.Sequence.t)
    Base__Set_intf.Without_comparator.t

val empty : ('a, 'cmp, 'a t) Base__Set_intf.Without_comparator.t

val singleton : ('a, 'cmp, 'a -> 'a t) Base__Set_intf.Without_comparator.t

val union_list : 
  ('a, 'cmp, 'a t list -> 'a t) Base__Set_intf.Without_comparator.t

val of_list : ('a, 'cmp, 'a list -> 'a t) Base__Set_intf.Without_comparator.t

val of_sequence : 
  ('a, 'cmp, 'a Base__.Sequence.t -> 'a t) Base__Set_intf.Without_comparator.t

val of_array : ('a, 'cmp, 'a array -> 'a t) Base__Set_intf.Without_comparator.t

val of_sorted_array : 
  ('a, 'cmp, 'a array -> 'a t Base__.Or_error.t)
    Base__Set_intf.Without_comparator.t

val of_sorted_array_unchecked : 
  ('a, 'cmp, 'a array -> 'a t) Base__Set_intf.Without_comparator.t

val of_increasing_iterator_unchecked : 
  ('a, 'cmp, len:int -> f:(int -> 'a) -> 'a t)
    Base__Set_intf.Without_comparator.t

val stable_dedup_list : 
  ('a, 'b, 'a list -> 'a list) Base__Set_intf.Without_comparator.t

deprecated [since 2023-04] Use [List.stable_dedup] instead.

val map : 
  ('b, 'cmp, ('a, 'c) Base__Set.t -> f:('a -> 'b) -> 'b t)
    Base__Set_intf.Without_comparator.t

val filter_map : 
  ('b, 'cmp, ('a, 'c) Base__Set.t -> f:('a -> 'b option) -> 'b t)
    Base__Set_intf.Without_comparator.t

val of_tree : 
  ('a,
    'cmp,
    ('a, Base__.Comparator.Poly.comparator_witness)
      Base__Set.Using_comparator.Tree.t ->
    'a t)
    Base__Set_intf.Without_comparator.t

val sexp_of_t : 
  ('a -> Sexplib0__.Sexp.t) ->
  ('a, 'b) Base.Set.t ->
  Sexplib0__.Sexp.t