sig
  module type OrderedType = BatInterfaces.OrderedType
  module type S =
    sig
      type elt
      type t
      val empty : BatSet.S.t
      val is_empty : BatSet.S.t -> bool
      val mem : BatSet.S.elt -> BatSet.S.t -> bool
      val add : BatSet.S.elt -> BatSet.S.t -> BatSet.S.t
      val singleton : BatSet.S.elt -> BatSet.S.t
      val remove : BatSet.S.elt -> BatSet.S.t -> BatSet.S.t
      val union : BatSet.S.t -> BatSet.S.t -> BatSet.S.t
      val inter : BatSet.S.t -> BatSet.S.t -> BatSet.S.t
      val diff : BatSet.S.t -> BatSet.S.t -> BatSet.S.t
      val compare : BatSet.S.t -> BatSet.S.t -> int
      val equal : BatSet.S.t -> BatSet.S.t -> bool
      val subset : BatSet.S.t -> BatSet.S.t -> bool
      val compare_subset : BatSet.S.t -> BatSet.S.t -> int
      val iter : (BatSet.S.elt -> unit) -> BatSet.S.t -> unit
      val map : (BatSet.S.elt -> BatSet.S.elt) -> BatSet.S.t -> BatSet.S.t
      val filter : (BatSet.S.elt -> bool) -> BatSet.S.t -> BatSet.S.t
      val filter_map :
        (BatSet.S.elt -> BatSet.S.elt option) -> BatSet.S.t -> BatSet.S.t
      val fold : (BatSet.S.elt -> 'a -> 'a) -> BatSet.S.t -> 'a -> 'a
      val for_all : (BatSet.S.elt -> bool) -> BatSet.S.t -> bool
      val exists : (BatSet.S.elt -> bool) -> BatSet.S.t -> bool
      val partition :
        (BatSet.S.elt -> bool) -> BatSet.S.t -> BatSet.S.t * BatSet.S.t
      val cardinal : BatSet.S.t -> int
      val elements : BatSet.S.t -> BatSet.S.elt list
      val min_elt : BatSet.S.t -> BatSet.S.elt
      val max_elt : BatSet.S.t -> BatSet.S.elt
      val choose : BatSet.S.t -> BatSet.S.elt
      val split :
        BatSet.S.elt -> BatSet.S.t -> BatSet.S.t * bool * BatSet.S.t
      val enum : BatSet.S.t -> BatSet.S.elt BatEnum.t
      val backwards : BatSet.S.t -> BatSet.S.elt BatEnum.t
      val of_enum : BatSet.S.elt BatEnum.t -> BatSet.S.t
      val print :
        ?first:string ->
        ?last:string ->
        ?sep:string ->
        ('a BatInnerIO.output -> BatSet.S.elt -> unit) ->
        'a BatInnerIO.output -> BatSet.S.t -> unit
      module Exceptionless :
        sig
          val min_elt : BatSet.S.t -> BatSet.S.elt option
          val max_elt : BatSet.S.t -> BatSet.S.elt option
          val choose : BatSet.S.t -> BatSet.S.elt option
        end
      module Labels :
        sig
          val iter : f:(BatSet.S.elt -> unit) -> BatSet.S.t -> unit
          val fold :
            f:(BatSet.S.elt -> 'a -> 'a) -> BatSet.S.t -> init:'a -> 'a
          val for_all : f:(BatSet.S.elt -> bool) -> BatSet.S.t -> bool
          val exists : f:(BatSet.S.elt -> bool) -> BatSet.S.t -> bool
          val map :
            f:(BatSet.S.elt -> BatSet.S.elt) -> BatSet.S.t -> BatSet.S.t
          val filter : f:(BatSet.S.elt -> bool) -> BatSet.S.t -> BatSet.S.t
          val filter_map :
            f:(BatSet.S.elt -> BatSet.S.elt option) ->
            BatSet.S.t -> BatSet.S.t
          val partition :
            f:(BatSet.S.elt -> bool) -> BatSet.S.t -> BatSet.S.t * BatSet.S.t
        end
    end
  module StringSet :
    sig
      type elt = String.t
      type t
      val empty : t
      val is_empty : t -> bool
      val mem : elt -> t -> bool
      val add : elt -> t -> t
      val singleton : elt -> t
      val remove : elt -> t -> t
      val union : t -> t -> t
      val inter : t -> t -> t
      val diff : t -> t -> t
      val compare : t -> t -> int
      val equal : t -> t -> bool
      val subset : t -> t -> bool
      val compare_subset : t -> t -> int
      val iter : (elt -> unit) -> t -> unit
      val map : (elt -> elt) -> t -> t
      val filter : (elt -> bool) -> t -> t
      val filter_map : (elt -> elt option) -> t -> t
      val fold : (elt -> 'a -> 'a) -> t -> 'a -> 'a
      val for_all : (elt -> bool) -> t -> bool
      val exists : (elt -> bool) -> t -> bool
      val partition : (elt -> bool) -> t -> t * t
      val cardinal : t -> int
      val elements : t -> elt list
      val min_elt : t -> elt
      val max_elt : t -> elt
      val choose : t -> elt
      val split : elt -> t -> t * bool * t
      val enum : t -> elt BatEnum.t
      val backwards : t -> elt BatEnum.t
      val of_enum : elt BatEnum.t -> t
      val print :
        ?first:string ->
        ?last:string ->
        ?sep:string ->
        ('a BatInnerIO.output -> elt -> unit) ->
        'a BatInnerIO.output -> t -> unit
      module Exceptionless :
        sig
          val min_elt : t -> elt option
          val max_elt : t -> elt option
          val choose : t -> elt option
        end
      module Labels :
        sig
          val iter : f:(elt -> unit) -> t -> unit
          val fold : f:(elt -> 'a -> 'a) -> t -> init:'a -> 'a
          val for_all : f:(elt -> bool) -> t -> bool
          val exists : f:(elt -> bool) -> t -> bool
          val map : f:(elt -> elt) -> t -> t
          val filter : f:(elt -> bool) -> t -> t
          val filter_map : f:(elt -> elt option) -> t -> t
          val partition : f:(elt -> bool) -> t -> t * t
        end
    end
  module IStringSet :
    sig
      type elt = String.t
      type t
      val empty : t
      val is_empty : t -> bool
      val mem : elt -> t -> bool
      val add : elt -> t -> t
      val singleton : elt -> t
      val remove : elt -> t -> t
      val union : t -> t -> t
      val inter : t -> t -> t
      val diff : t -> t -> t
      val compare : t -> t -> int
      val equal : t -> t -> bool
      val subset : t -> t -> bool
      val compare_subset : t -> t -> int
      val iter : (elt -> unit) -> t -> unit
      val map : (elt -> elt) -> t -> t
      val filter : (elt -> bool) -> t -> t
      val filter_map : (elt -> elt option) -> t -> t
      val fold : (elt -> 'a -> 'a) -> t -> 'a -> 'a
      val for_all : (elt -> bool) -> t -> bool
      val exists : (elt -> bool) -> t -> bool
      val partition : (elt -> bool) -> t -> t * t
      val cardinal : t -> int
      val elements : t -> elt list
      val min_elt : t -> elt
      val max_elt : t -> elt
      val choose : t -> elt
      val split : elt -> t -> t * bool * t
      val enum : t -> elt BatEnum.t
      val backwards : t -> elt BatEnum.t
      val of_enum : elt BatEnum.t -> t
      val print :
        ?first:string ->
        ?last:string ->
        ?sep:string ->
        ('a BatInnerIO.output -> elt -> unit) ->
        'a BatInnerIO.output -> t -> unit
      module Exceptionless :
        sig
          val min_elt : t -> elt option
          val max_elt : t -> elt option
          val choose : t -> elt option
        end
      module Labels :
        sig
          val iter : f:(elt -> unit) -> t -> unit
          val fold : f:(elt -> 'a -> 'a) -> t -> init:'a -> 'a
          val for_all : f:(elt -> bool) -> t -> bool
          val exists : f:(elt -> bool) -> t -> bool
          val map : f:(elt -> elt) -> t -> t
          val filter : f:(elt -> bool) -> t -> t
          val filter_map : f:(elt -> elt option) -> t -> t
          val partition : f:(elt -> bool) -> t -> t * t
        end
    end
  module NumStringSet :
    sig
      type elt = String.t
      type t
      val empty : t
      val is_empty : t -> bool
      val mem : elt -> t -> bool
      val add : elt -> t -> t
      val singleton : elt -> t
      val remove : elt -> t -> t
      val union : t -> t -> t
      val inter : t -> t -> t
      val diff : t -> t -> t
      val compare : t -> t -> int
      val equal : t -> t -> bool
      val subset : t -> t -> bool
      val compare_subset : t -> t -> int
      val iter : (elt -> unit) -> t -> unit
      val map : (elt -> elt) -> t -> t
      val filter : (elt -> bool) -> t -> t
      val filter_map : (elt -> elt option) -> t -> t
      val fold : (elt -> 'a -> 'a) -> t -> 'a -> 'a
      val for_all : (elt -> bool) -> t -> bool
      val exists : (elt -> bool) -> t -> bool
      val partition : (elt -> bool) -> t -> t * t
      val cardinal : t -> int
      val elements : t -> elt list
      val min_elt : t -> elt
      val max_elt : t -> elt
      val choose : t -> elt
      val split : elt -> t -> t * bool * t
      val enum : t -> elt BatEnum.t
      val backwards : t -> elt BatEnum.t
      val of_enum : elt BatEnum.t -> t
      val print :
        ?first:string ->
        ?last:string ->
        ?sep:string ->
        ('a BatInnerIO.output -> elt -> unit) ->
        'a BatInnerIO.output -> t -> unit
      module Exceptionless :
        sig
          val min_elt : t -> elt option
          val max_elt : t -> elt option
          val choose : t -> elt option
        end
      module Labels :
        sig
          val iter : f:(elt -> unit) -> t -> unit
          val fold : f:(elt -> 'a -> 'a) -> t -> init:'a -> 'a
          val for_all : f:(elt -> bool) -> t -> bool
          val exists : f:(elt -> bool) -> t -> bool
          val map : f:(elt -> elt) -> t -> t
          val filter : f:(elt -> bool) -> t -> t
          val filter_map : f:(elt -> elt option) -> t -> t
          val partition : f:(elt -> bool) -> t -> t * t
        end
    end
  module RopeSet :
    sig
      type elt = BatRope.t
      type t
      val empty : t
      val is_empty : t -> bool
      val mem : elt -> t -> bool
      val add : elt -> t -> t
      val singleton : elt -> t
      val remove : elt -> t -> t
      val union : t -> t -> t
      val inter : t -> t -> t
      val diff : t -> t -> t
      val compare : t -> t -> int
      val equal : t -> t -> bool
      val subset : t -> t -> bool
      val compare_subset : t -> t -> int
      val iter : (elt -> unit) -> t -> unit
      val map : (elt -> elt) -> t -> t
      val filter : (elt -> bool) -> t -> t
      val filter_map : (elt -> elt option) -> t -> t
      val fold : (elt -> 'a -> 'a) -> t -> 'a -> 'a
      val for_all : (elt -> bool) -> t -> bool
      val exists : (elt -> bool) -> t -> bool
      val partition : (elt -> bool) -> t -> t * t
      val cardinal : t -> int
      val elements : t -> elt list
      val min_elt : t -> elt
      val max_elt : t -> elt
      val choose : t -> elt
      val split : elt -> t -> t * bool * t
      val enum : t -> elt BatEnum.t
      val backwards : t -> elt BatEnum.t
      val of_enum : elt BatEnum.t -> t
      val print :
        ?first:string ->
        ?last:string ->
        ?sep:string ->
        ('a BatInnerIO.output -> elt -> unit) ->
        'a BatInnerIO.output -> t -> unit
      module Exceptionless :
        sig
          val min_elt : t -> elt option
          val max_elt : t -> elt option
          val choose : t -> elt option
        end
      module Labels :
        sig
          val iter : f:(elt -> unit) -> t -> unit
          val fold : f:(elt -> 'a -> 'a) -> t -> init:'a -> 'a
          val for_all : f:(elt -> bool) -> t -> bool
          val exists : f:(elt -> bool) -> t -> bool
          val map : f:(elt -> elt) -> t -> t
          val filter : f:(elt -> bool) -> t -> t
          val filter_map : f:(elt -> elt option) -> t -> t
          val partition : f:(elt -> bool) -> t -> t * t
        end
    end
  module IRopeSet :
    sig
      type elt = BatRope.t
      type t
      val empty : t
      val is_empty : t -> bool
      val mem : elt -> t -> bool
      val add : elt -> t -> t
      val singleton : elt -> t
      val remove : elt -> t -> t
      val union : t -> t -> t
      val inter : t -> t -> t
      val diff : t -> t -> t
      val compare : t -> t -> int
      val equal : t -> t -> bool
      val subset : t -> t -> bool
      val compare_subset : t -> t -> int
      val iter : (elt -> unit) -> t -> unit
      val map : (elt -> elt) -> t -> t
      val filter : (elt -> bool) -> t -> t
      val filter_map : (elt -> elt option) -> t -> t
      val fold : (elt -> 'a -> 'a) -> t -> 'a -> 'a
      val for_all : (elt -> bool) -> t -> bool
      val exists : (elt -> bool) -> t -> bool
      val partition : (elt -> bool) -> t -> t * t
      val cardinal : t -> int
      val elements : t -> elt list
      val min_elt : t -> elt
      val max_elt : t -> elt
      val choose : t -> elt
      val split : elt -> t -> t * bool * t
      val enum : t -> elt BatEnum.t
      val backwards : t -> elt BatEnum.t
      val of_enum : elt BatEnum.t -> t
      val print :
        ?first:string ->
        ?last:string ->
        ?sep:string ->
        ('a BatInnerIO.output -> elt -> unit) ->
        'a BatInnerIO.output -> t -> unit
      module Exceptionless :
        sig
          val min_elt : t -> elt option
          val max_elt : t -> elt option
          val choose : t -> elt option
        end
      module Labels :
        sig
          val iter : f:(elt -> unit) -> t -> unit
          val fold : f:(elt -> 'a -> 'a) -> t -> init:'a -> 'a
          val for_all : f:(elt -> bool) -> t -> bool
          val exists : f:(elt -> bool) -> t -> bool
          val map : f:(elt -> elt) -> t -> t
          val filter : f:(elt -> bool) -> t -> t
          val filter_map : f:(elt -> elt option) -> t -> t
          val partition : f:(elt -> bool) -> t -> t * t
        end
    end
  module IntSet :
    sig
      type elt = BatInt.t
      type t
      val empty : t
      val is_empty : t -> bool
      val mem : elt -> t -> bool
      val add : elt -> t -> t
      val singleton : elt -> t
      val remove : elt -> t -> t
      val union : t -> t -> t
      val inter : t -> t -> t
      val diff : t -> t -> t
      val compare : t -> t -> int
      val equal : t -> t -> bool
      val subset : t -> t -> bool
      val compare_subset : t -> t -> int
      val iter : (elt -> unit) -> t -> unit
      val map : (elt -> elt) -> t -> t
      val filter : (elt -> bool) -> t -> t
      val filter_map : (elt -> elt option) -> t -> t
      val fold : (elt -> 'a -> 'a) -> t -> 'a -> 'a
      val for_all : (elt -> bool) -> t -> bool
      val exists : (elt -> bool) -> t -> bool
      val partition : (elt -> bool) -> t -> t * t
      val cardinal : t -> int
      val elements : t -> elt list
      val min_elt : t -> elt
      val max_elt : t -> elt
      val choose : t -> elt
      val split : elt -> t -> t * bool * t
      val enum : t -> elt BatEnum.t
      val backwards : t -> elt BatEnum.t
      val of_enum : elt BatEnum.t -> t
      val print :
        ?first:string ->
        ?last:string ->
        ?sep:string ->
        ('a BatInnerIO.output -> elt -> unit) ->
        'a BatInnerIO.output -> t -> unit
      module Exceptionless :
        sig
          val min_elt : t -> elt option
          val max_elt : t -> elt option
          val choose : t -> elt option
        end
      module Labels :
        sig
          val iter : f:(elt -> unit) -> t -> unit
          val fold : f:(elt -> 'a -> 'a) -> t -> init:'a -> 'a
          val for_all : f:(elt -> bool) -> t -> bool
          val exists : f:(elt -> bool) -> t -> bool
          val map : f:(elt -> elt) -> t -> t
          val filter : f:(elt -> bool) -> t -> t
          val filter_map : f:(elt -> elt option) -> t -> t
          val partition : f:(elt -> bool) -> t -> t * t
        end
    end
  module CharSet :
    sig
      type elt = Char.t
      type t
      val empty : t
      val is_empty : t -> bool
      val mem : elt -> t -> bool
      val add : elt -> t -> t
      val singleton : elt -> t
      val remove : elt -> t -> t
      val union : t -> t -> t
      val inter : t -> t -> t
      val diff : t -> t -> t
      val compare : t -> t -> int
      val equal : t -> t -> bool
      val subset : t -> t -> bool
      val compare_subset : t -> t -> int
      val iter : (elt -> unit) -> t -> unit
      val map : (elt -> elt) -> t -> t
      val filter : (elt -> bool) -> t -> t
      val filter_map : (elt -> elt option) -> t -> t
      val fold : (elt -> 'a -> 'a) -> t -> 'a -> 'a
      val for_all : (elt -> bool) -> t -> bool
      val exists : (elt -> bool) -> t -> bool
      val partition : (elt -> bool) -> t -> t * t
      val cardinal : t -> int
      val elements : t -> elt list
      val min_elt : t -> elt
      val max_elt : t -> elt
      val choose : t -> elt
      val split : elt -> t -> t * bool * t
      val enum : t -> elt BatEnum.t
      val backwards : t -> elt BatEnum.t
      val of_enum : elt BatEnum.t -> t
      val print :
        ?first:string ->
        ?last:string ->
        ?sep:string ->
        ('a BatInnerIO.output -> elt -> unit) ->
        'a BatInnerIO.output -> t -> unit
      module Exceptionless :
        sig
          val min_elt : t -> elt option
          val max_elt : t -> elt option
          val choose : t -> elt option
        end
      module Labels :
        sig
          val iter : f:(elt -> unit) -> t -> unit
          val fold : f:(elt -> 'a -> 'a) -> t -> init:'a -> 'a
          val for_all : f:(elt -> bool) -> t -> bool
          val exists : f:(elt -> bool) -> t -> bool
          val map : f:(elt -> elt) -> t -> t
          val filter : f:(elt -> bool) -> t -> t
          val filter_map : f:(elt -> elt option) -> t -> t
          val partition : f:(elt -> bool) -> t -> t * t
        end
    end
  module Make :
    functor (Ord : OrderedType) ->
      sig
        type elt = Ord.t
        type t
        val empty : t
        val is_empty : t -> bool
        val mem : elt -> t -> bool
        val add : elt -> t -> t
        val singleton : elt -> t
        val remove : elt -> t -> t
        val union : t -> t -> t
        val inter : t -> t -> t
        val diff : t -> t -> t
        val compare : t -> t -> int
        val equal : t -> t -> bool
        val subset : t -> t -> bool
        val compare_subset : t -> t -> int
        val iter : (elt -> unit) -> t -> unit
        val map : (elt -> elt) -> t -> t
        val filter : (elt -> bool) -> t -> t
        val filter_map : (elt -> elt option) -> t -> t
        val fold : (elt -> 'a -> 'a) -> t -> 'a -> 'a
        val for_all : (elt -> bool) -> t -> bool
        val exists : (elt -> bool) -> t -> bool
        val partition : (elt -> bool) -> t -> t * t
        val cardinal : t -> int
        val elements : t -> elt list
        val min_elt : t -> elt
        val max_elt : t -> elt
        val choose : t -> elt
        val split : elt -> t -> t * bool * t
        val enum : t -> elt BatEnum.t
        val backwards : t -> elt BatEnum.t
        val of_enum : elt BatEnum.t -> t
        val print :
          ?first:string ->
          ?last:string ->
          ?sep:string ->
          ('a BatInnerIO.output -> elt -> unit) ->
          'a BatInnerIO.output -> t -> unit
        module Exceptionless :
          sig
            val min_elt : t -> elt option
            val max_elt : t -> elt option
            val choose : t -> elt option
          end
        module Labels :
          sig
            val iter : f:(elt -> unit) -> t -> unit
            val fold : f:(elt -> 'a -> 'a) -> t -> init:'a -> 'a
            val for_all : f:(elt -> bool) -> t -> bool
            val exists : f:(elt -> bool) -> t -> bool
            val map : f:(elt -> elt) -> t -> t
            val filter : f:(elt -> bool) -> t -> t
            val filter_map : f:(elt -> elt option) -> t -> t
            val partition : f:(elt -> bool) -> t -> t * t
          end
      end
  type 'a t
  type 'a enumerable = 'a t
  val enum : 'a enumerable -> 'a BatEnum.t
  val of_enum : 'a BatEnum.t -> 'a enumerable
  type 'a mappable = 'a t
  val map : ('a -> 'b) -> 'a mappable -> 'b mappable
  val empty : 'a BatSet.t
  val create : ('a -> 'a -> int) -> 'a BatSet.t
  val singleton : ?cmp:('a -> 'a -> int) -> 'a -> 'a BatSet.t
  val is_empty : 'a BatSet.t -> bool
  val mem : 'a -> 'a BatSet.t -> bool
  val add : 'a -> 'a BatSet.t -> 'a BatSet.t
  val remove : 'a -> 'a BatSet.t -> 'a BatSet.t
  val iter : ('a -> unit) -> 'a BatSet.t -> unit
  val map : ('a -> 'b) -> 'a BatSet.t -> 'b BatSet.t
  val filter : ('a -> bool) -> 'a t -> 'a t
  val filter_map : ('a -> 'b option) -> 'a BatSet.t -> 'b BatSet.t
  val fold : ('a -> 'b -> 'b) -> 'a BatSet.t -> 'b -> 'b
  val exists : ('a -> bool) -> 'a BatSet.t -> bool
  val cardinal : 'a BatSet.t -> int
  val choose : 'a BatSet.t -> 'a
  val min_elt : 'a BatSet.t -> 'a
  val max_elt : 'a BatSet.t -> 'a
  val enum : 'a BatSet.t -> 'a BatEnum.t
  val of_enum : 'a BatEnum.t -> 'a BatSet.t
  val for_all : ('a -> bool) -> 'a BatSet.t -> bool
  val partition : ('a -> bool) -> 'a BatSet.t -> 'a BatSet.t * 'a BatSet.t
  val filter : ('a -> bool) -> 'a BatSet.t -> 'a BatSet.t
  val pop : 'a BatSet.t -> 'a * 'a BatSet.t
  val union : 'a BatSet.t -> 'a BatSet.t -> 'a BatSet.t
  val diff : 'a BatSet.t -> 'a BatSet.t -> 'a BatSet.t
  val print :
    ?first:string ->
    ?last:string ->
    ?sep:string ->
    ('a BatInnerIO.output -> 'b -> unit) ->
    'a BatInnerIO.output -> 'b BatSet.t -> unit
end