package batteries

  1. Overview
  2. Docs
package batteries
Legend:
Library
Module
Module type
Parameter
Class
Class type
module Legacy : sig ... end
module Buffer : sig ... end
module Bytes : sig ... end
type bytes = Bytes.t
module Char : sig ... end
module Complex : sig ... end
module Digest : sig ... end
module Format : sig ... end
module Gc : sig ... end
module Genlex : sig ... end
module Int32 : sig ... end
module Int64 : sig ... end
module Lexing : sig ... end
module Marshal : sig ... end
module Nativeint : sig ... end
module Oo : sig ... end
module Printexc : sig ... end
module Printf : sig ... end
module Random : sig ... end
module Scanf : sig ... end
module Set : sig ... end
module Stream : sig ... end
module Sys : sig ... end
module Unix : sig ... end
module Big_int : sig ... end
module Num : sig ... end
module Bigarray : sig ... end
module Base64 : sig ... end
module BitSet : sig ... end
module Bit_set : sig ... end
module Dllist : sig ... end
module DynArray : sig ... end
module File : sig ... end
module Global : sig ... end
module IO : sig ... end
module MultiPMap : sig ... end
module Option : sig ... end
module RefList : sig ... end
module Ref : sig ... end
module Cache : sig ... end
module CharParser : sig ... end
module Deque : sig ... end
module Hashcons : sig ... end
module Heap : sig ... end
module FingerTree : sig ... end
module Logger : sig ... end
module MultiMap : sig ... end
module ParserCo : sig ... end
module Result : sig ... end
module Return : sig ... end
module Substring : sig ... end
module Tuple : sig ... end
module Tuple2 : sig ... end
module Tuple3 : sig ... end
module Tuple4 : sig ... end
module Tuple5 : sig ... end
module Vect : sig ... end
module ISet : sig ... end
module IMap : sig ... end
module Uref : sig ... end
module UChar : sig ... end
module UTF8 : sig ... end
module Text : sig ... end
module Concurrent : sig ... end
module Interfaces : sig ... end
module Number : sig ... end
module Float : sig ... end
module Int : sig ... end
module Bool : sig ... end
module Unit : sig ... end
module Incubator : sig ... end
val raise : exn -> 'a
val raise_notrace : exn -> 'a
val invalid_arg : string -> 'a
val failwith : string -> 'a
exception Exit
val (=) : 'a -> 'a -> bool
val (<>) : 'a -> 'a -> bool
val (<) : 'a -> 'a -> bool
val (>) : 'a -> 'a -> bool
val (<=) : 'a -> 'a -> bool
val (>=) : 'a -> 'a -> bool
val compare : 'a -> 'a -> int
val min : 'a -> 'a -> 'a
val max : 'a -> 'a -> 'a
val (==) : 'a -> 'a -> bool
val (!=) : 'a -> 'a -> bool
val not : bool -> bool
val (&&) : bool -> bool -> bool
val (&) : bool -> bool -> bool
  • deprecated Use (&&) instead.
val (||) : bool -> bool -> bool
val or : bool -> bool -> bool
  • deprecated Use (||) instead.
val __LOC__ : string
val __FILE__ : string
val __LINE__ : int
val __MODULE__ : string
val __POS__ : string * int * int * int
val __LOC_OF__ : 'a -> string * 'a
val __LINE_OF__ : 'a -> int * 'a
val __POS_OF__ : 'a -> (string * int * int * int) * 'a
val (~-) : int -> int
val (~+) : int -> int
val succ : int -> int
val pred : int -> int
val (+) : int -> int -> int
val (-) : int -> int -> int
val (*) : int -> int -> int
val (/) : int -> int -> int
val (mod) : int -> int -> int
val abs : int -> int
val max_int : int
val min_int : int
val (land) : int -> int -> int
val (lor) : int -> int -> int
val (lxor) : int -> int -> int
val lnot : int -> int
val (lsl) : int -> int -> int
val (lsr) : int -> int -> int
val (asr) : int -> int -> int
val (~-.) : float -> float
val (~+.) : float -> float
val (+.) : float -> float -> float
val (-.) : float -> float -> float
val (*.) : float -> float -> float
val (/.) : float -> float -> float
val (**) : float -> float -> float
val sqrt : float -> float
val exp : float -> float
val log : float -> float
val log10 : float -> float
val expm1 : float -> float
val log1p : float -> float
val cos : float -> float
val sin : float -> float
val tan : float -> float
val acos : float -> float
val asin : float -> float
val atan : float -> float
val atan2 : float -> float -> float
val hypot : float -> float -> float
val cosh : float -> float
val sinh : float -> float
val tanh : float -> float
val ceil : float -> float
val floor : float -> float
val abs_float : float -> float
val copysign : float -> float -> float
val mod_float : float -> float -> float
val frexp : float -> float * int
val ldexp : float -> int -> float
val modf : float -> float * float
val float : int -> float
val float_of_int : int -> float
val truncate : float -> int
val int_of_float : float -> int
val infinity : float
val neg_infinity : float
val nan : float
val max_float : float
val min_float : float
val epsilon_float : float
type fpclass = Pervasives.fpclass =
  1. | FP_normal
  2. | FP_subnormal
  3. | FP_zero
  4. | FP_infinite
  5. | FP_nan
