`module Elt : sig ... end with type t = t and type comparator_witness = comparator_witness`
`include Core_kernel.Set_intf.S with module Elt := Elt`
`module Elt : sig ... end`
`module Tree : sig ... end`
`include Core_kernel.Set_intf.S_plain with module Elt := Elt and module Tree := Tree`
`module Elt : sig ... end`
`module Tree : Core_kernel.Set_intf.Make_S_plain_tree(Elt).S`
`type t``= (Elt.t, Elt.comparator_witness) Base.Set.t```
`include sig ... end`
`val compare : t ‑> t ‑> Core_kernel__.Import.int`
`val sexp_of_t : t ‑> Base.Sexp.t`
`type named``= (Elt.t, Elt.comparator_witness) Core_kernel.Set_intf.Named.t```
`include Core_kernel.Set_intf.Creators_and_accessors0 with type (a, b) set := (a, b) Base.Set.t with type t := t with type tree := Tree.t with type elt := Elt.t with type named := named with type comparator_witness := Elt.comparator_witness`
`include Core_kernel.Set_intf.Accessors0`
`include Core_kernel.Set_intf.Set.Accessors0`
`type t`````
`type elt`````
`val length : t ‑> int`
`val is_empty : t ‑> bool`
`val iter : t ‑> f:(elt ‑> unit) ‑> unit`
`val fold : t ‑> init:'accum ‑> f:('accum ‑> elt ‑> 'accum) ‑> 'accum`
`val fold_result : t ‑> init:'accum ‑> f:('accum ‑> elt ‑> ('accum, 'e) Base.Result.t) ‑> ('accum, 'e) Base.Result.t`
`val exists : t ‑> f:(elt ‑> bool) ‑> bool`
`val for_all : t ‑> f:(elt ‑> bool) ‑> bool`
`val count : t ‑> f:(elt ‑> bool) ‑> int`
`val sum : (module Base.Commutative_group.S with type t = 'sum) ‑> t ‑> f:(elt ‑> 'sum) ‑> 'sum`
`val find : t ‑> f:(elt ‑> bool) ‑> elt option`
`val find_map : t ‑> f:(elt ‑> 'a option) ‑> 'a option`
`val to_list : t ‑> elt list`
`val to_array : t ‑> elt array`
`type tree`````
`type comparator_witness`````
`val invariants : t ‑> bool`
`val mem : t ‑> elt ‑> bool`
`val add : t ‑> elt ‑> t`
`val remove : t ‑> elt ‑> t`
`val union : t ‑> t ‑> t`
`val inter : t ‑> t ‑> t`
`val diff : t ‑> t ‑> t`
`val symmetric_diff : t ‑> t ‑> (elt, elt) Base.Either.t Base.Sequence.t`
`val compare_direct : t ‑> t ‑> int`
`val equal : t ‑> t ‑> bool`
`val is_subset : t ‑> of_:t ‑> bool`
`val subset : t ‑> t ‑> bool`

- Deprecated [since 2016-09] Replace [Set.subset t1 t2] with [Set.is_subset t1 ~of_:t2]

