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