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 singleton : elt -> t         val mem : elt -> t -> bool         val find : elt -> t -> elt         val add : elt -> t -> t         val remove : 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 pop_min : t -> elt * t         val pop_max : t -> elt * t         val max_elt : t -> elt         val choose : 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 print :           ?first:string ->           ?last:string ->           ?sep:string ->           ('BatInnerIO.output -> elt -> unit) ->           'BatInnerIO.output -> t -> unit         module Infix :           sig             val ( <-- ) : t -> elt -> t             val ( <. ) : t -> t -> bool             val ( >. ) : t -> t -> bool             val ( <=. ) : t -> t -> bool             val ( >=. ) : t -> t -> bool             val ( -. ) : t -> t -> t             val ( &&. ) : t -> t -> t             val ( ||. ) : t -> t -> t           end         module Exceptionless :           sig             val min_elt : t -> elt option             val max_elt : t -> elt option             val choose : 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