sig
  module Raw :
    sig
      type ('base, 'set) t = private
          Base of 'base
        | Set of 'set
        | Union of ('base, 'set) Set_lang.Raw.t *
            ('base, 'set) Set_lang.Raw.t
        | Inter of ('base, 'set) Set_lang.Raw.t *
            ('base, 'set) Set_lang.Raw.t
        | Diff of ('base, 'set) Set_lang.Raw.t * ('base, 'set) Set_lang.Raw.t
      val compare :
        ('base -> 'base -> int) ->
        ('set -> 'set -> int) ->
        ('base, 'set) Set_lang.Raw.t -> ('base, 'set) Set_lang.Raw.t -> int
    end
  type ('base, 'elt, 'cmp) t =
      ('base, ('elt, 'cmp) Core.Std.Set.t) Set_lang.Raw.t
  val base : 'base -> ('base, 'a, 'b) Set_lang.t
  val set : ('elt, 'cmp) Core.Std.Set.t -> ('a, 'elt, 'cmp) Set_lang.t
  val inter2 :
    ('b, 'e, 'c) Set_lang.t ->
    ('b, 'e, 'c) Set_lang.t -> ('b, 'e, 'c) Set_lang.t
  val union2 :
    ('b, 'e, 'c) Set_lang.t ->
    ('b, 'e, 'c) Set_lang.t -> ('b, 'e, 'c) Set_lang.t
  val diff :
    ('b, 'e, 'c) Set_lang.t ->
    ('b, 'e, 'c) Set_lang.t -> ('b, 'e, 'c) Set_lang.t
  val union :
    ('b, 'e, 'c) Set_lang.t * ('b, 'e, 'c) Set_lang.t list ->
    ('b, 'e, 'c) Set_lang.t
  val inter :
    ('b, 'e, 'c) Set_lang.t * ('b, 'e, 'c) Set_lang.t list ->
    ('b, 'e, 'c) Set_lang.t
  val union_list :
    ('b, 'e, 'c) Set_lang.t list ->
    ('b, 'e, 'c) Set_lang.t Core.Std.Or_error.t
  val inter_list :
    ('b, 'e, 'c) Set_lang.t list ->
    ('b, 'e, 'c) Set_lang.t Core.Std.Or_error.t
  val union_list_exn :
    ('b, 'e, 'c) Set_lang.t list -> ('b, 'e, 'c) Set_lang.t
  val inter_list_exn :
    ('b, 'e, 'c) Set_lang.t list -> ('b, 'e, 'c) Set_lang.t
  val values : ('base, 'a, 'b) Set_lang.t -> 'base list
  val constant_value :
    ('a, 'elt, 'cmp) Set_lang.t -> ('elt, 'cmp) Core.Std.Set.t option
  val subst :
    ('b1, 'e, 'c) Set_lang.t ->
    f:('b1 -> ('b2, 'e, 'c) Set_lang.t) -> ('b2, 'e, 'c) Set_lang.t
  val map :
    ('b1, 'e, 'c) Set_lang.t -> f:('b1 -> 'b2) -> ('b2, 'e, 'c) Set_lang.t
  val specialize :
    ('b, 'e, 'c) Set_lang.t ->
    f:('-> ('e, 'c) Core.Std.Set.t option) -> ('b, 'e, 'c) Set_lang.t
  val eval :
    ('b, 'e, 'c) Set_lang.t ->
    f:('-> ('e, 'c) Core.Std.Set.t) -> ('e, 'c) Core.Std.Set.t
  val invariant : ('base, 'elt, 'cmp) Set_lang.t -> unit
  module Make_monadic_eval :
    functor (M : Core.Std.Monad.S->
      sig
        val subst :
          ('b, 'e, 'c) Set_lang.t ->
          f:('-> ('b, 'e, 'c) Set_lang.t M.t) ->
          ('b, 'e, 'c) Set_lang.t M.t
        val map :
          ('b, 'e, 'c) Set_lang.t ->
          f:('-> 'M.t) -> ('b, 'e, 'c) Set_lang.t M.t
        val specialize :
          ('b, 'e, 'c) Set_lang.t ->
          f:('-> ('e, 'c) Core.Std.Set.t option M.t) ->
          ('b, 'e, 'c) Set_lang.t M.t
        val eval :
          ('b, 'e, 'c) Set_lang.t ->
          f:('-> ('e, 'c) Core.Std.Set.t M.t) ->
          ('e, 'c) Core.Std.Set.t M.t
      end
  module type S =
    sig
      module Set : Core.Std.Set.S
      type 'base t = ('base, Set.t) Raw.t
      val base : 'base -> 'base t
      val set : Set.t -> 'a t
      val inter2 : 'b t -> 'b t -> 'b t
      val union2 : 'b t -> 'b t -> 'b t
      val diff : 'b t -> 'b t -> 'b t
      val union : 'b t list -> 'b t
      val inter : 'b t * 'b t list -> 'b t
      val inter_list : 'b t list -> 'b t Core.Std.Or_error.t
      val inter_list_exn : 'b t list -> 'b t
      val values : 'base t -> 'base list
      val constant_value : 'a t -> Set.t option
      val subst :
        'b1 t ->
        f:('b1 -> 'b2 t Set_lang_intf.value) -> 'b2 t Set_lang_intf.value
      val map :
        'b1 t ->
        f:('b1 -> 'b2 Set_lang_intf.value) -> 'b2 t Set_lang_intf.value
      val specialize :
        'b t ->
        f:('-> Set.t option Set_lang_intf.value) ->
        'b t Set_lang_intf.value
      val eval :
        'b t ->
        f:('-> Set.t Set_lang_intf.value) -> Set.t Set_lang_intf.value
      module Make_monadic_eval :
        functor (M : Core.Std.Monad.S->
          sig
            val subst : 'b1 t -> f:('b1 -> 'b2 t M.t) -> 'b2 t M.t
            val map : 'b1 t -> f:('b1 -> 'b2 M.t) -> 'b2 t M.t
            val specialize : 'b t -> f:('-> Set.t option M.t) -> 'b t M.t
            val eval : 'b t -> f:('-> Set.t M.t) -> Set.t M.t
          end
      val t_of_sexp : (Sexplib.Sexp.t -> 'base) -> Sexplib.Sexp.t -> 'base t
      val sexp_of_t : ('base -> Sexplib.Sexp.t) -> 'base t -> Sexplib.Sexp.t
      val compare : ('base -> 'base -> int) -> 'base t -> 'base t -> int
    end
  module type S_binable =
    sig
      module Set : Core.Std.Set.S_binable
      type 'base t = ('base, Set.t) Raw.t
      val base : 'base -> 'base t
      val set : Set.t -> 'a t
      val inter2 : 'b t -> 'b t -> 'b t
      val union2 : 'b t -> 'b t -> 'b t
      val diff : 'b t -> 'b t -> 'b t
      val union : 'b t list -> 'b t
      val inter : 'b t * 'b t list -> 'b t
      val inter_list : 'b t list -> 'b t Core.Std.Or_error.t
      val inter_list_exn : 'b t list -> 'b t
      val values : 'base t -> 'base list
      val constant_value : 'a t -> Set.t option
      val subst :
        'b1 t ->
        f:('b1 -> 'b2 t Set_lang_intf.value) -> 'b2 t Set_lang_intf.value
      val map :
        'b1 t ->
        f:('b1 -> 'b2 Set_lang_intf.value) -> 'b2 t Set_lang_intf.value
      val specialize :
        'b t ->
        f:('-> Set.t option Set_lang_intf.value) ->
        'b t Set_lang_intf.value
      val eval :
        'b t ->
        f:('-> Set.t Set_lang_intf.value) -> Set.t Set_lang_intf.value
      module Make_monadic_eval :
        functor (M : Core.Std.Monad.S->
          sig
            val subst : 'b1 t -> f:('b1 -> 'b2 t M.t) -> 'b2 t M.t
            val map : 'b1 t -> f:('b1 -> 'b2 M.t) -> 'b2 t M.t
            val specialize : 'b t -> f:('-> Set.t option M.t) -> 'b t M.t
            val eval : 'b t -> f:('-> Set.t M.t) -> Set.t M.t
          end
      val bin_t :
        'base Core.Std.Bin_prot.Type_class.t ->
        'base t Core.Std.Bin_prot.Type_class.t
      val bin_read_t :
        'base Core.Std.Bin_prot.Read.reader ->
        'base t Core.Std.Bin_prot.Read.reader
      val __bin_read_t__ :
        'base Core.Std.Bin_prot.Read.reader ->
        (int -> 'base t) Core.Std.Bin_prot.Read.reader
      val bin_reader_t :
        'base Core.Std.Bin_prot.Type_class.reader ->
        'base t Core.Std.Bin_prot.Type_class.reader
      val bin_size_t :
        'base Core.Std.Bin_prot.Size.sizer ->
        'base t Core.Std.Bin_prot.Size.sizer
      val bin_write_t :
        'base Core.Std.Bin_prot.Write.writer ->
        'base t Core.Std.Bin_prot.Write.writer
      val bin_writer_t :
        'base Core.Std.Bin_prot.Type_class.writer ->
        'base t Core.Std.Bin_prot.Type_class.writer
      val t_of_sexp : (Sexplib.Sexp.t -> 'base) -> Sexplib.Sexp.t -> 'base t
      val sexp_of_t : ('base -> Sexplib.Sexp.t) -> 'base t -> Sexplib.Sexp.t
      val compare : ('base -> 'base -> int) -> 'base t -> 'base t -> int
    end
  module Make :
    functor (Elt : Core.Std.Comparable.S->
      sig
        module Set :
          sig
            module Elt :
              sig
                type t = Elt.t
                type comparator_witness = Elt.comparator_witness
                val comparator :
                  (t, comparator_witness) Core_kernel.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)
                    Core_kernel.Core_set.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 Core_kernel.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) Core_kernel.Either.t Core_kernel.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 Core_kernel.Sequence.t
                val to_map :
                  t ->
                  f:(Elt.t -> 'data) ->
                  (Elt.t, 'data, Elt.comparator_witness)
                  Core_kernel.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 Core_kernel.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) Core_kernel.Core_set.Tree.t ->
                  f:('-> Elt.t) -> t
                val filter_map :
                  ('a, 'b) Core_kernel.Core_set.Tree.t ->
                  f:('-> Elt.t option) -> t
                val of_tree : t -> t
                val of_map_keys :
                  (Elt.t, 'a, Elt.comparator_witness)
                  Core_kernel.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) Core_kernel.Core_set.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 Core_kernel.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) Core_kernel.Either.t Core_kernel.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 Core_kernel.Sequence.t
            val to_map :
              t ->
              f:(Elt.t -> 'data) ->
              (Elt.t, 'data, Elt.comparator_witness)
              Core_kernel.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 Core_kernel.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) Core_kernel.Core_set.t -> f:('-> Elt.t) -> t
            val filter_map :
              ('a, 'b) Core_kernel.Core_set.t -> f:('-> Elt.t option) -> t
            val of_tree : Tree.t -> t
            val of_map_keys :
              (Elt.t, 'a, Elt.comparator_witness)
              Core_kernel.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 'base t = ('base, Set.t) Raw.t
        val base : 'base -> 'base t
        val set : Set.t -> 'a t
        val inter2 : 'b t -> 'b t -> 'b t
        val union2 : 'b t -> 'b t -> 'b t
        val diff : 'b t -> 'b t -> 'b t
        val union : 'b t list -> 'b t
        val inter : 'b t * 'b t list -> 'b t
        val inter_list : 'b t list -> 'b t Core.Std.Or_error.t
        val inter_list_exn : 'b t list -> 'b t
        val values : 'base t -> 'base list
        val constant_value : 'a t -> Set.t option
        val subst :
          'b1 t ->
          f:('b1 -> 'b2 t Set_lang_intf.value) -> 'b2 t Set_lang_intf.value
        val map :
          'b1 t ->
          f:('b1 -> 'b2 Set_lang_intf.value) -> 'b2 t Set_lang_intf.value
        val specialize :
          'b t ->
          f:('-> Set.t option Set_lang_intf.value) ->
          'b t Set_lang_intf.value
        val eval :
          'b t ->
          f:('-> Set.t Set_lang_intf.value) -> Set.t Set_lang_intf.value
        module Make_monadic_eval :
          functor (M : Core.Std.Monad.S->
            sig
              val subst : 'b1 t -> f:('b1 -> 'b2 t M.t) -> 'b2 t M.t
              val map : 'b1 t -> f:('b1 -> 'b2 M.t) -> 'b2 t M.t
              val specialize : 'b t -> f:('-> Set.t option M.t) -> 'b t M.t
              val eval : 'b t -> f:('-> Set.t M.t) -> Set.t M.t
            end
        val t_of_sexp :
          (Sexplib.Sexp.t -> 'base) -> Sexplib.Sexp.t -> 'base t
        val sexp_of_t :
          ('base -> Sexplib.Sexp.t) -> 'base t -> Sexplib.Sexp.t
        val compare : ('base -> 'base -> int) -> 'base t -> 'base t -> int
      end
  module Make_binable :
    functor (Elt : Core.Std.Comparable.S_binable->
      sig
        module Set :
          sig
            module Elt :
              sig
                type t = Elt.t
                type comparator_witness = Elt.comparator_witness
                val comparator :
                  (t, comparator_witness) Core_kernel.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)
                    Core_kernel.Core_set.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 Core_kernel.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) Core_kernel.Either.t Core_kernel.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 Core_kernel.Sequence.t
                val to_map :
                  t ->
                  f:(Elt.t -> 'data) ->
                  (Elt.t, 'data, Elt.comparator_witness)
                  Core_kernel.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 Core_kernel.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) Core_kernel.Core_set.Tree.t ->
                  f:('-> Elt.t) -> t
                val filter_map :
                  ('a, 'b) Core_kernel.Core_set.Tree.t ->
                  f:('-> Elt.t option) -> t
                val of_tree : t -> t
                val of_map_keys :
                  (Elt.t, 'a, Elt.comparator_witness)
                  Core_kernel.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) Core_kernel.Core_set.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 Core_kernel.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) Core_kernel.Either.t Core_kernel.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 Core_kernel.Sequence.t
            val to_map :
              t ->
              f:(Elt.t -> 'data) ->
              (Elt.t, 'data, Elt.comparator_witness)
              Core_kernel.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 Core_kernel.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) Core_kernel.Core_set.t -> f:('-> Elt.t) -> t
            val filter_map :
              ('a, 'b) Core_kernel.Core_set.t -> f:('-> Elt.t option) -> t
            val of_tree : Tree.t -> t
            val of_map_keys :
              (Elt.t, 'a, Elt.comparator_witness)
              Core_kernel.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
        type 'base t = ('base, Set.t) Raw.t
        val base : 'base -> 'base t
        val set : Set.t -> 'a t
        val inter2 : 'b t -> 'b t -> 'b t
        val union2 : 'b t -> 'b t -> 'b t
        val diff : 'b t -> 'b t -> 'b t
        val union : 'b t list -> 'b t
        val inter : 'b t * 'b t list -> 'b t
        val inter_list : 'b t list -> 'b t Core.Std.Or_error.t
        val inter_list_exn : 'b t list -> 'b t
        val values : 'base t -> 'base list
        val constant_value : 'a t -> Set.t option
        val subst :
          'b1 t ->
          f:('b1 -> 'b2 t Set_lang_intf.value) -> 'b2 t Set_lang_intf.value
        val map :
          'b1 t ->
          f:('b1 -> 'b2 Set_lang_intf.value) -> 'b2 t Set_lang_intf.value
        val specialize :
          'b t ->
          f:('-> Set.t option Set_lang_intf.value) ->
          'b t Set_lang_intf.value
        val eval :
          'b t ->
          f:('-> Set.t Set_lang_intf.value) -> Set.t Set_lang_intf.value
        module Make_monadic_eval :
          functor (M : Core.Std.Monad.S->
            sig
              val subst : 'b1 t -> f:('b1 -> 'b2 t M.t) -> 'b2 t M.t
              val map : 'b1 t -> f:('b1 -> 'b2 M.t) -> 'b2 t M.t
              val specialize : 'b t -> f:('-> Set.t option M.t) -> 'b t M.t
              val eval : 'b t -> f:('-> Set.t M.t) -> Set.t M.t
            end
        val bin_t :
          'base Core.Std.Bin_prot.Type_class.t ->
          'base t Core.Std.Bin_prot.Type_class.t
        val bin_read_t :
          'base Core.Std.Bin_prot.Read.reader ->
          'base t Core.Std.Bin_prot.Read.reader
        val __bin_read_t__ :
          'base Core.Std.Bin_prot.Read.reader ->
          (int -> 'base t) Core.Std.Bin_prot.Read.reader
        val bin_reader_t :
          'base Core.Std.Bin_prot.Type_class.reader ->
          'base t Core.Std.Bin_prot.Type_class.reader
        val bin_size_t :
          'base Core.Std.Bin_prot.Size.sizer ->
          'base t Core.Std.Bin_prot.Size.sizer
        val bin_write_t :
          'base Core.Std.Bin_prot.Write.writer ->
          'base t Core.Std.Bin_prot.Write.writer
        val bin_writer_t :
          'base Core.Std.Bin_prot.Type_class.writer ->
          'base t Core.Std.Bin_prot.Type_class.writer
        val t_of_sexp :
          (Sexplib.Sexp.t -> 'base) -> Sexplib.Sexp.t -> 'base t
        val sexp_of_t :
          ('base -> Sexplib.Sexp.t) -> 'base t -> Sexplib.Sexp.t
        val compare : ('base -> 'base -> int) -> 'base t -> 'base t -> int
      end
  val compare :
    ('base -> 'base -> int) ->
    ('elt -> 'elt -> int) ->
    ('cmp -> 'cmp -> int) ->
    ('base, 'elt, 'cmp) Set_lang.t -> ('base, 'elt, 'cmp) Set_lang.t -> int
end