val classify_float : float -> fpclass
val (^) : string -> string -> string
val int_of_char : char -> int
val char_of_int : int -> char
val ignore : 'a -> unit
val string_of_bool : bool -> string
val bool_of_string : string -> bool
val string_of_int : int -> string
val int_of_string : string -> int
val string_of_float : float -> string
val float_of_string : string -> float
val fst : ('a * 'b) -> 'a
val snd : ('a * 'b) -> 'b
type in_channel = Pervasives.in_channel
type out_channel = Pervasives.out_channel
val print_char : char -> unit
val print_string : string -> unit
val print_bytes : bytes -> unit
val print_int : int -> unit
val print_float : float -> unit
val print_endline : string -> unit
val print_newline : unit -> unit
val prerr_char : char -> unit
val prerr_string : string -> unit
val prerr_bytes : bytes -> unit
val prerr_int : int -> unit
val prerr_float : float -> unit
val prerr_endline : string -> unit
val prerr_newline : unit -> unit
val read_line : unit -> string
val read_int : unit -> int
val read_float : unit -> float
type open_flag = Pervasives.open_flag =
  1. | Open_rdonly
  2. | Open_wronly
  3. | Open_append
  4. | Open_creat
  5. | Open_trunc
  6. | Open_excl
  7. | Open_binary
  8. | Open_text
  9. | Open_nonblock
val output_bytes : out_channel -> bytes -> unit
val output_substring : out_channel -> string -> int -> int -> unit
val seek_out : out_channel -> int -> unit
val pos_out : out_channel -> int
val out_channel_length : out_channel -> int
val set_binary_mode_out : out_channel -> bool -> unit
val really_input_string : in_channel -> int -> string
val seek_in : in_channel -> int -> unit
val pos_in : in_channel -> int
val in_channel_length : in_channel -> int
val set_binary_mode_in : in_channel -> bool -> unit
module LargeFile : sig ... end
type !'a ref = 'a Pervasives.ref = {
  1. mutable contents : 'a;
}
val ref : 'a -> 'a ref
val (!) : 'a ref -> 'a
val (:=) : 'a ref -> 'a -> unit
val incr : int ref -> unit
val decr : int ref -> unit
type (!'a, !'b, !'c, !'d, !'e, !'f) format6 = ('a, 'b, 'c, 'd, 'e, 'f) Pervasives.format6
type (!'a, !'b, !'c, !'d) format4 = ('a, 'b, 'c, 'd) Pervasives.format4
type (!'a, !'b, !'c) format = ('a, 'b, 'c) Pervasives.format
val string_of_format : ('a, 'b, 'c, 'd, 'e, 'f) format6 -> string
val format_of_string : ('a, 'b, 'c, 'd, 'e, 'f) format6 -> ('a, 'b, 'c, 'd, 'e, 'f) format6
val (^^) : ('a, 'b, 'c, 'd, 'e, 'f) format6 -> ('f, 'b, 'c, 'e, 'g, 'h) format6 -> ('a, 'b, 'c, 'd, 'g, 'h) format6
val exit : int -> 'a
val at_exit : (unit -> unit) -> unit
val valid_float_lexem : string -> string
val unsafe_really_input : in_channel -> bytes -> int -> int -> unit
val do_at_exit : unit -> unit
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 =
  1. | Ok of 'a
  2. | Bad of 'b
val ignore_ok : ('a, exn) result -> unit
val ok : ('a, exn) result -> 'a
val wrap : ('a -> 'b) -> 'a -> ('b, exn) result
module Array : sig ... end
module Hashtbl : sig ... end
module List : sig ... end
module Map : sig ... end
module Queue : sig ... end
module Stack : sig ... end
module String : sig ... end
module Enum : sig ... end
module LazyList : sig ... end
module Seq : sig ... end
module Splay : sig ... end
OCaml

Innovation. Community. Security.

GitHub Discord Twitter Peertube RSS
About
Changelog Releases Industrial Users Academic Users Why OCaml
Ecosystem
Packages Community Events OCaml Planet Jobs
Resources
Install OCaml Get Started Platform Tools Language Manual Standard Library API Books Exercises Papers OCaml Playground Logo
Policies
Carbon Footprint Governance Privacy Code of Conduct