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 is_singleton : BatSet.S.t -> bool
      val singleton : BatSet.S.elt -> BatSet.S.t
      val mem : BatSet.S.elt -> BatSet.S.t -> bool
      val find : BatSet.S.elt -> BatSet.S.t -> BatSet.S.elt
      val find_opt : BatSet.S.elt -> BatSet.S.t -> BatSet.S.elt option
      val find_first : (BatSet.S.elt -> bool) -> BatSet.S.t -> BatSet.S.elt
      val find_first_opt :
        (BatSet.S.elt -> bool) -> BatSet.S.t -> BatSet.S.elt option
      val find_last : (BatSet.S.elt -> bool) -> BatSet.S.t -> BatSet.S.elt
      val find_last_opt :
        (BatSet.S.elt -> bool) -> BatSet.S.t -> BatSet.S.elt option
      val add : BatSet.S.elt -> BatSet.S.t -> BatSet.S.t
      val remove : BatSet.S.elt -> BatSet.S.t -> BatSet.S.t
      val remove_exn : BatSet.S.elt -> BatSet.S.t -> BatSet.S.t
      val update : BatSet.S.elt -> 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 sym_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 disjoint : 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 at_rank_exn : int -> BatSet.S.t -> BatSet.S.elt
      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) -> BatSet.S.t -> '-> '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 split :
        BatSet.S.elt -> BatSet.S.t -> BatSet.S.t * bool * BatSet.S.t
      val split_opt :
        BatSet.S.elt ->
        BatSet.S.t -> BatSet.S.t * BatSet.S.elt option * BatSet.S.t
      val split_lt : BatSet.S.elt -> BatSet.S.t -> BatSet.S.t * BatSet.S.t
      val split_le : BatSet.S.elt -> 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 to_list : BatSet.S.t -> BatSet.S.elt list
      val to_array : BatSet.S.t -> BatSet.S.elt array
      val min_elt : BatSet.S.t -> BatSet.S.elt
      val min_elt_opt : BatSet.S.t -> BatSet.S.elt option
      val pop_min : BatSet.S.t -> BatSet.S.elt * BatSet.S.t
      val pop_max : BatSet.S.t -> BatSet.S.elt * BatSet.S.t
      val max_elt : BatSet.S.t -> BatSet.S.elt
      val max_elt_opt : BatSet.S.t -> BatSet.S.elt option
      val choose : BatSet.S.t -> BatSet.S.elt
      val choose_opt : BatSet.S.t -> BatSet.S.elt option
      val any : BatSet.S.t -> BatSet.S.elt
      val pop : BatSet.S.t -> BatSet.S.elt * 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 of_list : BatSet.S.elt list -> BatSet.S.t
      val of_array : BatSet.S.elt array -> BatSet.S.t
      val to_seq : BatSet.S.t -> BatSet.S.elt BatSeq.t
      val to_rev_seq : BatSet.S.t -> BatSet.S.elt BatSeq.t
      val to_seq_from : BatSet.S.elt -> BatSet.S.t -> BatSet.S.elt BatSeq.t
      val add_seq : BatSet.S.elt BatSeq.t -> BatSet.S.t -> BatSet.S.t
      val of_seq : BatSet.S.elt BatSeq.t -> BatSet.S.t
      val print :
        ?first:string ->
        ?last:string ->
        ?sep:string ->
        ('BatInnerIO.output -> BatSet.S.elt -> unit) ->
        '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
          val any : BatSet.S.t -> BatSet.S.elt option
          val find : BatSet.S.elt -> 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) -> BatSet.S.t -> init:'-> '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 Make :
    functor (Ord : OrderedType->
      sig
        type elt = Ord.t
        type t
        val empty : t
        val is_empty : t -> bool
        val is_singleton : t -> bool
        val singleton : elt -> t
        val mem : elt -> t -> bool
        val find : elt -> t -> elt
        val find_opt : elt -> t -> elt option
        val find_first : (elt -> bool) -> t -> elt
        val find_first_opt : (elt -> bool) -> t -> elt option
        val find_last : (elt -> bool) -> t -> elt
        val find_last_opt : (elt -> bool) -> t -> elt option
        val add : elt -> t -> t
        val remove : elt -> t -> t
        val remove_exn : elt -> t -> t
        val update : elt -> elt -> t -> t
        val union : t -> t -> t
        val inter : t -> t -> t
        val diff : t -> t -> t
        val sym_diff : t -> t -> t
        val compare : t -> t -> int
        val equal : t -> t -> bool
        val subset : t -> t -> bool
        val disjoint : t -> t -> bool
        val compare_subset : t -> t -> int
        val iter : (elt -> unit) -> t -> unit
        val at_rank_exn : int -> t -> elt
        val map : (elt -> elt) -> t -> t
        val filter : (elt -> bool) -> t -> t
        val filter_map : (elt -> elt option) -> t -> t
        val fold : (elt -> '-> 'a) -> t -> '-> 'a
        val for_all : (elt -> bool) -> t -> bool
        val exists : (elt -> bool) -> t -> bool
        val partition : (elt -> bool) -> t -> t * t
        val split : elt -> t -> t * bool * t
        val split_opt : elt -> t -> t * elt option * t
        val split_lt : elt -> t -> t * t
        val split_le : elt -> t -> t * t
        val cardinal : t -> int
        val elements : t -> elt list
        val to_list : t -> elt list
        val to_array : t -> elt array
        val min_elt : t -> elt
        val min_elt_opt : t -> elt option
        val pop_min : t -> elt * t
        val pop_max : t -> elt * t
        val max_elt : t -> elt
        val max_elt_opt : t -> elt option
        val choose : t -> elt
        val choose_opt : t -> elt option
        val any : t -> elt
        val pop : t -> elt * t
        val enum : t -> elt BatEnum.t
        val backwards : t -> elt BatEnum.t
        val of_enum : elt BatEnum.t -> t
        val of_list : elt list -> t
        val of_array : elt array -> t
        val to_seq : t -> elt BatSeq.t
        val to_rev_seq : t -> elt BatSeq.t
        val to_seq_from : elt -> t -> elt BatSeq.t
        val add_seq : elt BatSeq.t -> t -> t
        val of_seq : elt BatSeq.t -> t
        val print :
          ?first:string ->
          ?last:string ->
          ?sep:string ->
          ('BatInnerIO.output -> elt -> unit) ->
          'BatInnerIO.output -> t -> unit
        module Exceptionless :
          sig
            val min_elt : t -> elt option
            val max_elt : t -> elt option
            val choose : t -> elt option
            val any : t -> elt option
            val find : elt -> t -> elt option
          end
        module Labels :
          sig
            val iter : f:(elt -> unit) -> t -> unit
            val fold : f:(elt -> '-> 'a) -> t -> init:'-> '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 Make2 :
    functor (O1 : OrderedType) (O2 : OrderedType->
      sig
        module Product :
          sig
            type elt = O1.t * O2.t
            type t
            val empty : t
            val is_empty : t -> bool
            val is_singleton : t -> bool
            val singleton : elt -> t
            val mem : elt -> t -> bool
            val find : elt -> t -> elt
            val find_opt : elt -> t -> elt option
            val find_first : (elt -> bool) -> t -> elt
            val find_first_opt : (elt -> bool) -> t -> elt option
            val find_last : (elt -> bool) -> t -> elt
            val find_last_opt : (elt -> bool) -> t -> elt option
            val add : elt -> t -> t
            val remove : elt -> t -> t
            val remove_exn : elt -> t -> t
            val update : elt -> elt -> t -> t
            val union : t -> t -> t
            val inter : t -> t -> t
            val diff : t -> t -> t
            val sym_diff : t -> t -> t
            val compare : t -> t -> int
            val equal : t -> t -> bool
            val subset : t -> t -> bool
            val disjoint : t -> t -> bool
            val compare_subset : t -> t -> int
            val iter : (elt -> unit) -> t -> unit
            val at_rank_exn : int -> t -> elt
            val map : (elt -> elt) -> t -> t
            val filter : (elt -> bool) -> t -> t
            val filter_map : (elt -> elt option) -> t -> t
            val fold : (elt -> '-> 'a) -> t -> '-> 'a
            val for_all : (elt -> bool) -> t -> bool
            val exists : (elt -> bool) -> t -> bool
            val partition : (elt -> bool) -> t -> t * t
            val split : elt -> t -> t * bool * t
            val split_opt : elt -> t -> t * elt option * t
            val split_lt : elt -> t -> t * t
            val split_le : elt -> t -> t * t
            val cardinal : t -> int
            val elements : t -> elt list
            val to_list : t -> elt list
            val to_array : t -> elt array
            val min_elt : t -> elt
            val min_elt_opt : t -> elt option
            val pop_min : t -> elt * t
            val pop_max : t -> elt * t
            val max_elt : t -> elt
            val max_elt_opt : t -> elt option
            val choose : t -> elt
            val choose_opt : t -> elt option
            val any : t -> elt
            val pop : t -> elt * t
            val enum : t -> elt BatEnum.t
            val backwards : t -> elt BatEnum.t
            val of_enum : elt BatEnum.t -> t
            val of_list : elt list -> t
            val of_array : elt array -> t
            val to_seq : t -> elt BatSeq.t
            val to_rev_seq : t -> elt BatSeq.t
            val to_seq_from : elt -> t -> elt BatSeq.t
            val add_seq : elt BatSeq.t -> t -> t
            val of_seq : elt BatSeq.t -> t
            val print :
              ?first:string ->
              ?last:string ->
              ?sep:string ->
              ('BatInnerIO.output -> elt -> unit) ->
              'BatInnerIO.output -> t -> unit
            module Exceptionless :
              sig
                val min_elt : t -> elt option
                val max_elt : t -> elt option
                val choose : t -> elt option
                val any : t -> elt option
                val find : elt -> t -> elt option
              end
            module Labels :
              sig
                val iter : f:(elt -> unit) -> t -> unit
                val fold : f:(elt -> '-> 'a) -> t -> init:'-> '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
        val cartesian_product :
          Make(O1).t -> Make(O2).t -> BatSet.Make2.Product.t
      end
  module Int :
    sig
      type elt = int
      type t
      val empty : t
      val is_empty : t -> bool
      val is_singleton : t -> bool
      val singleton : elt -> t
      val mem : elt -> t -> bool
      val find : elt -> t -> elt
      val find_opt : elt -> t -> elt option
      val find_first : (elt -> bool) -> t -> elt
      val find_first_opt : (elt -> bool) -> t -> elt option
      val find_last : (elt -> bool) -> t -> elt
      val find_last_opt : (elt -> bool) -> t -> elt option
      val add : elt -> t -> t
      val remove : elt -> t -> t
      val remove_exn : elt -> t -> t
      val update : elt -> elt -> t -> t
      val union : t -> t -> t
      val inter : t -> t -> t
      val diff : t -> t -> t
      val sym_diff : t -> t -> t
      val compare : t -> t -> int
      val equal : t -> t -> bool
      val subset : t -> t -> bool
      val disjoint : t -> t -> bool
      val compare_subset : t -> t -> int
      val iter : (elt -> unit) -> t -> unit
      val at_rank_exn : int -> t -> elt
      val map : (elt -> elt) -> t -> t
      val filter : (elt -> bool) -> t -> t
      val filter_map : (elt -> elt option) -> t -> t
      val fold : (elt -> '-> 'a) -> t -> '-> 'a
      val for_all : (elt -> bool) -> t -> bool
      val exists : (elt -> bool) -> t -> bool
      val partition : (elt -> bool) -> t -> t * t
      val split : elt -> t -> t * bool * t
      val split_opt : elt -> t -> t * elt option * t
      val split_lt : elt -> t -> t * t
      val split_le : elt -> t -> t * t
      val cardinal : t -> int
      val elements : t -> elt list
      val to_list : t -> elt list
      val to_array : t -> elt array
      val min_elt : t -> elt
      val min_elt_opt : t -> elt option
      val pop_min : t -> elt * t
      val pop_max : t -> elt * t
      val max_elt : t -> elt
      val max_elt_opt : t -> elt option
      val choose : t -> elt
      val choose_opt : t -> elt option
      val any : t -> elt
      val pop : t -> elt * t
      val enum : t -> elt BatEnum.t
      val backwards : t -> elt BatEnum.t
      val of_enum : elt BatEnum.t -> t
      val of_list : elt list -> t
      val of_array : elt array -> t
      val to_seq : t -> elt BatSeq.t
      val to_rev_seq : t -> elt BatSeq.t
      val to_seq_from : elt -> t -> elt BatSeq.t
      val add_seq : elt BatSeq.t -> t -> t
      val of_seq : elt BatSeq.t -> t
      val print :
        ?first:string ->
        ?last:string ->
        ?sep:string ->
        ('BatInnerIO.output -> elt -> unit) ->
        'BatInnerIO.output -> t -> unit
      module Exceptionless :
        sig
          val min_elt : t -> elt option
          val max_elt : t -> elt option
          val choose : t -> elt option
          val any : t -> elt option
          val find : elt -> t -> elt option
        end
      module Labels :
        sig
          val iter : f:(elt -> unit) -> t -> unit
          val fold : f:(elt -> '-> 'a) -> t -> init:'-> '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 Int32 :
    sig
      type elt = int32
      type t
      val empty : t
      val is_empty : t -> bool
      val is_singleton : t -> bool
      val singleton : elt -> t
      val mem : elt -> t -> bool
      val find : elt -> t -> elt
      val find_opt : elt -> t -> elt option
      val find_first : (elt -> bool) -> t -> elt
      val find_first_opt : (elt -> bool) -> t -> elt option
      val find_last : (elt -> bool) -> t -> elt
      val find_last_opt : (elt -> bool) -> t -> elt option
      val add : elt -> t -> t
      val remove : elt -> t -> t
      val remove_exn : elt -> t -> t
      val update : elt -> elt -> t -> t
      val union : t -> t -> t
      val inter : t -> t -> t
      val diff : t -> t -> t
      val sym_diff : t -> t -> t
      val compare : t -> t -> int
      val equal : t -> t -> bool
      val subset : t -> t -> bool
      val disjoint : t -> t -> bool
      val compare_subset : t -> t -> int
      val iter : (elt -> unit) -> t -> unit
      val at_rank_exn : int -> t -> elt
      val map : (elt -> elt) -> t -> t
      val filter : (elt -> bool) -> t -> t
      val filter_map : (elt -> elt option) -> t -> t
      val fold : (elt -> '-> 'a) -> t -> '-> 'a
      val for_all : (elt -> bool) -> t -> bool
      val exists : (elt -> bool) -> t -> bool
      val partition : (elt -> bool) -> t -> t * t
      val split : elt -> t -> t * bool * t
      val split_opt : elt -> t -> t * elt option * t
      val split_lt : elt -> t -> t * t
      val split_le : elt -> t -> t * t
      val cardinal : t -> int
      val elements : t -> elt list
      val to_list : t -> elt list
      val to_array : t -> elt array
      val min_elt : t -> elt
      val min_elt_opt : t -> elt option
      val pop_min : t -> elt * t
      val pop_max : t -> elt * t
      val max_elt : t -> elt
      val max_elt_opt : t -> elt option
      val choose : t -> elt
      val choose_opt : t -> elt option
      val any : t -> elt
      val pop : t -> elt * t
      val enum : t -> elt BatEnum.t
      val backwards : t -> elt BatEnum.t
      val of_enum : elt BatEnum.t -> t
      val of_list : elt list -> t
      val of_array : elt array -> t
      val to_seq : t -> elt BatSeq.t
      val to_rev_seq : t -> elt BatSeq.t
      val to_seq_from : elt -> t -> elt BatSeq.t
      val add_seq : elt BatSeq.t -> t -> t
      val of_seq : elt BatSeq.t -> t
      val print :
        ?first:string ->
        ?last:string ->
        ?sep:string ->
        ('BatInnerIO.output -> elt -> unit) ->
        'BatInnerIO.output -> t -> unit
      module Exceptionless :
        sig
          val min_elt : t -> elt option
          val max_elt : t -> elt option
          val choose : t -> elt option
          val any : t -> elt option
          val find : elt -> t -> elt option
        end
      module Labels :
        sig
          val iter : f:(elt -> unit) -> t -> unit
          val fold : f:(elt -> '-> 'a) -> t -> init:'-> '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 Int64 :
    sig
      type elt = int64
      type t
      val empty : t
      val is_empty : t -> bool
      val is_singleton : t -> bool
      val singleton : elt -> t
      val mem : elt -> t -> bool
      val find : elt -> t -> elt
      val find_opt : elt -> t -> elt option
      val find_first : (elt -> bool) -> t -> elt
      val find_first_opt : (elt -> bool) -> t -> elt option
      val find_last : (elt -> bool) -> t -> elt
      val find_last_opt : (elt -> bool) -> t -> elt option
      val add : elt -> t -> t
      val remove : elt -> t -> t
      val remove_exn : elt -> t -> t
      val update : elt -> elt -> t -> t
      val union : t -> t -> t
      val inter : t -> t -> t
      val diff : t -> t -> t
      val sym_diff : t -> t -> t
      val compare : t -> t -> int
      val equal : t -> t -> bool
      val subset : t -> t -> bool
      val disjoint : t -> t -> bool
      val compare_subset : t -> t -> int
      val iter : (elt -> unit) -> t -> unit
      val at_rank_exn : int -> t -> elt
      val map : (elt -> elt) -> t -> t
      val filter : (elt -> bool) -> t -> t
      val filter_map : (elt -> elt option) -> t -> t
      val fold : (elt -> '-> 'a) -> t -> '-> 'a
      val for_all : (elt -> bool) -> t -> bool
      val exists : (elt -> bool) -> t -> bool
      val partition : (elt -> bool) -> t -> t * t
      val split : elt -> t -> t * bool * t
      val split_opt : elt -> t -> t * elt option * t
      val split_lt : elt -> t -> t * t
      val split_le : elt -> t -> t * t
      val cardinal : t -> int
      val elements : t -> elt list
      val to_list : t -> elt list
      val to_array : t -> elt array
      val min_elt : t -> elt
      val min_elt_opt : t -> elt option
      val pop_min : t -> elt * t
      val pop_max : t -> elt * t
      val max_elt : t -> elt
      val max_elt_opt : t -> elt option
      val choose : t -> elt
      val choose_opt : t -> elt option
      val any : t -> elt
      val pop : t -> elt * t
      val enum : t -> elt BatEnum.t
      val backwards : t -> elt BatEnum.t
      val of_enum : elt BatEnum.t -> t
      val of_list : elt list -> t
      val of_array : elt array -> t
      val to_seq : t -> elt BatSeq.t
      val to_rev_seq : t -> elt BatSeq.t
      val to_seq_from : elt -> t -> elt BatSeq.t
      val add_seq : elt BatSeq.t -> t -> t
      val of_seq : elt BatSeq.t -> t
      val print :
        ?first:string ->
        ?last:string ->
        ?sep:string ->
        ('BatInnerIO.output -> elt -> unit) ->
        'BatInnerIO.output -> t -> unit
      module Exceptionless :
        sig
          val min_elt : t -> elt option
          val max_elt : t -> elt option
          val choose : t -> elt option
          val any : t -> elt option
          val find : elt -> t -> elt option
        end
      module Labels :
        sig
          val iter : f:(elt -> unit) -> t -> unit
          val fold : f:(elt -> '-> 'a) -> t -> init:'-> '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 Nativeint :
    sig
      type elt = nativeint
      type t
      val empty : t
      val is_empty : t -> bool
      val is_singleton : t -> bool
      val singleton : elt -> t
      val mem : elt -> t -> bool
      val find : elt -> t -> elt
      val find_opt : elt -> t -> elt option
      val find_first : (elt -> bool) -> t -> elt
      val find_first_opt : (elt -> bool) -> t -> elt option
      val find_last : (elt -> bool) -> t -> elt
      val find_last_opt : (elt -> bool) -> t -> elt option
      val add : elt -> t -> t
      val remove : elt -> t -> t
      val remove_exn : elt -> t -> t
      val update : elt -> elt -> t -> t
      val union : t -> t -> t
      val inter : t -> t -> t
      val diff : t -> t -> t
      val sym_diff : t -> t -> t
      val compare : t -> t -> int
      val equal : t -> t -> bool
      val subset : t -> t -> bool
      val disjoint : t -> t -> bool
      val compare_subset : t -> t -> int
      val iter : (elt -> unit) -> t -> unit
      val at_rank_exn : int -> t -> elt
      val map : (elt -> elt) -> t -> t
      val filter : (elt -> bool) -> t -> t
      val filter_map : (elt -> elt option) -> t -> t
      val fold : (elt -> '-> 'a) -> t -> '-> 'a
      val for_all : (elt -> bool) -> t -> bool
      val exists : (elt -> bool) -> t -> bool
      val partition : (elt -> bool) -> t -> t * t
      val split : elt -> t -> t * bool * t
      val split_opt : elt -> t -> t * elt option * t
      val split_lt : elt -> t -> t * t
      val split_le : elt -> t -> t * t
      val cardinal : t -> int
      val elements : t -> elt list
      val to_list : t -> elt list
      val to_array : t -> elt array
      val min_elt : t -> elt
      val min_elt_opt : t -> elt option
      val pop_min : t -> elt * t
      val pop_max : t -> elt * t
      val max_elt : t -> elt
      val max_elt_opt : t -> elt option
      val choose : t -> elt
      val choose_opt : t -> elt option
      val any : t -> elt
      val pop : t -> elt * t
      val enum : t -> elt BatEnum.t
      val backwards : t -> elt BatEnum.t
      val of_enum : elt BatEnum.t -> t
      val of_list : elt list -> t
      val of_array : elt array -> t
      val to_seq : t -> elt BatSeq.t
      val to_rev_seq : t -> elt BatSeq.t
      val to_seq_from : elt -> t -> elt BatSeq.t
      val add_seq : elt BatSeq.t -> t -> t
      val of_seq : elt BatSeq.t -> t
      val print :
        ?first:string ->
        ?last:string ->
        ?sep:string ->
        ('BatInnerIO.output -> elt -> unit) ->
        'BatInnerIO.output -> t -> unit
      module Exceptionless :
        sig
          val min_elt : t -> elt option
          val max_elt : t -> elt option
          val choose : t -> elt option
          val any : t -> elt option
          val find : elt -> t -> elt option
        end
      module Labels :
        sig
          val iter : f:(elt -> unit) -> t -> unit
          val fold : f:(elt -> '-> 'a) -> t -> init:'-> '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 Float :
    sig
      type elt = float
      type t
      val empty : t
      val is_empty : t -> bool
      val is_singleton : t -> bool
      val singleton : elt -> t
      val mem : elt -> t -> bool
      val find : elt -> t -> elt
      val find_opt : elt -> t -> elt option
      val find_first : (elt -> bool) -> t -> elt
      val find_first_opt : (elt -> bool) -> t -> elt option
      val find_last : (elt -> bool) -> t -> elt
      val find_last_opt : (elt -> bool) -> t -> elt option
      val add : elt -> t -> t
      val remove : elt -> t -> t
      val remove_exn : elt -> t -> t
      val update : elt -> elt -> t -> t
      val union : t -> t -> t
      val inter : t -> t -> t
      val diff : t -> t -> t
      val sym_diff : t -> t -> t
      val compare : t -> t -> int
      val equal : t -> t -> bool
      val subset : t -> t -> bool
      val disjoint : t -> t -> bool
      val compare_subset : t -> t -> int
      val iter : (elt -> unit) -> t -> unit
      val at_rank_exn : int -> t -> elt
      val map : (elt -> elt) -> t -> t
      val filter : (elt -> bool) -> t -> t
      val filter_map : (elt -> elt option) -> t -> t
      val fold : (elt -> '-> 'a) -> t -> '-> 'a
      val for_all : (elt -> bool) -> t -> bool
      val exists : (elt -> bool) -> t -> bool
      val partition : (elt -> bool) -> t -> t * t
      val split : elt -> t -> t * bool * t
      val split_opt : elt -> t -> t * elt option * t
      val split_lt : elt -> t -> t * t
      val split_le : elt -> t -> t * t
      val cardinal : t -> int
      val elements : t -> elt list
      val to_list : t -> elt list
      val to_array : t -> elt array
      val min_elt : t -> elt
      val min_elt_opt : t -> elt option
      val pop_min : t -> elt * t
      val pop_max : t -> elt * t
      val max_elt : t -> elt
      val max_elt_opt : t -> elt option
      val choose : t -> elt
      val choose_opt : t -> elt option
      val any : t -> elt
      val pop : t -> elt * t
      val enum : t -> elt BatEnum.t
      val backwards : t -> elt BatEnum.t
      val of_enum : elt BatEnum.t -> t
      val of_list : elt list -> t
      val of_array : elt array -> t
      val to_seq : t -> elt BatSeq.t
      val to_rev_seq : t -> elt BatSeq.t
      val to_seq_from : elt -> t -> elt BatSeq.t
      val add_seq : elt BatSeq.t -> t -> t
      val of_seq : elt BatSeq.t -> t
      val print :
        ?first:string ->
        ?last:string ->
        ?sep:string ->
        ('BatInnerIO.output -> elt -> unit) ->
        'BatInnerIO.output -> t -> unit
      module Exceptionless :
        sig
          val min_elt : t -> elt option
          val max_elt : t -> elt option
          val choose : t -> elt option
          val any : t -> elt option
          val find : elt -> t -> elt option
        end
      module Labels :
        sig
          val iter : f:(elt -> unit) -> t -> unit
          val fold : f:(elt -> '-> 'a) -> t -> init:'-> '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 Char :
    sig
      type elt = char
      type t
      val empty : t
      val is_empty : t -> bool
      val is_singleton : t -> bool
      val singleton : elt -> t
      val mem : elt -> t -> bool
      val find : elt -> t -> elt
      val find_opt : elt -> t -> elt option
      val find_first : (elt -> bool) -> t -> elt
      val find_first_opt : (elt -> bool) -> t -> elt option
      val find_last : (elt -> bool) -> t -> elt
      val find_last_opt : (elt -> bool) -> t -> elt option
      val add : elt -> t -> t
      val remove : elt -> t -> t
      val remove_exn : elt -> t -> t
      val update : elt -> elt -> t -> t
      val union : t -> t -> t
      val inter : t -> t -> t
      val diff : t -> t -> t
      val sym_diff : t -> t -> t
      val compare : t -> t -> int
      val equal : t -> t -> bool
      val subset : t -> t -> bool
      val disjoint : t -> t -> bool
      val compare_subset : t -> t -> int
      val iter : (elt -> unit) -> t -> unit
      val at_rank_exn : int -> t -> elt
      val map : (elt -> elt) -> t -> t
      val filter : (elt -> bool) -> t -> t
      val filter_map : (elt -> elt option) -> t -> t
      val fold : (elt -> '-> 'a) -> t -> '-> 'a
      val for_all : (elt -> bool) -> t -> bool
      val exists : (elt -> bool) -> t -> bool
      val partition : (elt -> bool) -> t -> t * t
      val split : elt -> t -> t * bool * t
      val split_opt : elt -> t -> t * elt option * t
      val split_lt : elt -> t -> t * t
      val split_le : elt -> t -> t * t
      val cardinal : t -> int
      val elements : t -> elt list
      val to_list : t -> elt list
      val to_array : t -> elt array
      val min_elt : t -> elt
      val min_elt_opt : t -> elt option
      val pop_min : t -> elt * t
      val pop_max : t -> elt * t
      val max_elt : t -> elt
      val max_elt_opt : t -> elt option
      val choose : t -> elt
      val choose_opt : t -> elt option
      val any : t -> elt
      val pop : t -> elt * t
      val enum : t -> elt BatEnum.t
      val backwards : t -> elt BatEnum.t
      val of_enum : elt BatEnum.t -> t
      val of_list : elt list -> t
      val of_array : elt array -> t
      val to_seq : t -> elt BatSeq.t
      val to_rev_seq : t -> elt BatSeq.t
      val to_seq_from : elt -> t -> elt BatSeq.t
      val add_seq : elt BatSeq.t -> t -> t
      val of_seq : elt BatSeq.t -> t
      val print :
        ?first:string ->
        ?last:string ->
        ?sep:string ->
        ('BatInnerIO.output -> elt -> unit) ->
        'BatInnerIO.output -> t -> unit
      module Exceptionless :
        sig
          val min_elt : t -> elt option
          val max_elt : t -> elt option
          val choose : t -> elt option
          val any : t -> elt option
          val find : elt -> t -> elt option
        end
      module Labels :
        sig
          val iter : f:(elt -> unit) -> t -> unit
          val fold : f:(elt -> '-> 'a) -> t -> init:'-> '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 String :
    sig
      type elt = string
      type t
      val empty : t
      val is_empty : t -> bool
      val is_singleton : t -> bool
      val singleton : elt -> t
      val mem : elt -> t -> bool
      val find : elt -> t -> elt
      val find_opt : elt -> t -> elt option
      val find_first : (elt -> bool) -> t -> elt
      val find_first_opt : (elt -> bool) -> t -> elt option
      val find_last : (elt -> bool) -> t -> elt
      val find_last_opt : (elt -> bool) -> t -> elt option
      val add : elt -> t -> t
      val remove : elt -> t -> t
      val remove_exn : elt -> t -> t
      val update : elt -> elt -> t -> t
      val union : t -> t -> t
      val inter : t -> t -> t
      val diff : t -> t -> t
      val sym_diff : t -> t -> t
      val compare : t -> t -> int
      val equal : t -> t -> bool
      val subset : t -> t -> bool
      val disjoint : t -> t -> bool
      val compare_subset : t -> t -> int
      val iter : (elt -> unit) -> t -> unit
      val at_rank_exn : int -> t -> elt
      val map : (elt -> elt) -> t -> t
      val filter : (elt -> bool) -> t -> t
      val filter_map : (elt -> elt option) -> t -> t
      val fold : (elt -> '-> 'a) -> t -> '-> 'a
      val for_all : (elt -> bool) -> t -> bool
      val exists : (elt -> bool) -> t -> bool
      val partition : (elt -> bool) -> t -> t * t
      val split : elt -> t -> t * bool * t
      val split_opt : elt -> t -> t * elt option * t
      val split_lt : elt -> t -> t * t
      val split_le : elt -> t -> t * t
      val cardinal : t -> int
      val elements : t -> elt list
      val to_list : t -> elt list
      val to_array : t -> elt array
      val min_elt : t -> elt
      val min_elt_opt : t -> elt option
      val pop_min : t -> elt * t
      val pop_max : t -> elt * t
      val max_elt : t -> elt
      val max_elt_opt : t -> elt option
      val choose : t -> elt
      val choose_opt : t -> elt option
      val any : t -> elt
      val pop : t -> elt * t
      val enum : t -> elt BatEnum.t
      val backwards : t -> elt BatEnum.t
      val of_enum : elt BatEnum.t -> t
      val of_list : elt list -> t
      val of_array : elt array -> t
      val to_seq : t -> elt BatSeq.t
      val to_rev_seq : t -> elt BatSeq.t
      val to_seq_from : elt -> t -> elt BatSeq.t
      val add_seq : elt BatSeq.t -> t -> t
      val of_seq : elt BatSeq.t -> t
      val print :
        ?first:string ->
        ?last:string ->
        ?sep:string ->
        ('BatInnerIO.output -> elt -> unit) ->
        'BatInnerIO.output -> t -> unit
      module Exceptionless :
        sig
          val min_elt : t -> elt option
          val max_elt : t -> elt option
          val choose : t -> elt option
          val any : t -> elt option
          val find : elt -> t -> elt option
        end
      module Labels :
        sig
          val iter : f:(elt -> unit) -> t -> unit
          val fold : f:(elt -> '-> 'a) -> t -> init:'-> '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
  type 'a mappable = 'a t
  val empty : 'BatSet.t
  val is_empty : 'BatSet.t -> bool
  val is_singleton : 'BatSet.t -> bool
  val singleton : '-> 'BatSet.t
  val mem : '-> 'BatSet.t -> bool
  val find : '-> 'BatSet.t -> 'a
  val find_opt : '-> 'BatSet.t -> 'a option
  val find_first : ('-> bool) -> 'BatSet.t -> 'a
  val find_first_opt : ('-> bool) -> 'BatSet.t -> 'a option
  val find_last : ('-> bool) -> 'BatSet.t -> 'a
  val find_last_opt : ('-> bool) -> 'BatSet.t -> 'a option
  val add : '-> 'BatSet.t -> 'BatSet.t
  val remove : '-> 'BatSet.t -> 'BatSet.t
  val remove_exn : '-> 'BatSet.t -> 'BatSet.t
  val update : '-> '-> 'BatSet.t -> 'BatSet.t
  val union : 'BatSet.t -> 'BatSet.t -> 'BatSet.t
  val intersect : 'BatSet.t -> 'BatSet.t -> 'BatSet.t
  val diff : 'BatSet.t -> 'BatSet.t -> 'BatSet.t
  val sym_diff : 'BatSet.t -> 'BatSet.t -> 'BatSet.t
  val compare : 'BatSet.t -> 'BatSet.t -> int
  val equal : 'BatSet.t -> 'BatSet.t -> bool
  val subset : 'BatSet.t -> 'BatSet.t -> bool
  val disjoint : 'BatSet.t -> 'BatSet.t -> bool
  val iter : ('-> unit) -> 'BatSet.t -> unit
  val at_rank_exn : int -> 'BatSet.t -> 'a
  val map : ('-> 'b) -> 'BatSet.t -> 'BatSet.t
  val map_endo : ('-> 'a) -> 'BatSet.t -> 'BatSet.t
  val filter : ('-> bool) -> 'BatSet.t -> 'BatSet.t
  val filter_map : ('-> 'b option) -> 'BatSet.t -> 'BatSet.t
  val filter_map_endo : ('-> 'a option) -> 'BatSet.t -> 'BatSet.t
  val fold : ('-> '-> 'b) -> 'BatSet.t -> '-> 'b
  val exists : ('-> bool) -> 'BatSet.t -> bool
  val for_all : ('-> bool) -> 'BatSet.t -> bool
  val partition : ('-> bool) -> 'BatSet.t -> 'BatSet.t * 'BatSet.t
  val split : '-> 'BatSet.t -> 'BatSet.t * bool * 'BatSet.t
  val split_opt : '-> 'BatSet.t -> 'BatSet.t * 'a option * 'BatSet.t
  val split_lt : '-> 'BatSet.t -> 'BatSet.t * 'BatSet.t
  val split_le : '-> 'BatSet.t -> 'BatSet.t * 'BatSet.t
  val cardinal : 'BatSet.t -> int
  val elements : 'BatSet.t -> 'a list
  val to_list : 'BatSet.t -> 'a list
  val to_array : 'BatSet.t -> 'a array
  val min_elt : 'BatSet.t -> 'a
  val min_elt_opt : 'BatSet.t -> 'a option
  val pop_min : 'BatSet.t -> 'a * 'BatSet.t
  val pop_max : 'BatSet.t -> 'a * 'BatSet.t
  val max_elt : 'BatSet.t -> 'a
  val max_elt_opt : 'BatSet.t -> 'a option
  val choose : 'BatSet.t -> 'a
  val choose_opt : 'BatSet.t -> 'a option
  val any : 'BatSet.t -> 'a
  val pop : 'BatSet.t -> 'a * 'BatSet.t
  val cartesian_product : 'BatSet.t -> 'BatSet.t -> ('a * 'b) BatSet.t
  val enum : 'BatSet.t -> 'BatEnum.t
  val of_enum : 'BatEnum.t -> 'BatSet.t
  val backwards : 'BatSet.t -> 'BatEnum.t
  val of_list : 'a list -> 'BatSet.t
  val of_array : 'a array -> 'BatSet.t
  val to_seq : 'BatSet.t -> 'BatSeq.t
  val to_rev_seq : 'BatSet.t -> 'BatSeq.t
  val to_seq_from : '-> 'BatSet.t -> 'BatSeq.t
  val add_seq : 'BatSeq.t -> 'BatSet.t -> 'BatSet.t
  val of_seq : 'BatSeq.t -> 'BatSet.t
  val print :
    ?first:string ->
    ?last:string ->
    ?sep:string ->
    ('BatInnerIO.output -> '-> unit) ->
    'BatInnerIO.output -> 'BatSet.t -> unit
  module Incubator :
    sig val op_map : ('-> 'b) -> 'BatSet.t -> 'BatSet.t end
  module PSet :
    sig
      type 'a t
      type 'a enumerable = 'a t
      type 'a mappable = 'a t
      val empty : 'BatSet.PSet.t
      val create : ('-> '-> int) -> 'BatSet.PSet.t
      val is_empty : 'BatSet.PSet.t -> bool
      val is_singleton : 'BatSet.PSet.t -> bool
      val singleton : ?cmp:('-> '-> int) -> '-> 'BatSet.PSet.t
      val mem : '-> 'BatSet.PSet.t -> bool
      val find : '-> 'BatSet.PSet.t -> 'a
      val find_opt : '-> 'BatSet.PSet.t -> 'a option
      val find_first : ('-> bool) -> 'BatSet.PSet.t -> 'a
      val find_first_opt : ('-> bool) -> 'BatSet.PSet.t -> 'a option
      val find_last : ('-> bool) -> 'BatSet.PSet.t -> 'a
      val find_last_opt : ('-> bool) -> 'BatSet.PSet.t -> 'a option
      val add : '-> 'BatSet.PSet.t -> 'BatSet.PSet.t
      val remove : '-> 'BatSet.PSet.t -> 'BatSet.PSet.t
      val remove_exn : '-> 'BatSet.PSet.t -> 'BatSet.PSet.t
      val update : '-> '-> 'BatSet.PSet.t -> 'BatSet.PSet.t
      val union : 'BatSet.PSet.t -> 'BatSet.PSet.t -> 'BatSet.PSet.t
      val intersect :
        'BatSet.PSet.t -> 'BatSet.PSet.t -> 'BatSet.PSet.t
      val diff : 'BatSet.PSet.t -> 'BatSet.PSet.t -> 'BatSet.PSet.t
      val sym_diff : 'BatSet.PSet.t -> 'BatSet.PSet.t -> 'BatSet.PSet.t
      val compare : 'BatSet.PSet.t -> 'BatSet.PSet.t -> int
      val equal : 'BatSet.PSet.t -> 'BatSet.PSet.t -> bool
      val subset : 'BatSet.PSet.t -> 'BatSet.PSet.t -> bool
      val disjoint : 'BatSet.PSet.t -> 'BatSet.PSet.t -> bool
      val iter : ('-> unit) -> 'BatSet.PSet.t -> unit
      val at_rank_exn : int -> 'BatSet.PSet.t -> 'a
      val map : ('-> 'b) -> 'BatSet.PSet.t -> 'BatSet.PSet.t
      val map_endo : ('-> 'a) -> 'BatSet.PSet.t -> 'BatSet.PSet.t
      val filter : ('-> bool) -> 'BatSet.PSet.t -> 'BatSet.PSet.t
      val filter_map :
        ('-> 'b option) -> 'BatSet.PSet.t -> 'BatSet.PSet.t
      val filter_map_endo :
        ('-> 'a option) -> 'BatSet.PSet.t -> 'BatSet.PSet.t
      val fold : ('-> '-> 'b) -> 'BatSet.PSet.t -> '-> 'b
      val exists : ('-> bool) -> 'BatSet.PSet.t -> bool
      val for_all : ('-> bool) -> 'BatSet.PSet.t -> bool
      val partition :
        ('-> bool) ->
        'BatSet.PSet.t -> 'BatSet.PSet.t * 'BatSet.PSet.t
      val split :
        '-> 'BatSet.PSet.t -> 'BatSet.PSet.t * bool * 'BatSet.PSet.t
      val split_opt :
        '->
        'BatSet.PSet.t -> 'BatSet.PSet.t * 'a option * 'BatSet.PSet.t
      val split_lt :
        '-> 'BatSet.PSet.t -> 'BatSet.PSet.t * 'BatSet.PSet.t
      val split_le :
        '-> 'BatSet.PSet.t -> 'BatSet.PSet.t * 'BatSet.PSet.t
      val cardinal : 'BatSet.PSet.t -> int
      val elements : 'BatSet.PSet.t -> 'a list
      val to_list : 'BatSet.PSet.t -> 'a list
      val to_array : 'BatSet.PSet.t -> 'a array
      val min_elt : 'BatSet.PSet.t -> 'a
      val min_elt_opt : 'BatSet.PSet.t -> 'a option
      val pop_min : 'BatSet.PSet.t -> 'a * 'BatSet.PSet.t
      val pop_max : 'BatSet.PSet.t -> 'a * 'BatSet.PSet.t
      val max_elt : 'BatSet.PSet.t -> 'a
      val max_elt_opt : 'BatSet.PSet.t -> 'a option
      val choose : 'BatSet.PSet.t -> 'a
      val choose_opt : 'BatSet.PSet.t -> 'a option
      val any : 'BatSet.PSet.t -> 'a
      val pop : 'BatSet.PSet.t -> 'a * 'BatSet.PSet.t
      val enum : 'BatSet.PSet.t -> 'BatEnum.t
      val of_enum :
        ?cmp:('-> '-> int) -> 'BatEnum.t -> 'BatSet.PSet.t
      val of_enum_cmp :
        cmp:('-> '-> int) -> 'BatEnum.t -> 'BatSet.PSet.t
      val of_list : ?cmp:('-> '-> int) -> 'a list -> 'BatSet.PSet.t
      val of_array : ?cmp:('-> '-> int) -> 'a array -> 'BatSet.PSet.t
      val to_seq : 'BatSet.PSet.t -> 'BatSeq.t
      val to_rev_seq : 'BatSet.PSet.t -> 'BatSeq.t
      val to_seq_from : '-> 'BatSet.PSet.t -> 'BatSeq.t
      val add_seq : 'BatSeq.t -> 'BatSet.PSet.t -> 'BatSet.PSet.t
      val of_seq : ?cmp:('-> '-> int) -> 'BatSeq.t -> 'BatSet.PSet.t
      val print :
        ?first:string ->
        ?last:string ->
        ?sep:string ->
        ('BatInnerIO.output -> '-> unit) ->
        'BatInnerIO.output -> 'BatSet.PSet.t -> unit
      val get_cmp : 'BatSet.PSet.t -> '-> '-> int
    end
end