functor
  (Elt : sig
           type t
           type comparator_witness
           val comparator : (t, comparator_witness) Comparator.comparator
           val t_of_sexp :
             Sexplib.Sexp.t -> Core_set.Make_binable_using_comparator.t
           val sexp_of_t :
             Core_set.Make_binable_using_comparator.t -> Sexplib.Sexp.t
           val bin_t :
             Core_set.Make_binable_using_comparator.t Bin_prot.Type_class.t
           val bin_read_t :
             Core_set.Make_binable_using_comparator.t Bin_prot.Read.reader
           val __bin_read_t__ :
             (int -> Core_set.Make_binable_using_comparator.t)
             Bin_prot.Read.reader
           val bin_reader_t :
             Core_set.Make_binable_using_comparator.t
             Bin_prot.Type_class.reader
           val bin_size_t :
             Core_set.Make_binable_using_comparator.t Bin_prot.Size.sizer
           val bin_write_t :
             Core_set.Make_binable_using_comparator.t Bin_prot.Write.writer
           val bin_writer_t :
             Core_set.Make_binable_using_comparator.t
             Bin_prot.Type_class.writer
         end->
  sig
    module Elt :
      sig
        type t = Elt.t
        type comparator_witness = Elt.comparator_witness
        val comparator : (t, comparator_witness) Comparator.comparator
        val t_of_sexp : Sexplib.Sexp.t -> t
        val sexp_of_t : t -> Sexplib.Sexp.t
      end
    module Tree :
      sig
        type t = (Elt.t, Elt.comparator_witness) Tree.t
        val length : t -> int
        val is_empty : t -> bool
        val iter : t -> f:(Elt.t -> unit) -> unit
        val fold :
          t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum
        val exists : t -> f:(Elt.t -> bool) -> bool
        val for_all : t -> f:(Elt.t -> bool) -> bool
        val count : t -> f:(Elt.t -> bool) -> int
        val sum :
          (module Commutative_group.S with type t = 'sum) ->
          t -> f:(Elt.t -> 'sum) -> 'sum
        val find : t -> f:(Elt.t -> bool) -> Elt.t option
        val find_map : t -> f:(Elt.t -> 'a option) -> 'a option
        val to_list : t -> Elt.t list
        val to_array : t -> Elt.t array
        val invariants : t -> bool
        val mem : t -> Elt.t -> bool
        val add : t -> Elt.t -> t
        val remove : t -> Elt.t -> t
        val union : t -> t -> t
        val inter : t -> t -> t
        val diff : t -> t -> t
        val symmetric_diff : t -> t -> (Elt.t, Elt.t) 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:'->
          f:('-> Elt.t -> [ `Continue of '| `Stop of 'b ]) -> 'b
        val fold_right : t -> init:'-> f:(Elt.t -> '-> 'b) -> 'b
        val iter2 :
          t ->
          t ->
          f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] ->
             unit) ->
          unit
        val filter : t -> f:(Elt.t -> bool) -> t
        val partition_tf : t -> f:(Elt.t -> bool) -> t * t
        val elements : t -> Elt.t list
        val min_elt : t -> Elt.t option
        val min_elt_exn : t -> Elt.t
        val max_elt : t -> Elt.t option
        val max_elt_exn : t -> Elt.t
        val choose : t -> Elt.t option
        val choose_exn : t -> Elt.t
        val split : t -> Elt.t -> t * Elt.t option * t
        val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list
        val find_exn : t -> f:(Elt.t -> bool) -> Elt.t
        val find_index : t -> int -> Elt.t option
        val remove_index : t -> int -> t
        val to_tree : t -> t
        val to_sequence :
          ?order:[ `Decreasing | `Increasing ] ->
          ?greater_or_equal_to:Elt.t ->
          ?less_or_equal_to:Elt.t -> t -> Elt.t Sequence.t
        val to_map :
          t ->
          f:(Elt.t -> 'data) ->
          (Elt.t, 'data, Elt.comparator_witness) Core_set_intf.Map.t
        val empty : t
        val singleton : Elt.t -> t
        val union_list : t list -> t
        val of_list : Elt.t list -> t
        val of_array : Elt.t array -> t
        val of_sorted_array : Elt.t array -> t Or_error.t
        val of_sorted_array_unchecked : Elt.t array -> t
        val stable_dedup_list : Elt.t list -> Elt.t list
        val map : ('a, 'b) Tree.t -> f:('-> Elt.t) -> t
        val filter_map : ('a, 'b) Tree.t -> f:('-> Elt.t option) -> t
        val of_tree : t -> t
        val of_map_keys :
          (Elt.t, 'a, Elt.comparator_witness) Core_set_intf.Map.t -> t
        val t_of_sexp : Sexplib.Sexp.t -> t
        val sexp_of_t : t -> Sexplib.Sexp.t
        val compare : t -> t -> int
      end
    type t = (Elt.t, Elt.comparator_witness) t
    val length : t -> int
    val is_empty : t -> bool
    val iter : t -> f:(Elt.t -> unit) -> unit
    val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum
    val exists : t -> f:(Elt.t -> bool) -> bool
    val for_all : t -> f:(Elt.t -> bool) -> bool
    val count : t -> f:(Elt.t -> bool) -> int
    val sum :
      (module Commutative_group.S with type t = 'sum) ->
      t -> f:(Elt.t -> 'sum) -> 'sum
    val find : t -> f:(Elt.t -> bool) -> Elt.t option
    val find_map : t -> f:(Elt.t -> 'a option) -> 'a option
    val to_list : t -> Elt.t list
    val to_array : t -> Elt.t array
    val invariants : t -> bool
    val mem : t -> Elt.t -> bool
    val add : t -> Elt.t -> t
    val remove : t -> Elt.t -> t
    val union : t -> t -> t
    val inter : t -> t -> t
    val diff : t -> t -> t
    val symmetric_diff : t -> t -> (Elt.t, Elt.t) 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:'-> f:('-> Elt.t -> [ `Continue of '| `Stop of 'b ]) -> 'b
    val fold_right : t -> init:'-> f:(Elt.t -> '-> 'b) -> 'b
    val iter2 :
      t ->
      t ->
      f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] ->
         unit) ->
      unit
    val filter : t -> f:(Elt.t -> bool) -> t
    val partition_tf : t -> f:(Elt.t -> bool) -> t * t
    val elements : t -> Elt.t list
    val min_elt : t -> Elt.t option
    val min_elt_exn : t -> Elt.t
    val max_elt : t -> Elt.t option
    val max_elt_exn : t -> Elt.t
    val choose : t -> Elt.t option
    val choose_exn : t -> Elt.t
    val split : t -> Elt.t -> t * Elt.t option * t
    val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list
    val find_exn : t -> f:(Elt.t -> bool) -> Elt.t
    val find_index : t -> int -> Elt.t option
    val remove_index : t -> int -> t
    val to_tree : t -> Tree.t
    val to_sequence :
      ?order:[ `Decreasing | `Increasing ] ->
      ?greater_or_equal_to:Elt.t ->
      ?less_or_equal_to:Elt.t -> t -> Elt.t Sequence.t
    val to_map :
      t ->
      f:(Elt.t -> 'data) ->
      (Elt.t, 'data, Elt.comparator_witness) Core_set_intf.Map.t
    val empty : t
    val singleton : Elt.t -> t
    val union_list : t list -> t
    val of_list : Elt.t list -> t
    val of_array : Elt.t array -> t
    val of_sorted_array : Elt.t array -> t Or_error.t
    val of_sorted_array_unchecked : Elt.t array -> t
    val stable_dedup_list : Elt.t list -> Elt.t list
    val map : ('a, 'b) t -> f:('-> Elt.t) -> t
    val filter_map : ('a, 'b) t -> f:('-> Elt.t option) -> t
    val of_tree : Tree.t -> t
    val of_map_keys :
      (Elt.t, 'a, Elt.comparator_witness) Core_set_intf.Map.t -> t
    val t_of_sexp : Sexplib.Sexp.t -> t
    val sexp_of_t : t -> Sexplib.Sexp.t
    val compare : t -> t -> int
    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
    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
  end