batteries 2.5.3 · OCaml Package

batteries

val input_lines : Pervasives.in_channel -> string BatEnum.t

val input_chars : Pervasives.in_channel -> char BatEnum.t

val input_list : Pervasives.in_channel -> string list

val input_all : 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 : 
  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 : 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 : 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

val identity : 'a -> 'a

val undefined : ?message:string -> 'a -> 'b

val (@@) : ('a -> 'b) -> 'a -> 'b

val (%) : ('a -> 'b) -> ('c -> 'a) -> 'c -> 'b

val (|>) : 'a -> ('a -> 'b) -> 'b

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 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 : ('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, !'b) result = ('a, 'b) BatInnerPervasives.result =

| Ok of 'a
| Bad of 'b

val ignore_ok : ('a, exn) result -> unit

val ok : ('a, exn) result -> 'a

val wrap : ('a -> 'b) -> 'a -> ('b, exn) result

val lock : BatConcurrent.lock Pervasives.ref

package batteries