`type named`````
`module Named : sig ... end`
`val fold_until : t ‑> init:'b ‑> f:('b ‑> elt ‑> ('b, 'final) Base__.Set_intf.Continue_or_stop.t) ‑> finish:('b ‑> 'final) ‑> 'final`
`val fold_right : t ‑> init:'b ‑> f:(elt ‑> 'b ‑> 'b) ‑> 'b`
`val iter2 : t ‑> t ‑> f:([ `Both of elt * elt | `Left of elt | `Right of elt ] ‑> unit) ‑> unit`
`val filter : t ‑> f:(elt ‑> bool) ‑> t`
`val partition_tf : t ‑> f:(elt ‑> bool) ‑> t * t`
`val elements : t ‑> elt list`
`val min_elt : t ‑> elt option`
`val min_elt_exn : t ‑> elt`
`val max_elt : t ‑> elt option`
`val max_elt_exn : t ‑> elt`
`val choose : t ‑> elt option`
`val choose_exn : t ‑> elt`
`val split : t ‑> elt ‑> t * elt option * t`
`val group_by : t ‑> equiv:(elt ‑> elt ‑> bool) ‑> t list`
`val find_exn : t ‑> f:(elt ‑> bool) ‑> elt`
`val find_index : t ‑> int ‑> elt option`

- Deprecated [since 2016-10] Use [nth]

`val nth : t ‑> int ‑> elt option`
`val remove_index : t ‑> int ‑> t`
`val to_tree : t ‑> tree`
`val to_sequence : ?⁠order:[ `Decreasing | `Increasing ] ‑> ?⁠greater_or_equal_to:elt ‑> ?⁠less_or_equal_to:elt ‑> t ‑> elt Base.Sequence.t`
`val merge_to_sequence : ?⁠order:[ `Decreasing | `Increasing ] ‑> ?⁠greater_or_equal_to:elt ‑> ?⁠less_or_equal_to:elt ‑> t ‑> t ‑> (elt, elt) Base__.Set_intf.Merge_to_sequence_element.t Base.Sequence.t`
`val to_map : t ‑> f:(elt ‑> 'data) ‑> (elt, 'data, comparator_witness) Core_kernel.Map.t`
`val obs : elt Core_kernel.Quickcheck.Observer.t ‑> t Core_kernel.Quickcheck.Observer.t`
`val shrinker : elt Core_kernel.Quickcheck.Shrinker.t ‑> t Core_kernel.Quickcheck.Shrinker.t`
`include Core_kernel.Set_intf.Creators0 with type t := t with type tree := tree with type elt := elt with type comparator_witness := comparator_witness`
`include Core_kernel.Set_intf.Set.Creators0`
`type ('a, 'cmp) set`````
`type t`````
`type tree`````
`type elt`````
`type comparator_witness`````
`val empty : t`
`val singleton : elt ‑> t`
`val union_list : t list ‑> t`
`val of_list : elt list ‑> t`
`val of_array : elt array ‑> t`
`val of_sorted_array : elt array ‑> t Base.Or_error.t`
`val of_sorted_array_unchecked : elt array ‑> t`
`val of_increasing_iterator_unchecked : len:int ‑> f:(int ‑> elt) ‑> t`
`val stable_dedup_list : elt list ‑> elt list`
`val map : ('a, 'b) set ‑> f:('a ‑> elt) ‑> t`
`val filter_map : ('a, 'b) set ‑> f:('a ‑> elt option) ‑> t`
`val of_tree : tree ‑> t`
`val of_hash_set : elt Core_kernel.Hash_set.t ‑> t`
`val of_hashtbl_keys : (elt, _) Core_kernel.Hashtbl.t ‑> t`
`val of_map_keys : (elt, _, comparator_witness) Core_kernel.Map.t ‑> t`
`val gen : elt Core_kernel.Quickcheck.Generator.t ‑> t Core_kernel.Quickcheck.Generator.t`
`module Provide_of_sexp : functor (Elt : sig ... end with type t := Elt.t) -> sig ... end with type t := t`
`module Provide_bin_io : functor (Elt : sig ... end with type t := Elt.t) -> Core_kernel.Set_intf.Binable.S with type t := t`
`module Provide_hash : functor (Elt : Core_kernel__.Import.Hasher.S with type t := Elt.t) -> sig ... end with type t := t`
`include Core_kernel.Sexpable.S with type t := t`
`type t`````
`val t_of_sexp : Base.Sexp.t ‑> t`
`val sexp_of_t : t ‑> Base.Sexp.t`
`include Core_kernel.Set_intf.Binable.S with type t := t`
`type t`````
`include Core_kernel.Set_intf.Binable.S_only_functions with type t := t`
`type t`````
`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`

This function only needs implementation if `t` exposed to be a polymorphic variant. Despite what the type reads, this does *not* produce a function after reading; instead it takes the constructor tag (int) before reading and reads the rest of the variant `t` afterwards.

`val bin_shape_t : Bin_prot.Shape.t`
`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`