# Module Std.Set_lang

    module Set_lang: Set_lang

    module Raw: sig .. end

    type ('base, 'elt, 'cmp) t = ('base, ('elt, 'cmp) Core.Std.Set.t) Raw.t

    val base : 'base -> ('base, 'a, 'b) t

    val set : ('elt, 'cmp) Core.Std.Set.t -> ('a, 'elt, 'cmp) t

    val inter2 : ('b, 'e, 'c) t -> ('b, 'e, 'c) t -> ('b, 'e, 'c) t

    val union2 : ('b, 'e, 'c) t -> ('b, 'e, 'c) t -> ('b, 'e, 'c) t

    val diff : ('b, 'e, 'c) t -> ('b, 'e, 'c) t -> ('b, 'e, 'c) t

    val union : ('b, 'e, 'c) t * ('b, 'e, 'c) t list ->
           ('b, 'e, 'c) t

    val inter : ('b, 'e, 'c) t * ('b, 'e, 'c) t list ->
           ('b, 'e, 'c) t

    val union_list : ('b, 'e, 'c) t list -> ('b, 'e, 'c) t Core.Std.Or_error.t

    val inter_list : ('b, 'e, 'c) t list -> ('b, 'e, 'c) t Core.Std.Or_error.t

    val union_list_exn : ('b, 'e, 'c) t list -> ('b, 'e, 'c) t

    val inter_list_exn : ('b, 'e, 'c) t list -> ('b, 'e, 'c) t

    val values : ('base, 'a, 'b) t -> 'base list

    val constant_value : ('a, 'elt, 'cmp) t -> ('elt, 'cmp) Core.Std.Set.t option

    val subst : ('b1, 'e, 'c) t ->
           f:('b1 -> ('b2, 'e, 'c) t) -> ('b2, 'e, 'c) t

    val map : ('b1, 'e, 'c) t -> f:('b1 -> 'b2) -> ('b2, 'e, 'c) t

    val specialize : ('b, 'e, 'c) t ->
           f:('b -> ('e, 'c) Core.Std.Set.t option) -> ('b, 'e, 'c) t

    val eval : ('b, 'e, 'c) t ->
           f:('b -> ('e, 'c) Core.Std.Set.t) -> ('e, 'c) Core.Std.Set.t

    val invariant : ('base, 'elt, 'cmp) t -> unit

    module Make_monadic_eval: functor (M : Core.Std.Monad.S) -> sig .. end

    module type S = Set_lang_intf.S  with module Raw := Raw

    module type S_binable = Set_lang_intf.S_binable  with module Raw := Raw

    module Make: functor (Elt : Core.Std.Comparable.S) -> S
      with module Set = Elt.Set

    module Make_binable: functor (Elt : Core.Std.Comparable.S_binable) -> S_binable
      with module Set = Elt.Set

    val compare : ('base -> 'base -> int) ->
           ('elt -> 'elt -> int) ->
           ('cmp -> 'cmp -> int) ->
           ('base, 'elt, 'cmp) t -> ('base, 'elt, 'cmp) t -> int