# Module type Core_set_intf.Accessors0

    module type Accessors0 = sig .. end

    include Container.S0

    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) 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 -> [ `Continue of 'b | `Stop of 'b ]) -> 'b

    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

    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 Sequence.t

    val to_map : t ->
           f:(elt -> 'data) ->
           (elt, 'data, comparator_witness) Map.t