sig
  type 'a t = 'a array
  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 fold_lefti : ('a -> int -> 'b -> 'a) -> 'a -> 'b array -> 'a
  val reduce : ('a -> 'a -> 'a) -> 'a array -> 'a
  val max : 'a array -> 'a
  val min : 'a array -> 'a
  val iter2 : ('a -> 'b -> unit) -> 'a array -> 'b array -> unit
  val iter2i : (int -> 'a -> 'b -> unit) -> 'a array -> 'b array -> unit
  val for_all2 : ('a -> 'b -> bool) -> 'a array -> 'b array -> bool
  val exists2 : ('a -> 'b -> bool) -> 'a array -> 'b array -> bool
  val map2 : ('a -> 'b -> 'c) -> 'a array -> 'b array -> 'c array
  val for_all : ('a -> bool) -> 'a array -> bool
  val exists : ('a -> bool) -> 'a array -> bool
  val find : ('a -> bool) -> 'a array -> 'a
  val mem : 'a -> 'a array -> bool
  val memq : 'a -> 'a array -> bool
  val findi : ('a -> bool) -> 'a array -> int
  val filter : ('a -> bool) -> 'a array -> 'a array
  val filter_map : ('a -> 'b option) -> 'a array -> 'b array
  val find_all : ('a -> bool) -> 'a array -> 'a array
  val partition : ('a -> bool) -> 'a array -> 'a array * 'a array
  val rev : 'a array -> 'a array
  val rev_in_place : 'a array -> unit
  val enum : 'a array -> 'a BatEnum.t
  val of_enum : 'a BatEnum.t -> 'a array
  val backwards : 'a array -> 'a BatEnum.t
  val of_backwards : 'a BatEnum.t -> 'a array
  val make_compare : ('a -> 'a -> int) -> 'a array -> 'a array -> int
  val decorate_stable_sort : ('a -> 'b) -> 'a array -> 'a array
  val decorate_fast_sort : ('a -> 'b) -> 'a array -> 'a array
  val range : 'a array -> int BatEnum.t
  val print :
    ?first:string ->
    ?last:string ->
    ?sep:string ->
    ('a BatIO.output -> 'b -> unit) -> 'a BatIO.output -> 'b t -> unit
  val sprint :
    ?first:string ->
    ?last:string ->
    ?sep:string -> ('a BatIO.output -> 'b -> unit) -> 'b t -> string
  val t_printer : 'a BatValue_printer.t -> 'a BatArray.t BatValue_printer.t
  module Cap :
    sig
      type ('a, 'b) t constraint 'b = [< `Read | `Write ]
      external length : ('a, [< `Read | `Write ]) BatArray.Cap.t -> int
        = "%array_length"
      external get :
        ('a, [< `Read | `Write > `Read ]) BatArray.Cap.t -> int -> 'a
        = "%array_safe_get"
      external set :
        ('a, [< `Read | `Write > `Write ]) BatArray.Cap.t ->
        int -> 'a -> unit = "%array_safe_set"
      external make : int -> 'a -> ('a, [< `Read | `Write ]) BatArray.Cap.t
        = "caml_make_vect"
      external create : int -> 'a -> ('a, [< `Read | `Write ]) BatArray.Cap.t
        = "caml_make_vect"
      external of_array :
        'a array -> ('a, [< `Read | `Write ]) BatArray.Cap.t = "%identity"
      external to_array : ('a, [ `Read | `Write ]) BatArray.Cap.t -> 'a array
        = "%identity"
      external read_only :
        ('a, [< `Read | `Write > `Read ]) BatArray.Cap.t ->
        ('a, [ `Read ]) BatArray.Cap.t = "%identity"
      external write_only :
        ('a, [< `Read | `Write > `Write ]) BatArray.Cap.t ->
        ('a, [ `Write ]) BatArray.Cap.t = "%identity"
      val init :
        int -> (int -> 'a) -> ('a, [< `Read | `Write ]) BatArray.Cap.t
      val make_matrix :
        int ->
        int ->
        'a ->
        (('a, [< `Read | `Write ]) BatArray.Cap.t, [< `Read | `Write ])
        BatArray.Cap.t
      val create_matrix :
        int ->
        int ->
        'a ->
        (('a, [< `Read | `Write ]) BatArray.Cap.t, [< `Read | `Write ])
        BatArray.Cap.t
      val iter :
        ('a -> unit) ->
        ('a, [< `Read | `Write > `Read ]) BatArray.Cap.t -> unit
      val map :
        ('a -> 'b) ->
        ('a, [< `Read | `Write > `Read ]) BatArray.Cap.t ->
        ('b, [< `Read | `Write ]) BatArray.Cap.t
      val iteri :
        (int -> 'a -> unit) ->
        ('a, [< `Read | `Write > `Read ]) BatArray.Cap.t -> unit
      val mapi :
        (int -> 'a -> 'b) ->
        ('a, [< `Read | `Write > `Read ]) BatArray.Cap.t ->
        ('b, [< `Read | `Write ]) BatArray.Cap.t
      val fold_left :
        ('a -> 'b -> 'a) ->
        'a -> ('b, [< `Read | `Write > `Read ]) BatArray.Cap.t -> 'a
      val fold_right :
        ('a -> 'b -> 'b) ->
        ('a, [< `Read | `Write > `Read ]) BatArray.Cap.t -> 'b -> 'b
      val iter2 :
        ('a -> 'b -> unit) ->
        ('a, [< `Read | `Write > `Read ]) BatArray.Cap.t ->
        ('b, [< `Read | `Write > `Read ]) BatArray.Cap.t -> unit
      val iter2i :
        (int -> 'a -> 'b -> unit) ->
        ('a, [< `Read | `Write > `Read ]) BatArray.Cap.t ->
        ('b, [< `Read | `Write > `Read ]) BatArray.Cap.t -> unit
      val for_all :
        ('a -> bool) ->
        ('a, [< `Read | `Write > `Read ]) BatArray.Cap.t -> bool
      val exists :
        ('a -> bool) ->
        ('a, [< `Read | `Write > `Read ]) BatArray.Cap.t -> bool
      val find :
        ('a -> bool) ->
        ('a, [< `Read | `Write > `Read ]) BatArray.Cap.t -> 'a
      val mem :
        'a -> ('a, [< `Read | `Write > `Read ]) BatArray.Cap.t -> bool
      val memq :
        'a -> ('a, [< `Read | `Write > `Read ]) BatArray.Cap.t -> bool
      val findi :
        ('a -> bool) ->
        ('a, [< `Read | `Write > `Read ]) BatArray.Cap.t -> int
      val filter :
        ('a -> bool) ->
        ('a, [< `Read | `Write > `Read ]) BatArray.Cap.t ->
        ('a, [< `Read | `Write ]) BatArray.Cap.t
      val filter_map :
        ('a -> 'b option) ->
        ('a, [< `Read | `Write > `Read ]) BatArray.Cap.t ->
        ('b, [< `Read | `Write ]) BatArray.Cap.t
      val find_all :
        ('a -> bool) ->
        ('a, [< `Read | `Write > `Read ]) BatArray.Cap.t ->
        ('a, [< `Read | `Write ]) BatArray.Cap.t
      val partition :
        ('a -> bool) ->
        ('a, [< `Read | `Write > `Read ]) BatArray.Cap.t ->
        ('a, [< `Read | `Write ]) BatArray.Cap.t *
        ('a, [< `Read | `Write ]) BatArray.Cap.t
      val rev :
        ('a, [< `Read | `Write > `Read ]) BatArray.Cap.t ->
        ('a, [< `Read | `Write ]) BatArray.Cap.t
      val rev_in_place : ('a, [ `Read | `Write ]) BatArray.Cap.t -> unit
      val append :
        ('a, [< `Read | `Write > `Read ]) BatArray.Cap.t ->
        ('a, [< `Read | `Write > `Read ]) BatArray.Cap.t ->
        ('a, [< `Read | `Write ]) BatArray.Cap.t
      val concat :
        ('a, [< `Read | `Write > `Read ]) BatArray.Cap.t list ->
        ('a, [< `Read | `Write ]) BatArray.Cap.t
      val sub :
        ('a, [< `Read | `Write > `Read ]) BatArray.Cap.t ->
        int -> int -> ('a, [< `Read | `Write ]) BatArray.Cap.t
      val copy : ('a, [< `Read | `Write > `Read ]) BatArray.Cap.t -> 'a array
      val fill :
        ('a, [< `Read | `Write > `Write ]) BatArray.Cap.t ->
        int -> int -> 'a -> unit
      val blit :
        ('a, [< `Read | `Write > `Read ]) BatArray.Cap.t ->
        int ->
        ('a, [< `Read | `Write > `Write ]) BatArray.Cap.t ->
        int -> int -> unit
      val enum :
        ('a, [< `Read | `Write > `Read ]) BatArray.Cap.t -> 'a BatEnum.t
      val of_enum : 'a BatEnum.t -> ('a, [< `Read | `Write ]) BatArray.Cap.t
      val backwards :
        ('a, [< `Read | `Write > `Read ]) BatArray.Cap.t -> 'a BatEnum.t
      val of_backwards :
        'a BatEnum.t -> ('a, [< `Read | `Write ]) BatArray.Cap.t
      val to_list :
        ('a, [< `Read | `Write > `Read ]) BatArray.Cap.t -> 'a list
      val of_list : 'a list -> ('a, [< `Read | `Write ]) BatArray.Cap.t
      val make_compare :
        ('a -> 'a -> int) ->
        ('a, [< `Read | `Write > `Read ]) BatArray.Cap.t ->
        ('a, [< `Read | `Write > `Read ]) BatArray.Cap.t -> int
      val sort :
        ('a -> 'a -> int) -> ('a, [ `Read | `Write ]) BatArray.Cap.t -> unit
      val stable_sort :
        ('a -> 'a -> int) -> ('a, [ `Read | `Write ]) BatArray.Cap.t -> unit
      val fast_sort :
        ('a -> 'a -> int) -> ('a, [ `Read | `Write ]) BatArray.Cap.t -> unit
      val print :
        ?first:string ->
        ?last:string ->
        ?sep:string ->
        ('a BatIO.output -> 'b -> unit) ->
        'a BatIO.output ->
        ('b, [< `Read | `Write > `Read ]) BatArray.Cap.t -> unit
      val sprint :
        ?first:string ->
        ?last:string ->
        ?sep:string ->
        ('a BatIO.output -> 'b -> unit) ->
        ('b, [< `Read | `Write > `Read ]) BatArray.Cap.t -> string
      external unsafe_get :
        ('a, [< `Read | `Write > `Read ]) BatArray.Cap.t -> int -> 'a
        = "%array_unsafe_get"
      external unsafe_set :
        ('a, [< `Read | `Write > `Write ]) BatArray.Cap.t ->
        int -> 'a -> unit = "%array_unsafe_set"
      module Exceptionless :
        sig
          val find :
            ('a -> bool) ->
            ('a, [< `Read | `Write > `Read ]) BatArray.Cap.t -> 'a option
          val findi :
            ('a -> bool) ->
            ('a, [< `Read | `Write > `Read ]) BatArray.Cap.t -> int option
        end
      module Labels :
        sig
          val init :
            int -> f:(int -> 'a) -> ('a, [< `Read | `Write ]) BatArray.Cap.t
          val make :
            int -> init:'a -> ('a, [< `Read | `Write ]) BatArray.Cap.t
          val create :
            int -> init:'a -> ('a, [< `Read | `Write ]) BatArray.Cap.t
          val make_matrix :
            dimx:int ->
            dimy:int ->
            'a ->
            (('a, [< `Read | `Write ]) BatArray.Cap.t, [< `Read | `Write ])
            BatArray.Cap.t
          val create_matrix :
            dimx:int ->
            dimy:int ->
            'a ->
            (('a, [< `Read | `Write ]) BatArray.Cap.t, [< `Read | `Write ])
            BatArray.Cap.t
          val sub :
            ('a, [< `Read | `Write > `Read ]) BatArray.Cap.t ->
            pos:int -> len:int -> ('a, [< `Read | `Write ]) BatArray.Cap.t
          val fill :
            ('a, [< `Read | `Write > `Write ]) BatArray.Cap.t ->
            pos:int -> len:int -> 'a -> unit
          val blit :
            src:('a, [< `Read | `Write > `Read ]) BatArray.Cap.t ->
            src_pos:int ->
            dst:('a, [< `Read | `Write > `Write ]) BatArray.Cap.t ->
            dst_pos:int -> len:int -> unit
          val iter :
            f:('a -> unit) ->
            ('a, [< `Read | `Write > `Read ]) BatArray.Cap.t -> unit
          val map :
            f:('a -> 'b) ->
            ('a, [< `Read | `Write > `Read ]) t ->
            ('b, [< `Read | `Write ]) t
          val iteri :
            f:(int -> 'a -> unit) ->
            ('a, [< `Read | `Write > `Read ]) BatArray.Cap.t -> unit
          val mapi :
            f:(int -> 'a -> 'b) ->
            ('a, [< `Read | `Write > `Read ]) t ->
            ('b, [< `Read | `Write ]) t
          val fold_left :
            f:('a -> 'b -> 'a) ->
            init:'a -> ('b, [< `Read | `Write > `Read ]) BatArray.Cap.t -> 'a
          val fold_right :
            f:('a -> 'b -> 'b) ->
            ('a, [< `Read | `Write > `Read ]) BatArray.Cap.t -> init:'b -> 'b
          val sort :
            cmp:('a -> 'a -> int) ->
            ('a, [ `Read | `Write ]) BatArray.Cap.t -> unit
          val stable_sort :
            cmp:('a -> 'a -> int) ->
            ('a, [ `Read | `Write ]) BatArray.Cap.t -> unit
          val fast_sort :
            cmp:('a -> 'a -> int) ->
            ('a, [ `Read | `Write ]) BatArray.Cap.t -> unit
          val iter2 :
            f:('a -> 'b -> unit) ->
            ('a, [< `Read | `Write > `Read ]) BatArray.Cap.t ->
            ('b, [< `Read | `Write > `Read ]) BatArray.Cap.t -> unit
          val iter2i :
            f:(int -> 'a -> 'b -> unit) ->
            ('a, [< `Read | `Write > `Read ]) BatArray.Cap.t ->
            ('b, [< `Read | `Write > `Read ]) BatArray.Cap.t -> unit
          val exists :
            f:('a -> bool) ->
            ('a, [< `Read | `Write > `Read ]) BatArray.Cap.t -> bool
          val for_all :
            f:('a -> bool) ->
            ('a, [< `Read | `Write > `Read ]) BatArray.Cap.t -> bool
          val find :
            f:('a -> bool) ->
            ('a, [< `Read | `Write > `Read ]) BatArray.Cap.t -> 'a
          val map :
            f:('a -> 'b) ->
            ('a, [< `Read | `Write > `Read ]) BatArray.Cap.t ->
            ('b, [< `Read | `Write ]) BatArray.Cap.t
          val mapi :
            f:(int -> 'a -> 'b) ->
            ('a, [< `Read | `Write > `Read ]) BatArray.Cap.t ->
            ('b, [< `Read | `Write ]) BatArray.Cap.t
          val filter :
            f:('a -> bool) ->
            ('a, [< `Read | `Write > `Read ]) BatArray.Cap.t ->
            ('a, [< `Read | `Write ]) BatArray.Cap.t
          val filter_map :
            f:('a -> 'b option) ->
            ('a, [< `Read | `Write > `Read ]) BatArray.Cap.t ->
            ('b, [< `Read | `Write ]) BatArray.Cap.t
        end
    end
  val print :
    ?first:string ->
    ?last:string ->
    ?sep:string ->
    ('a BatIO.output -> 'b -> unit) ->
    'a BatIO.output -> 'b BatArray.t -> unit
  val sprint :
    ?first:string ->
    ?last:string ->
    ?sep:string -> ('a BatIO.output -> 'b -> unit) -> 'b BatArray.t -> string
  module Exceptionless :
    sig
      val find : ('a -> bool) -> 'a BatArray.t -> 'a option
      val findi : ('a -> bool) -> 'a BatArray.t -> int option
    end
  module Labels :
    sig
      val init : int -> f:(int -> 'a) -> 'a array
      val create : int -> init:'a -> 'a array
      val make_matrix : dimx:int -> dimy:int -> 'a -> 'a array array
      val create_matrix : dimx:int -> dimy:int -> 'a -> 'a array array
      val sub : 'a array -> pos:int -> len:int -> 'a array
      val fill : 'a array -> pos:int -> len:int -> 'a -> unit
      val blit :
        src:'a array ->
        src_pos:int -> dst:'a array -> dst_pos:int -> len:int -> unit
      val iter : f:('a -> unit) -> 'a array -> unit
      val map : f:('a -> 'b) -> 'a array -> 'b array
      val iteri : f:(int -> 'a -> unit) -> 'a array -> unit
      val mapi : f:(int -> 'a -> 'b) -> 'a array -> 'b array
      val fold_left : f:('a -> 'b -> 'a) -> init:'a -> 'b array -> 'a
      val fold_right : f:('a -> 'b -> 'b) -> 'a array -> init:'b -> 'b
      val sort : cmp:('a -> 'a -> int) -> 'a array -> unit
      val stable_sort : cmp:('a -> 'a -> int) -> 'a array -> unit
      val fast_sort : cmp:('a -> 'a -> int) -> 'a array -> unit
      val iter2 :
        f:('a -> 'b -> unit) -> 'a BatArray.t -> 'b BatArray.t -> unit
      val exists : f:('a -> bool) -> 'a BatArray.t -> bool
      val for_all : f:('a -> bool) -> 'a BatArray.t -> bool
      val iter2i :
        f:(int -> 'a -> 'b -> unit) -> 'a BatArray.t -> 'b BatArray.t -> unit
      val find : f:('a -> bool) -> 'a BatArray.t -> 'a
      val findi : f:('a -> bool) -> 'a BatArray.t -> int
      val map : f:('a -> 'b) -> 'a BatArray.t -> 'b BatArray.t
      val mapi : f:(int -> 'a -> 'b) -> 'a BatArray.t -> 'b BatArray.t
      val filter : f:('a -> bool) -> 'a BatArray.t -> 'a BatArray.t
      val filter_map : f:('a -> 'b option) -> 'a BatArray.t -> 'b BatArray.t
      module LExceptionless :
        sig
          val find : f:('a -> bool) -> 'a BatArray.t -> 'a option
          val findi : f:('a -> bool) -> 'a BatArray.t -> int option
        end
    end
end