`include Stdlib.Set.S with type elt = t`
`type elt = t`
`type t`
`val empty : t`
`val add : elt -> t -> t`
`val singleton : elt -> t`
`val remove : elt -> t -> t`
`val union : t -> t -> t`
`val inter : t -> t -> t`
`val disjoint : t -> t -> bool`
`val diff : t -> t -> t`
`val cardinal : t -> int`
`val elements : t -> elt list`
`val min_elt : t -> elt`
`val min_elt_opt : t -> elt option`
`val max_elt : t -> elt`
`val max_elt_opt : t -> elt option`
`val choose : t -> elt`
`val choose_opt : t -> elt option`
`val find : elt -> t -> elt`
`val find_opt : elt -> t -> elt option`
`val find_first : (elt -> bool) -> t -> elt`
`val find_first_opt : (elt -> bool) -> t -> elt option`
`val find_last : (elt -> bool) -> t -> elt`
`val find_last_opt : (elt -> bool) -> t -> elt option`
`val iter : (elt -> unit) -> t -> unit`
`val fold : (elt -> 'acc -> 'acc) -> t -> 'acc -> 'acc`
`val map : (elt -> elt) -> t -> t`
`val filter : (elt -> bool) -> t -> t`
`val filter_map : (elt -> elt option) -> t -> t`
`val partition : (elt -> bool) -> t -> t * t`
`val split : elt -> t -> t * bool * t`
`val is_empty : t -> bool`
`val mem : elt -> t -> bool`
`val equal : t -> t -> bool`
`val compare : t -> t -> int`
`val subset : t -> t -> bool`
`val for_all : (elt -> bool) -> t -> bool`
`val exists : (elt -> bool) -> t -> bool`
`val to_list : t -> elt list`
`val of_list : elt list -> t`
`val to_seq_from : elt -> t -> elt Stdlib.Seq.t`
`val to_seq : t -> elt Stdlib.Seq.t`
`val to_rev_seq : t -> elt Stdlib.Seq.t`
`val add_seq : elt Stdlib.Seq.t -> t -> t`
`val of_seq : elt Stdlib.Seq.t -> t`
`val compare_cardinal_with : t -> int -> int`

`compare_cardinal_with s n` is equivalent to `compare (cardinal s) n` but runs in O(min(n, cardinal s)) time instead of O(cardinal s).

`val to_list_bounded : int -> t -> elt list option`

`to_list_bounded n s` returns `Some l` if `s` has at most `n` elements, where `l` is the sorted list of all elements. Returns `None` if `s` has more than `n` elements. Traverses at most `n+1` elements.