sig
  val input_lines : Stdlib.Pervasives.in_channel -> string BatEnum.t
  val input_chars : Stdlib.Pervasives.in_channel -> char BatEnum.t
  val input_list : Stdlib.Pervasives.in_channel -> string list
  val input_all : Stdlib.Pervasives.in_channel -> string
  val dump : 'a -> string
  val print_any : 'b BatIO.output -> 'a -> unit
  val ( @ ) : 'a list -> 'a list -> 'a list
  val stdin : BatIO.input
  val stdout : unit BatIO.output
  val stderr : unit BatIO.output
  val stdnull : unit BatIO.output
  val flush_all : unit -> unit
  val print_bool : bool -> unit
  val print_guess : 'a BatIO.output -> 'b -> unit
  val print_all : BatIO.input -> unit
  val prerr_bool : bool -> unit
  val prerr_guess : 'a -> unit
  val prerr_all : BatIO.input -> unit
  val output_file : filename:string -> text:string -> unit
  val open_out :
    ?mode:BatFile.open_out_flag list ->
    ?perm:BatFile.permission -> string -> unit BatIO.output
  val open_out_bin : string -> unit BatIO.output
  val open_out_gen :
    Stdlib.open_flag list -> int -> string -> unit BatIO.output
  val flush : unit BatIO.output -> unit
  val output_char : unit BatIO.output -> char -> unit
  val output_string : unit BatIO.output -> string -> unit
  val output : unit BatIO.output -> Stdlib.Bytes.t -> int -> int -> unit
  val output_substring : unit BatIO.output -> string -> int -> int -> unit
  val output_byte : unit BatIO.output -> int -> unit
  val output_binary_int : unit BatIO.output -> int -> unit
  val output_binary_float : unit BatIO.output -> float -> unit
  val output_value : unit BatIO.output -> 'a -> unit
  val close_out : unit BatIO.output -> unit
  val close_out_noerr : unit BatIO.output -> unit
  val input_file : ?bin:bool -> string -> string
  val open_in :
    ?mode:BatFile.open_in_flag list ->
    ?perm:BatFile.permission -> string -> BatIO.input
  val open_in_bin : string -> BatIO.input
  val open_in_gen : Stdlib.open_flag list -> int -> string -> BatIO.input
  val input_char : BatIO.input -> char
  val input_line : BatIO.input -> string
  val input : BatIO.input -> Stdlib.Bytes.t -> int -> int -> int
  val really_input : BatIO.input -> Stdlib.Bytes.t -> int -> int -> unit
  val input_byte : BatIO.input -> int
  val input_binary_int : BatIO.input -> int
  val input_binary_float : BatIO.input -> float
  val input_value : BatIO.input -> 'a
  val close_in : BatIO.input -> unit
  val close_in_noerr : BatIO.input -> unit
  external identity : 'a -> 'a = "%identity"
  val undefined : ?message:string -> 'a -> 'b
  external ( @@ ) : ('a -> 'b) -> 'a -> 'b = "%apply"
  val ( % ) : ('a -> 'b) -> ('c -> 'a) -> 'c -> 'b
  external ( |> ) : 'a -> ('a -> 'b) -> 'b = "%revapply"
  val ( %> ) : ('a -> 'b) -> ('b -> 'c) -> 'a -> 'c
  val ( |? ) : 'a option -> 'a -> 'a
  val flip : ('a -> 'b -> 'c) -> 'b -> 'a -> 'c
  val curry : ('a * 'b -> 'c) -> 'a -> 'b -> 'c
  val uncurry : ('a -> 'b -> 'c) -> 'a * 'b -> 'c
  val neg : ('a -> bool) -> 'a -> bool
  val neg2 : ('a -> 'b -> bool) -> 'a -> 'b -> bool
  val const : 'a -> 'b -> 'a
  val unique : unit -> int
  val tap : ('a -> unit) -> 'a -> 'a
  val finally : (unit -> unit) -> ('a -> 'b) -> 'a -> 'b
  val with_dispose : dispose:('a -> unit) -> ('a -> 'b) -> 'a -> 'b
  val forever : ('a -> 'b) -> 'a -> unit
  val ignore_exceptions : ('a -> 'b) -> 'a -> unit
  val verify_arg : bool -> string -> unit
  val args : unit -> string BatEnum.t
  val invisible_args : int Stdlib.ref
  val exe : string
  val foreach : 'a BatEnum.t -> ('a -> unit) -> unit
  val iter : ('a -> unit) -> 'a BatEnum.t -> unit
  val map : ('a -> 'b) -> 'a BatEnum.t -> 'b BatEnum.t
  val filter_map : ('a -> 'b option) -> 'a BatEnum.t -> 'b BatEnum.t
  val reduce : ('a -> 'a -> 'a) -> 'a BatEnum.t -> 'a
  val fold : ('b -> 'a -> 'b) -> 'b -> 'a BatEnum.t -> 'b
  val scanl : ('b -> 'a -> 'b) -> 'b -> 'a BatEnum.t -> 'b BatEnum.t
  val ( /@ ) : 'a BatEnum.t -> ('a -> 'b) -> 'b BatEnum.t
  val ( @/ ) : ('a -> 'b) -> 'a BatEnum.t -> 'b BatEnum.t
  val ( //@ ) : 'a BatEnum.t -> ('a -> 'b option) -> 'b BatEnum.t
  val ( @// ) : ('a -> 'b option) -> 'a BatEnum.t -> 'b BatEnum.t
  val exists : ('a -> bool) -> 'a BatEnum.t -> bool
  val for_all : ('a -> bool) -> 'a BatEnum.t -> bool
  val find : ('a -> bool) -> 'a BatEnum.t -> 'a
  val peek : 'a BatEnum.t -> 'a option
  val get : 'a BatEnum.t -> 'a option
  val push : 'a BatEnum.t -> 'a -> unit
  val junk : 'a BatEnum.t -> unit
  val filter : ('a -> bool) -> 'a BatEnum.t -> 'a BatEnum.t
  val ( // ) : 'a BatEnum.t -> ('a -> bool) -> 'a BatEnum.t
  val concat : 'a BatEnum.t BatEnum.t -> 'a BatEnum.t
  val ( -- ) : int -> int -> int BatEnum.t
  val ( --^ ) : int -> int -> int BatEnum.t
  val ( --. ) : float * float -> float -> float BatEnum.t
  val ( --- ) : int -> int -> int BatEnum.t
  val ( --~ ) : char -> char -> char BatEnum.t
  val print :
    ?first:string ->
    ?last:string ->
    ?sep:string ->
    ('a BatInnerIO.output -> 'b -> unit) ->
    'a BatInnerIO.output -> 'b BatEnum.t -> unit
  type ('a, 'e) result =
    ('a, 'e) BatInnerPervasives.result =
      Ok of 'a
    | Error of 'e
  val ignore_ok : ('a, exn) BatPervasives.result -> unit
  val ok : ('a, exn) BatPervasives.result -> 'a
  val wrap : ('a -> 'b) -> 'a -> ('b, exn) BatPervasives.result
  val lock : BatConcurrent.lock Stdlib.ref
end