BatPervasives

`sig
val uppercase : string -> string
val lowercase : string -> string
val string_of_char : char -> string
val dump : 'a -> string
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 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 :
Pervasives.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_rope : unit BatIO.output -> BatRope.t -> unit
val output : 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 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 : Pervasives.open_flag list -> int -> string -> BatIO.input
val input_char : BatIO.input -> char
val input_line : BatIO.input -> string
val input : BatIO.input -> string -> int -> int -> int
val really_input : BatIO.input -> string -> 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
val ( |> ) : 'a -> ('a -> 'b) -> 'b
val ( **> ) : ('a -> 'b) -> 'a -> 'b
val ( |- ) : ('a -> 'b) -> ('b -> 'c) -> 'a -> 'c
val ( -| ) : ('a -> 'b) -> ('c -> 'a) -> 'c -> 'b
val flip : ('a -> 'b -> 'c) -> 'b -> 'a -> 'c
val ( *** ) : ('a -> 'b) -> ('c -> 'd) -> 'a * 'c -> 'b * 'd
val ( &&& ) : ('a -> 'b) -> ('a -> 'c) -> 'a -> 'b * 'c
val first : ('a -> 'b) -> 'a * 'c -> 'b * 'c
val second : ('a -> 'b) -> 'c * 'a -> 'c * 'b
val curry : ('a * 'b -> 'c) -> 'a -> 'b -> 'c
val uncurry : ('a -> 'b -> 'c) -> 'a * 'b -> 'c
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 args : unit -> string BatEnum.t
val invisible_args : int Pervasives.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 : ('a -> 'b -> 'a) -> 'a -> 'b BatEnum.t -> 'a
val scanl : ('a -> 'b -> 'a) -> 'a -> 'b BatEnum.t -> 'a 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 printer_flags = {
pf_width : int option;
pf_frac_digits : int option;
pf_padding_char : char;
pf_justify : [ `left | `right ];
pf_positive_prefix : char option;
}
val default_printer_flags : BatPervasives.printer_flags
val printer_a :
((unit BatIO.output -> 'a -> unit) -> 'a -> 'b, 'b) BatPrint.directive
val printer_t : ((unit BatIO.output -> unit) -> 'a, 'a) BatPrint.directive
val printer_B : (bool -> 'a, 'a) BatPrint.directive
val printer_c : (char -> 'a, 'a) BatPrint.directive
val printer_C : (char -> 'a, 'a) BatPrint.directive
val printer_s :
?flags:BatPervasives.printer_flags ->
(string -> 'a, 'a) BatPrint.directive
val printer_S :
?flags:BatPervasives.printer_flags ->
(string -> 'a, 'a) BatPrint.directive
val printer_d :
?flags:BatPervasives.printer_flags -> (int -> 'a, 'a) BatPrint.directive
val printer_i :
?flags:BatPervasives.printer_flags -> (int -> 'a, 'a) BatPrint.directive
val printer_int :
?flags:BatPervasives.printer_flags -> (int -> 'a, 'a) BatPrint.directive
val printer_u :
?flags:BatPervasives.printer_flags -> (int -> 'a, 'a) BatPrint.directive
val printer_uint :
?flags:BatPervasives.printer_flags -> (int -> 'a, 'a) BatPrint.directive
val printer_x :
?flags:BatPervasives.printer_flags -> (int -> 'a, 'a) BatPrint.directive
val printer_X :
?flags:BatPervasives.printer_flags -> (int -> 'a, 'a) BatPrint.directive
val printer_hex :
?flags:BatPervasives.printer_flags -> (int -> 'a, 'a) BatPrint.directive
val printer_HEX :
?flags:BatPervasives.printer_flags -> (int -> 'a, 'a) BatPrint.directive
val printer_o :
?flags:BatPervasives.printer_flags -> (int -> 'a, 'a) BatPrint.directive
val printer_oct :
?flags:BatPervasives.printer_flags -> (int -> 'a, 'a) BatPrint.directive
val printer_ld :
?flags:BatPervasives.printer_flags ->
(int32 -> 'a, 'a) BatPrint.directive
val printer_li :
?flags:BatPervasives.printer_flags ->
(int32 -> 'a, 'a) BatPrint.directive
val printer_lu :
?flags:BatPervasives.printer_flags ->
(int32 -> 'a, 'a) BatPrint.directive
val printer_lx :
?flags:BatPervasives.printer_flags ->
(int32 -> 'a, 'a) BatPrint.directive
val printer_lX :
?flags:BatPervasives.printer_flags ->
(int32 -> 'a, 'a) BatPrint.directive
val printer_lo :
?flags:BatPervasives.printer_flags ->
(int32 -> 'a, 'a) BatPrint.directive
val printer_Ld :
?flags:BatPervasives.printer_flags ->
(int64 -> 'a, 'a) BatPrint.directive
val printer_Li :
?flags:BatPervasives.printer_flags ->
(int64 -> 'a, 'a) BatPrint.directive
val printer_Lu :
?flags:BatPervasives.printer_flags ->
(int64 -> 'a, 'a) BatPrint.directive
val printer_Lx :
?flags:BatPervasives.printer_flags ->
(int64 -> 'a, 'a) BatPrint.directive
val printer_LX :
?flags:BatPervasives.printer_flags ->
(int64 -> 'a, 'a) BatPrint.directive
val printer_Lo :
?flags:BatPervasives.printer_flags ->
(int64 -> 'a, 'a) BatPrint.directive
val printer_nd :
?flags:BatPervasives.printer_flags ->
(nativeint -> 'a, 'a) BatPrint.directive
val printer_ni :
?flags:BatPervasives.printer_flags ->
(nativeint -> 'a, 'a) BatPrint.directive
val printer_nu :
?flags:BatPervasives.printer_flags ->
(nativeint -> 'a, 'a) BatPrint.directive
val printer_nx :
?flags:BatPervasives.printer_flags ->
(nativeint -> 'a, 'a) BatPrint.directive
val printer_nX :
?flags:BatPervasives.printer_flags ->
(nativeint -> 'a, 'a) BatPrint.directive
val printer_no :
?flags:BatPervasives.printer_flags ->
(nativeint -> 'a, 'a) BatPrint.directive
val printer_f :
?flags:BatPervasives.printer_flags ->
(float -> 'a, 'a) BatPrint.directive
val printer_F :
?flags:BatPervasives.printer_flags ->
(float -> 'a, 'a) BatPrint.directive
val printer_format :
(('a, 'b) BatPrint.format -> 'a, 'b) BatPrint.directive
val printer_sc :
?flags:BatPervasives.printer_flags ->
([> `Read ] BatString.Cap.t -> 'a, 'a) BatPrint.directive
val printer_Sc :
?flags:BatPervasives.printer_flags ->
([> `Read ] BatString.Cap.t -> 'a, 'a) BatPrint.directive
val printer_rope : (BatRope.t -> 'a, 'a) BatPrint.directive
val printer_utf8 : (BatUTF8.t -> 'a, 'a) BatPrint.directive
val printer_obj :
(< print : unit BatIO.output -> unit; .. > -> 'a, 'a) BatPrint.directive
val printer_exn : (exn -> 'a, 'a) BatPrint.directive
val bool_printer : bool BatValue_printer.t
val int_printer : int BatValue_printer.t
val char_printer : char BatValue_printer.t
val int32_printer : int32 BatValue_printer.t
val int64_printer : int64 BatValue_printer.t
val nativeint_printer : nativeint BatValue_printer.t
val float_printer : float BatValue_printer.t
val string_printer : string BatValue_printer.t
val list_printer : 'a BatValue_printer.t -> 'a list BatValue_printer.t
val array_printer : 'a BatValue_printer.t -> 'a array BatValue_printer.t
val option_printer : 'a BatValue_printer.t -> 'a option BatValue_printer.t
val maybe_printer : 'a BatValue_printer.t -> 'a option BatValue_printer.t
val exn_printer : exn BatValue_printer.t
type ('a, 'b) result = ('a, 'b) BatStd.result = Ok of 'a | Bad of 'b
val lock : BatConcurrent.lock Pervasives.ref
end`