To focus the search input from anywhere on the page, press the 'S' key.
in-package search v0.1.0
Library
Module
Module type
Parameter
Class
Class type
include module type of Batteries
with module Array := Batteries.Array
and module Hashtbl := Batteries.Hashtbl
and module List := Batteries.List
and module Map := Batteries.Map
and module Queue := Batteries.Queue
and module Stack := Batteries.Stack
and module String := Batteries.String
and module Enum := Batteries.Enum
and module LazyList := Batteries.LazyList
and module Seq := Batteries.Seq
and module Splay := Batteries.Splay
module Legacy : sig ... end
module Buffer = BatBuffer
module Bytes = BatBytes
type bytes = Bytes.t
module Char = BatChar
module Complex = BatComplex
module Digest = BatDigest
module Either = BatEither
module Format = BatFormat
module Gc = BatGc
module Genlex = BatGenlex
module Int32 = BatInt32
module Int64 = BatInt64
module Lexing = BatLexing
module Marshal = BatMarshal
module Nativeint = BatNativeint
module Printexc = BatPrintexc
module Printf = BatPrintf
module Random = BatRandom
module Scanf = BatScanf
module Set = BatSet
module Stream = BatStream
module Sys = BatSys
module Unix = BatUnix
module Big_int = BatBig_int
module Num = BatNum
module Bigarray = BatBigarray
module Base64 = BatBase64
module BitSet = BatBitSet
module Bit_set = BatBitSet
module Dllist = BatDllist
module DynArray = BatDynArray
module File = BatFile
module Global = BatGlobal
module IO = BatIO
module MultiPMap = BatMultiPMap
module Option = BatOption
module RefList = BatRefList
module Ref = BatRef
module Cache = BatCache
module CharParser = BatCharParser
module Deque = BatDeque
module Hashcons = BatHashcons
module Heap = BatHeap
module FingerTree = BatFingerTree
module Logger = BatLogger
module MultiMap = BatMultiMap
module ParserCo = BatParserCo
module Result = BatResult
module Return = BatReturn
module Substring = BatSubstring
module Tuple = BatTuple
module Tuple2 = BatTuple.Tuple2
module Tuple3 = BatTuple.Tuple3
module Tuple4 = BatTuple.Tuple4
module Tuple5 = BatTuple.Tuple5
module Vect = BatVect
module ISet = BatISet
module IMap = BatIMap
module Uref = BatUref
module UChar = BatUChar
module UTF8 = BatUTF8
module Text = BatText
module Concurrent = BatConcurrent
module Interfaces = BatInterfaces
module Number = BatNumber
module Float = BatFloat
module Int = BatInt
module Bool = BatBool
module Unit = BatUnit
module Filename = BatFilename
module Incubator : sig ... end
include module type of struct include Pervasives end
Exceptions
The Exit
exception is not raised by any library function. It is provided for use in your programs.
Comparisons
e1 = e2
tests for structural equality of e1
and e2
. Mutable structures (e.g. references and arrays) are equal if and only if their current contents are structurally equal, even if the two mutable objects are not the same physical object. Equality between functional values raises Invalid_argument
. Equality between cyclic data structures may not terminate.
Negation of Pervasives.(=)
.
See Pervasives.(>=)
.
See Pervasives.(>=)
.
See Pervasives.(>=)
.
Structural ordering functions. These functions coincide with the usual orderings over integers, characters, strings, byte sequences and floating-point numbers, and extend them to a total ordering over all types. The ordering is compatible with ( = )
. As in the case of ( = )
, mutable structures are compared by contents. Comparison between functional values raises Invalid_argument
. Comparison between cyclic structures may not terminate.
compare x y
returns 0
if x
is equal to y
, a negative integer if x
is less than y
, and a positive integer if x
is greater than y
. The ordering implemented by compare
is compatible with the comparison predicates =
, <
and >
defined above, with one difference on the treatment of the float value Pervasives.nan
. Namely, the comparison predicates treat nan
as different from any other float value, including itself; while compare
treats nan
as equal to itself and less than any other float value. This treatment of nan
ensures that compare
defines a total ordering relation.
compare
applied to functional values may raise Invalid_argument
. compare
applied to cyclic structures may not terminate.
The compare
function can be used as the comparison function required by the Set.Make
and Map.Make
functors, as well as the List.sort
and Array.sort
functions.
Return the smaller of the two arguments. The result is unspecified if one of the arguments contains the float value nan
.
Return the greater of the two arguments. The result is unspecified if one of the arguments contains the float value nan
.
e1 == e2
tests for physical equality of e1
and e2
. On mutable types such as references, arrays, byte sequences, records with mutable fields and objects with mutable instance variables, e1 == e2
is true if and only if physical modification of e1
also affects e2
. On non-mutable types, the behavior of ( == )
is implementation-dependent; however, it is guaranteed that e1 == e2
implies compare e1 e2 = 0
.
Negation of Pervasives.(==)
.
Boolean operations
The boolean 'and'. Evaluation is sequential, left-to-right: in e1 && e2
, e1
is evaluated first, and if it returns false
, e2
is not evaluated at all.
The boolean 'or'. Evaluation is sequential, left-to-right: in e1 || e2
, e1
is evaluated first, and if it returns true
, e2
is not evaluated at all.
Debugging
__LOC__
returns the location at which this expression appears in the file currently being parsed by the compiler, with the standard error format of OCaml: "File %S, line %d, characters %d-%d".
__LOC__
returns the location at which this expression appears in the file currently being parsed by the compiler, with the standard error format of OCaml: "File %S, line %d, characters %d-%d".
__FILE__
returns the name of the file currently being parsed by the compiler.
__FILE__
returns the name of the file currently being parsed by the compiler.
__LINE__
returns the line number at which this expression appears in the file currently being parsed by the compiler.
__LINE__
returns the line number at which this expression appears in the file currently being parsed by the compiler.
__MODULE__
returns the module name of the file being parsed by the compiler.
__MODULE__
returns the module name of the file being parsed by the compiler.
__POS__
returns a tuple (file,lnum,cnum,enum)
, corresponding to the location at which this expression appears in the file currently being parsed by the compiler. file
is the current filename, lnum
the line number, cnum
the character position in the line and enum
the last character position in the line.
__LOC_OF__ expr
returns a pair (loc, expr)
where loc
is the location of expr
in the file currently being parsed by the compiler, with the standard error format of OCaml: "File %S, line %d, characters %d-%d".
__LOC_OF__ expr
returns a pair (loc, expr)
where loc
is the location of expr
in the file currently being parsed by the compiler, with the standard error format of OCaml: "File %S, line %d, characters %d-%d".
__LINE__ expr
returns a pair (line, expr)
, where line
is the line number at which the expression expr
appears in the file currently being parsed by the compiler.
__LINE__ expr
returns a pair (line, expr)
, where line
is the line number at which the expression expr
appears in the file currently being parsed by the compiler.
__POS_OF__ expr
returns a pair (loc,expr)
, where loc
is a tuple (file,lnum,cnum,enum)
corresponding to the location at which the expression expr
appears in the file currently being parsed by the compiler. file
is the current filename, lnum
the line number, cnum
the character position in the line and enum
the last character position in the line.
Composition operators
Integer arithmetic
Integers are 31 bits wide (or 63 bits on 64-bit processors). All operations are taken modulo 231 (or 263). They do not fail on overflow.
Integer division. Raise Division_by_zero
if the second argument is 0. Integer division rounds the real quotient of its arguments towards zero. More precisely, if x >= 0
and y > 0
, x / y
is the greatest integer less than or equal to the real quotient of x
by y
. Moreover, (- x) / y = x / (- y) = - (x / y)
.
Integer remainder. If y
is not zero, the result of x mod y
satisfies the following properties: x = (x / y) * y + x mod y
and abs(x mod y) <= abs(y) - 1
. If y = 0
, x mod y
raises Division_by_zero
. Note that x mod y
is negative only if x < 0
. Raise Division_by_zero
if y
is zero.
Return the absolute value of the argument. Note that this may be negative if the argument is min_int
.
Bitwise operations
n lsl m
shifts n
to the left by m
bits. The result is unspecified if m < 0
or m >= bitsize
, where bitsize
is 32
on a 32-bit platform and 64
on a 64-bit platform.
n lsr m
shifts n
to the right by m
bits. This is a logical shift: zeroes are inserted regardless of the sign of n
. The result is unspecified if m < 0
or m >= bitsize
.
n asr m
shifts n
to the right by m
bits. This is an arithmetic shift: the sign bit of n
is replicated. The result is unspecified if m < 0
or m >= bitsize
.
Floating-point arithmetic
OCaml's floating-point numbers follow the IEEE 754 standard, using double precision (64 bits) numbers. Floating-point operations never raise an exception on overflow, underflow, division by zero, etc. Instead, special IEEE numbers are returned as appropriate, such as infinity
for 1.0 /. 0.0
, neg_infinity
for -1.0 /. 0.0
, and nan
('not a number') for 0.0 /. 0.0
. These special numbers then propagate through floating-point computations as expected: for instance, 1.0 /. infinity
is 0.0
, and any arithmetic operation with nan
as argument returns nan
as result.
expm1 x
computes exp x -. 1.0
, giving numerically-accurate results even if x
is close to 0.0
.
log1p x
computes log(1.0 +. x)
(natural logarithm), giving numerically-accurate results even if x
is close to 0.0
.
Arc cosine. The argument must fall within the range [-1.0, 1.0]
. Result is in radians and is between 0.0
and pi
.
Arc sine. The argument must fall within the range [-1.0, 1.0]
. Result is in radians and is between -pi/2
and pi/2
.
atan2 y x
returns the arc tangent of y /. x
. The signs of x
and y
are used to determine the quadrant of the result. Result is in radians and is between -pi
and pi
.
hypot x y
returns sqrt(x *. x + y *. y)
, that is, the length of the hypotenuse of a right-angled triangle with sides of length x
and y
, or, equivalently, the distance of the point (x,y)
to origin.
Round above to an integer value. ceil f
returns the least integer value greater than or equal to f
. The result is returned as a float.
Round below to an integer value. floor f
returns the greatest integer value less than or equal to f
. The result is returned as a float.
copysign x y
returns a float whose absolute value is that of x
and whose sign is that of y
. If x
is nan
, returns nan
. If y
is nan
, returns either x
or -. x
, but it is not specified which.
mod_float a b
returns the remainder of a
with respect to b
. The returned value is a -. n *. b
, where n
is the quotient a /. b
rounded towards zero to an integer.
frexp f
returns the pair of the significant and the exponent of f
. When f
is zero, the significant x
and the exponent n
of f
are equal to zero. When f
is non-zero, they are defined by f = x *. 2 ** n
and 0.5 <= x < 1.0
.
Same as Pervasives.float_of_int
.
Same as Pervasives.int_of_float
.
Truncate the given floating-point number to an integer. The result is unspecified if the argument is nan
or falls outside the range of representable integers.
A special floating-point value denoting the result of an undefined operation such as 0.0 /. 0.0
. Stands for 'not a number'. Any floating-point operation with nan
as argument returns nan
as result. As for floating-point comparisons, =
, <
, <=
, >
and >=
return false
and <>
returns true
if one or both of their arguments is nan
.
The difference between 1.0
and the smallest exactly representable floating-point number greater than 1.0
.
type fpclass = Pervasives.fpclass =
The five classes of floating-point numbers, as determined by the Pervasives.classify_float
function.
val classify_float : float -> fpclass
Return the class of the given floating-point number: normal, subnormal, zero, infinite, or not a number.
String operations
More string operations are provided in module String
.
Character operations
More character operations are provided in module Char
.
Return the character with the given ASCII code. Raise Invalid_argument "char_of_int"
if the argument is outside the range 0--255.
Unit operations
Discard the value of its argument and return ()
. For instance, ignore(f x)
discards the result of the side-effecting function f
. It is equivalent to f x; ()
, except that the latter may generate a compiler warning; writing ignore(f x)
instead avoids the warning.
String conversion functions
Return the string representation of a boolean. As the returned values may be shared, the user should not modify them directly.
Convert the given string to a boolean. Raise Invalid_argument "bool_of_string"
if the string is not "true"
or "false"
.
Convert the given string to an integer. The string is read in decimal (by default) or in hexadecimal (if it begins with 0x
or 0X
), octal (if it begins with 0o
or 0O
), or binary (if it begins with 0b
or 0B
). Raise Failure "int_of_string"
if the given string is not a valid representation of an integer, or if the integer represented exceeds the range of integers representable in type int
.
Convert the given string to a float. Raise Failure "float_of_string"
if the given string is not a valid representation of a float.
Pair operations
List operations
More list operations are provided in module List
.
Input/output
Note: all input/output functions can raise Sys_error
when the system calls they invoke fail.
type in_channel = Pervasives.in_channel
The type of input channel.
type out_channel = Pervasives.out_channel
The type of output channel.
Output functions on standard output
Print a string, followed by a newline character, on standard output and flush standard output.
Print a newline character on standard output, and flush standard output. This can be used to simulate line buffering of standard output.
Output functions on standard error
Print a string, followed by a newline character on standard error and flush standard error.
Print a newline character on standard error, and flush standard error.
Input functions on standard input
Flush standard output, then read characters from standard input until a newline character is encountered. Return the string of all characters read, without the newline character at the end.
Flush standard output, then read one line from standard input and convert it to an integer. Raise Failure "int_of_string"
if the line read is not a valid representation of an integer.
Flush standard output, then read one line from standard input and convert it to a floating-point number. The result is unspecified if the line read is not a valid representation of a floating-point number.
General output functions
type open_flag = Pervasives.open_flag =
| Open_rdonly
(*open for reading.
*)| Open_wronly
(*open for writing.
*)| Open_append
(*open for appending: always write at end of file.
*)| Open_creat
(*create the file if it does not exist.
*)| Open_trunc
(*empty the file if it already exists.
*)| Open_excl
(*fail if Open_creat and the file already exists.
*)| Open_binary
(*open in binary mode (no conversion).
*)| Open_text
(*open in text mode (may perform conversions).
*)| Open_nonblock
(*open in non-blocking mode.
*)
Opening modes for Pervasives.open_out_gen
and Pervasives.open_in_gen
.
val output_bytes : out_channel -> bytes -> unit
Write the byte sequence on the given output channel.
val seek_out : out_channel -> int -> unit
seek_out chan pos
sets the current writing position to pos
for channel chan
. This works only for regular files. On files of other kinds (such as terminals, pipes and sockets), the behavior is unspecified.
val pos_out : out_channel -> int
Return the current writing position for the given channel. Does not work on channels opened with the Open_append
flag (returns unspecified results).
val out_channel_length : out_channel -> int
Return the size (number of characters) of the regular file on which the given channel is opened. If the channel is opened on a file that is not a regular file, the result is meaningless.
val set_binary_mode_out : out_channel -> bool -> unit
set_binary_mode_out oc true
sets the channel oc
to binary mode: no translations take place during output. set_binary_mode_out oc false
sets the channel oc
to text mode: depending on the operating system, some translations may take place during output. For instance, under Windows, end-of-lines will be translated from \n
to \r\n
. This function has no effect under operating systems that do not distinguish between text mode and binary mode.
General input functions
val really_input_string : in_channel -> int -> string
really_input_string ic len
reads len
characters from channel ic
and returns them in a new string. Raise End_of_file
if the end of file is reached before len
characters have been read.
val seek_in : in_channel -> int -> unit
seek_in chan pos
sets the current reading position to pos
for channel chan
. This works only for regular files. On files of other kinds, the behavior is unspecified.
val pos_in : in_channel -> int
Return the current reading position for the given channel.
val in_channel_length : in_channel -> int
Return the size (number of characters) of the regular file on which the given channel is opened. If the channel is opened on a file that is not a regular file, the result is meaningless. The returned size does not take into account the end-of-line translations that can be performed when reading from a channel opened in text mode.
val set_binary_mode_in : in_channel -> bool -> unit
set_binary_mode_in ic true
sets the channel ic
to binary mode: no translations take place during input. set_binary_mode_out ic false
sets the channel ic
to text mode: depending on the operating system, some translations may take place during input. For instance, under Windows, end-of-lines will be translated from \r\n
to \n
. This function has no effect under operating systems that do not distinguish between text mode and binary mode.
Operations on large files
module LargeFile = Pervasives.LargeFile
Operations on large files. This sub-module provides 64-bit variants of the channel functions that manipulate file positions and file sizes. By representing positions and sizes by 64-bit integers (type int64
) instead of regular integers (type int
), these alternate functions allow operating on files whose sizes are greater than max_int
.
References
The type of references (mutable indirection cells) containing a value of type 'a
.
val ref : 'a -> 'a ref
Return a fresh reference containing the given value.
val (!) : 'a ref -> 'a
!r
returns the current contents of reference r
. Equivalent to fun r -> r.contents
.
val (:=) : 'a ref -> 'a -> unit
r := a
stores the value of a
in reference r
. Equivalent to fun r v -> r.contents <- v
.
val incr : int ref -> unit
Increment the integer contained in the given reference. Equivalent to fun r -> r := succ !r
.
val decr : int ref -> unit
Decrement the integer contained in the given reference. Equivalent to fun r -> r := pred !r
.
Operations on format strings
Format strings are character strings with special lexical conventions that defines the functionality of formatted input/output functions. Format strings are used to read data with formatted input functions from module Scanf
and to print data with formatted output functions from modules Printf
and Format
.
Format strings are made of three kinds of entities:
- conversions specifications, introduced by the special character
'%'
followed by one or more characters specifying what kind of argument to read or print, - formatting indications, introduced by the special character
'@'
followed by one or more characters specifying how to read or print the argument, - plain characters that are regular characters with usual lexical conventions. Plain characters specify string literals to be read in the input or printed in the output.
There is an additional lexical rule to escape the special characters '%'
and '@'
in format strings: if a special character follows a '%'
character, it is treated as a plain character. In other words, "%%"
is considered as a plain '%'
and "%@"
as a plain '@'
.
For more information about conversion specifications and formatting indications available, read the documentation of modules Scanf
, Printf
and Format
.
Format strings have a general and highly polymorphic type ('a, 'b, 'c, 'd, 'e, 'f) format6
. The two simplified types, format
and format4
below are included for backward compatibility with earlier releases of OCaml.
The meaning of format string type parameters is as follows:
'a
is the type of the parameters of the format for formatted output functions (printf
-style functions);'a
is the type of the values read by the format for formatted input functions (scanf
-style functions).
'b
is the type of input source for formatted input functions and the type of output target for formatted output functions. Forprintf
-style functions from modulePrintf
,'b
is typicallyout_channel
; forprintf
-style functions from moduleFormat
,'b
is typicallyFormat.formatter
; forscanf
-style functions from moduleScanf
,'b
is typicallyScanf.Scanning.in_channel
.
Type argument 'b
is also the type of the first argument given to user's defined printing functions for %a
and %t
conversions, and user's defined reading functions for %r
conversion.
'c
is the type of the result of the%a
and%t
printing functions, and also the type of the argument transmitted to the first argument ofkprintf
-style functions or to thekscanf
-style functions.
'd
is the type of parameters for thescanf
-style functions.
'e
is the type of the receiver function for thescanf
-style functions.
'f
is the final result type of a formatted input/output function invocation: for theprintf
-style functions, it is typicallyunit
; for thescanf
-style functions, it is typically the result type of the receiver function.
type ('a, 'b, 'c, 'd, 'e, 'f) format6 =
('a, 'b, 'c, 'd, 'e, 'f) CamlinternalFormatBasics.format6
type ('a, 'b, 'c, 'd) format4 = ('a, 'b, 'c, 'c, 'c, 'd) format6
type ('a, 'b, 'c) format = ('a, 'b, 'c, 'c) format4
val string_of_format : ('a, 'b, 'c, 'd, 'e, 'f) format6 -> string
Converts a format string into a string.
format_of_string s
returns a format string read from the string literal s
. Note: format_of_string
can not convert a string argument that is not a literal. If you need this functionality, use the more general Scanf.format_from_string
function.
val (^^) :
('a, 'b, 'c, 'd, 'e, 'f) format6 ->
('f, 'b, 'c, 'e, 'g, 'h) format6 ->
('a, 'b, 'c, 'd, 'g, 'h) format6
f1 ^^ f2
catenates format strings f1
and f2
. The result is a format string that behaves as the concatenation of format strings f1
and f2
: in case of formatted output, it accepts arguments from f1
, then arguments from f2
; in case of formatted input, it returns results from f1
, then results from f2
.
Program termination
Terminate the process, returning the given status code to the operating system: usually 0 to indicate no errors, and a small positive integer to indicate failure. All open output channels are flushed with flush_all
. An implicit exit 0
is performed each time a program terminates normally. An implicit exit 2
is performed if the program terminates early because of an uncaught exception.
Register the given function to be called at program termination time. The functions registered with at_exit
will be called when the program executes Pervasives.exit
, or terminates, either normally or because of an uncaught exception. The functions are called in 'last in, first out' order: the function most recently added with at_exit
is called first.
include module type of struct include BatPervasives end
Additional functions.
The initially opened module.
This module provides the basic operations over the built-in types (numbers, booleans, strings, exceptions, references, lists, arrays, input-output channels, ...)
This module is automatically opened at the beginning of each compilation. All components of this module can therefore be referred by their short name, without prefixing them by BatPervasives
.
val input_lines : Pervasives.in_channel -> string BatEnum.t
Returns an enumeration over lines of an input channel, as read by the input_line
function.
val input_chars : Pervasives.in_channel -> char BatEnum.t
Returns an enumeration over characters of an input channel.
val input_list : Pervasives.in_channel -> string list
Returns the list of lines read from an input channel.
val input_all : Pervasives.in_channel -> string
Return the whole contents of an input channel as a single string.
Attempt to convert a value to a string.
Works well for a lot of cases such as non-empty lists, algebraic datatype, and records.
However, since types are lost at compile-time, the representation might not match your type. (0, 1) will be printed as expected, but (1, 0) and 1
have the same representation and will get printed in the same way. The result of dump
is unspecified and may change in future versions, so you should only use it for debugging and never have program behavior depend on the output.
Here is a list of some of the surprising corner cases of the current implementation:
- (3, 0) is printed
3
, (0.5, 0) is printed0.5
, etc. - None, false and are printed 0
dump
may fail for ill-formed values, such as obtained from a faulty C binding or crazy uses of Obj.set_tag
.
val print_any : 'b BatIO.output -> 'a -> unit
Attempt to print a value to an output.
Uses dump
to convert the value to a string and prints that string to the output.
List operations
More list operations are provided in module List
.
Input/output
This section only contains the most common input/output operations. More operations may be found in modules BatIO
and File
.
val stdin : BatIO.input
Standard input, as per Unix/Windows conventions (by default, keyboard).
Use this input to read what the user is writing on the keyboard.
val stdout : unit BatIO.output
Standard output, as per Unix/Windows conventions (by default, console).
Use this output to display regular messages.
val stderr : unit BatIO.output
Standard error output, as per Unix/Windows conventions.
Use this output to display warnings and error messages.
val stdnull : unit BatIO.output
An output which discards everything written to it.
Use this output to ignore messages.
Write all pending data to output channels, ignore all errors.
It is normally not necessary to call this function, as all pending data is written when an output channel is closed or when the program itself terminates, either normally or because of an uncaught exception. However, this function is useful for debugging, as it forces pending data to be written immediately.
Output functions on standard output
val print_guess : 'a BatIO.output -> 'b -> unit
Attempt to print the representation of a runtime value on the standard output. See remarks for dump
. This function is useful mostly for debugging. As a general rule, it should not be used in production code.
val print_all : BatIO.input -> unit
Print the contents of an input to the standard output.
Output functions on standard error
Attempt to print the representation of a runtime value on the error output. See remarks for dump
. This function is useful mostly for debugging.
val prerr_all : BatIO.input -> unit
Print the contents of an input to the error output.
General output functions
creates a filename, write text into it and close it.
val open_out :
?mode:BatFile.open_out_flag list ->
?perm:BatFile.permission ->
string ->
unit BatIO.output
Open the named file for writing, and return a new output channel on that file. You will need to close the file once you have finished using it.
You may use optional argument mode
to decide whether the output will overwrite the contents of the file (by default) or to add things at the end of the file, whether the file should be created if it does not exist yet (the default) or not, whether this operation should proceed if the file exists already (the default) or not, whether the file should be opened as text (the default) or as binary, and whether the file should be opened for non-blocking operations.
You may use optional argument perm
to specify the permissions of the file, as per Unix conventions. By default, files are created with default permissions (which depend on your setup).
val open_out_bin : string -> unit BatIO.output
val open_out_gen :
Pervasives.open_flag list ->
int ->
string ->
unit BatIO.output
open_out_gen mode perm filename
opens the named file for writing, as described above. The extra argument mode
specifies the opening mode. The extra argument perm
specifies the file permissions, in case the file must be created.
val flush : unit BatIO.output -> unit
Flush the buffer associated with the given output, performing all pending writes on that channel. Interactive programs must be careful about flushing standard output and standard error at the right time.
val output_char : unit BatIO.output -> char -> unit
Write the character on the given output channel.
val output_string : unit BatIO.output -> string -> unit
Write the string on the given output channel.
val output : unit BatIO.output -> Bytes.t -> int -> int -> unit
output oc buf pos len
writes len
characters from byte sequence buf
, starting at offset pos
, to the given output channel oc
.
val output_substring : unit BatIO.output -> string -> int -> int -> unit
output_substring oc buf pos len
writes len
characters from string buf
, starting at offset pos
, to the given output channel oc
.
val output_byte : unit BatIO.output -> int -> unit
Write one 8-bit integer (as the single character with that code) on the given output channel. The given integer is taken modulo 256.
val output_binary_int : unit BatIO.output -> int -> unit
Write one integer in binary format (4 bytes, big-endian) on the given output channel. The given integer is taken modulo 232. The only reliable way to read it back is through the Pervasives.input_binary_int
function. The format is compatible across all machines for a given version of OCaml.
val output_binary_float : unit BatIO.output -> float -> unit
Write one float in binary format (8 bytes, IEEE 754 double format) on the given output channel. The only reliable way to read it back is through the Pervasives
.input_binary_float function. The format is compatible across all machines for a given version of OCaml.
val output_value : unit BatIO.output -> 'a -> unit
Write the representation of a structured value of any type to a channel. Circularities and sharing inside the value are detected and preserved. The object can be read back, by the function input_value
. See the description of module Marshal
for more information. output_value
is equivalent to Marshal.output
with an empty list of flags.
val close_out : unit BatIO.output -> unit
Close the given channel, flushing all buffered write operations. Output functions raise a Sys_error
exception when they are applied to a closed output channel, except close_out
and flush
, which do nothing when applied to an already closed channel.
val close_out_noerr : unit BatIO.output -> unit
Same as close_out
, but ignore all errors.
General input functions
val open_in :
?mode:BatFile.open_in_flag list ->
?perm:BatFile.permission ->
string ->
BatIO.input
Open the named file for reading. You will need to close the file once you have finished using it.
You may use optional argument mode
to decide whether the opening should fail if the file doesn't exist yet (by default) or whether the file should be created if it doesn't exist yet, whether the opening should fail if the file already exists or not (by default), whether the file should be read as binary (by default) or as text, and whether reading should be non-blocking.
You may use optional argument perm
to specify the permissions of the file, should it be created, as per Unix conventions. By default, files are created with default permissions (which depend on your setup).
val open_in_bin : string -> BatIO.input
Same as Pervasives.open_in
, but the file is opened in binary mode, so that no translation takes place during reads. On operating systems that do not distinguish between text mode and binary mode, this function behaves like Pervasives.open_in
.
val open_in_gen : Pervasives.open_flag list -> int -> string -> BatIO.input
open_in_gen mode perm filename
opens the named file for reading, as described above. The extra arguments mode
and perm
specify the opening mode and file permissions. Pervasives.open_in
and Pervasives.open_in_bin
are special cases of this function.
val input_char : BatIO.input -> char
Read one character from the given input channel.
val input_line : BatIO.input -> string
Read characters from the given input channel, until a newline character is encountered. Return the string of all characters read, without the newline character at the end.
val input : BatIO.input -> Bytes.t -> int -> int -> int
input ic buf pos len
reads up to len
characters from the given channel ic
, storing them in byte sequence buf
, starting at character number pos
. It returns the actual number of characters read, between 0 and len
(inclusive). A return value of 0 means that the end of file was reached. A return value between 0 and len
exclusive means that not all requested len
characters were read, either because no more characters were available at that time, or because the implementation found it convenient to do a partial read; input
must be called again to read the remaining characters, if desired. (See also Pervasives.really_input
for reading exactly len
characters.)
val really_input : BatIO.input -> Bytes.t -> int -> int -> unit
really_input ic buf pos len
reads len
characters from channel ic
, storing them in byte sequence buf
, starting at character number pos
.
val input_byte : BatIO.input -> int
Same as Pervasives.input_char
, but return the 8-bit integer representing the character.
val input_binary_int : BatIO.input -> int
Read an integer encoded in binary format (4 bytes, big-endian) from the given input channel. See Pervasives.output_binary_int
.
val input_binary_float : BatIO.input -> float
Read a float encoded in binary format (8 bytes, IEEE 754 double format) from the given input channel. See Pervasives
.output_binary_float.
val input_value : BatIO.input -> 'a
Read the representation of a structured value, as produced by output_value
, and return the corresponding value. This function is identical to Marshal.input
; see the description of module Marshal
for more information, in particular concerning the lack of type safety.
val close_in : BatIO.input -> unit
Close the given channel. Input functions raise a Sys_error
exception when they are applied to a closed input channel, except close_in
, which does nothing when applied to an already closed channel.
val close_in_noerr : BatIO.input -> unit
Same as close_in
, but ignore all errors.
Fundamental functions and operators
The undefined function.
Evaluating undefined x
always fails and raises an exception "Undefined". Optional argument message
permits the customization of the error message.
Function application. f @@ x
is equivalent to f x
. However, it binds less tightly (between ::
and =
,<
,>
,etc) and is right-associative, which makes it useful for composing sequences of function calls without too many parentheses. It is similar to Haskell's $
. Note that it replaces pre-2.0 **>
and <|
.
Function composition: the mathematical o
operator. f % g
is fun x -> f (g x)
. It is similar to Haskell's .
.
Examples: the following are equivalent: f (g (h x))
, f @@ g @@ h x
, f % g % h @@ x
.
The "pipe": function application. x |> f
is equivalent to f x
.
This operator is commonly used to write a function composition by order of evaluation (the order used in object-oriented programming) rather than by inverse order (the order typically used in functional programming).
For instance, g (f x)
means "apply f
to x
, then apply g
to the result." The corresponding notation in most object-oriented programming languages would be somewhere along the lines of x.f.g.h()
, or "starting from x
, apply f
, then apply g
." In OCaml, using the ( |> ) operator, this is written x |> f |> g |> h
.
This operator may also be useful for composing sequences of function calls without too many parentheses.
Piping function composition. f %> g
is fun x -> g (f x)
. Whereas f % g
applies g
first and f
second, f %> g
applies f
, then g
. Note that it plays well with pipes, so for instance x |> f %> g %> h |> i %> j
yields the expected result... but in such cases it's still recommended to use |>
only. Note that it replaces pre-2.0 |-
, which didn't integrate with pipes.
Like BatOption.default
, with the arguments reversed. None |? 10
returns 10
, while Some "foo" |? "bar"
returns "foo"
.
Note This operator does not short circuit like ( || )
and ( && )
. Both arguments will be evaluated.
Argument flipping.
flip f x y
is f y x
. Don't abuse this function, it may shorten considerably your code but it also has the nasty habit of making it harder to read.
Convert a function which accepts a pair of arguments into a function which accepts two arguments.
curry f
is fun x y -> f (x,y)
Convert a function which accepts two arguments into a function which accepts a pair of arguments.
uncurry f
is fun (x, y) -> f x y
neg p
returns a new predicate that is the negation of the given predicate. That is, the new predicate returns false
when the input predicate returns true
and vice versa. This is for predicates with one argument.
neg p
is fun x -> not (p x)
Returns an unique identifier every time it is called.
Note This is thread-safe.
Allows application of a function in the middle of a pipe sequence without disturbing the sequence. x |> tap f
evaluates to x
, but has the side effect of f x
. Useful for debugging.
finally fend f x
calls f x
and then fend()
even if f x
raised an exception.
with_dispose dispose f x
invokes f
on x
, calling dispose x
when f
terminates (either with a return value or an exception).
forever f x
invokes f
on x
repeatedly (until an exception occurs).
ignore_exceptions f x
invokes f
on x
, ignoring both the returned value and the exceptions that may be raised.
verify_arg condition message
will raise Invalid_argument message
if condition
is false, otherwise it does nothing.
val args : unit -> string BatEnum.t
An enumeration of the arguments passed to this program through the command line.
args ()
is given by the elements of Sys.argv
, minus the first element.
val invisible_args : int Pervasives.ref
/*
The number of arguments which must never be returned by args
Typically, invisible_args
is 1
, to drop the name of the executable. However, in some circumstances, it may be useful to pretend that some arguments need not be parsed.
Enumerations
In OCaml Batteries Included, all data structures are enumerable, which means that they support a number of standard operations, transformations, etc. The general manner of enumerating the contents of a data structure is to invoke the enum
function of your data structure.
For instance, you may use the foreach
loop to apply a function f
to all the consecutive elements of a string s
. For this purpose, you may write either foreach (String.enum s) f
or open
String in foreach (enum s) f
. Either possibility states that you are enumerating through a character string s
. Should you prefer your enumeration to proceed from the end of the string to the beginning, you may replace String.enum
with
String
.backwards. Therefore, either foreach (String.backwards s)
f
or open String in foreach (backwards s) f
will apply f
to all the consecutive elements of string s
, from the last to the first.
Similarly, you may use List.enum
instead of String.enum
to visit the elements of a list in the usual order, or List.backwards
instead of String.backwards
to visit them in the opposite order, or Hashtbl.enum
for hash tables, etc.
More operations on enumerations are defined in module BatEnum
, including the necessary constructors to make your own structures enumerable.
The various kinds of loops are detailed further in this documentation.
val foreach : 'a BatEnum.t -> ('a -> unit) -> unit
Imperative loop on an enumeration.
foreach e f
applies function f
to each successive element of e
. For instance, foreach (1 -- 10) print_int
invokes function print_int
on 1
, 2
, ..., 10
, printing 12345678910
.
Note This function is one of the many loops available on enumerations. Other commonly used loops are iter
(same usage scenario as foreach
, but with different notations), map
(convert an enumeration to another enumeration) or fold
(flatten an enumeration by applying an operation to each element).
General-purpose loops
topic loops
The following functions are the three main general-purpose loops available in OCaml. By opposition to the loops available in imperative languages, OCaml loops are regular functions, which may be passed, composed, currified, etc. In particular, each of these loops may be considered either as a manner of applying a function to a data structure or as transforming a function into another function which will act on a whole data structure.
For instance, if f
is a function operating on one value, you may lift this function to operate on all values of an enumeration (and consequently on all values of any data structure of OCaml Batteries Included) by applying iter
, map
or fold
to this function.
val iter : ('a -> unit) -> 'a BatEnum.t -> unit
Imperative loop on an enumeration. This loop is typically used to lift a function with an effect but no meaningful result and get it to work on enumerations.
If f
is a function iter f
is a function which behaves as f
but acts upon enumerations rather than individual elements. As indicated in the type of iter
, f
must produce values of type unit
(i.e. f
has no meaningful result) the resulting function produces no meaningful result either.
In other words, iter f
is a function which, when applied upon an enumeration e
, calls f
with each element of e
in turn.
For instance, iter f (1 -- 10)
invokes function f
on 1
, 2
, ..., 10
and produces value ()
.
Transformation loop on an enumeration, used to build an enumeration from another enumeration. This loop is typically used to transform an enumeration into another enumeration with the same number of elements, in the same order.
If f
is a function, map f e
is a function which behaves as f
but acts upon enumerations rather than individual elements -- and builds a new enumeration from the results of each application.
In other words, map f
is a function which, when applied upon an enumeration containing elements e0
, e1
, ..., produces enumeration f e0
, f e1
, ...
For instance, if odd
is the function which returns true
when applied to an odd number or false
when applied to an even number, map odd (1 -- 10)
produces enumeration true
, false
, true
, ..., false
.
Similarly, if square
is the function fun x -> x * x
, map square (1 -- 10)
produces the enumeration of the square numbers of all numbers between 1
and 10
.
val reduce : ('a -> 'a -> 'a) -> 'a BatEnum.t -> 'a
Transformation loop on an enumeration, used to build a single value from an enumeration.
If f
is a function and e
is an enumeration, reduce f e
applies function f
to the first two elements of e
, then to the result of this expression and to the third element of e
, then to the result of this new expression and to the fourth element of e
...
In other words, reduce f e
returns a0
if e
contains only one element a0
, otherwise f (... (f (f a0) a1) ...) aN
where a0,a1..aN
are the elements of e
.
val fold : ('b -> 'a -> 'b) -> 'b -> 'a BatEnum.t -> 'b
Transformation loop on an enumeration, used to build a single value from an enumeration. This is the most powerful general-purpose loop and also the most complex.
If f
is a function, fold f v e
applies f v
to the first element of e
, then, calling acc_1
the result of this operation, applies f acc_1
to the second element of e
, then, calling acc_2
the result of this operation, applies f acc_2
to the third element of e
...
In other words, fold f v e
returns v
if e
is empty, otherwise f (... (f (f v a0) a1) ...) aN
where a0,a1..aN are the elements of e
.
For instance, if add
is the function fun x y -> x + y
, fold add 0
is the function which computes the sum of the elements of an enumeration. Therefore, fold add 0 (1 -- 10)
produces result 55
.
Functional loop on an enumeration, used to build an enumeration from both an enumeration and an initial value. This function may be seen as a variant of fold
which returns not only the final result of fold
but the enumeration of all the intermediate results of fold
.
If f
is a function, scanl f v e
is applies f v
to the first element of e
, then, calling acc_1
the result of this operation, applies f acc_1
to the second element of e
, then, calling acc_2
the result of this operation, applies f acc_2
to the third element of e
...
For instance, if add
is the function fun x y -> x + y
, scanl add 0
is the function which computes the sum of the elements of an enumeration. Therefore, scanl add 0 (1 -- 10)
produces result the enumeration with elements 0, 1, 3, 6, 10,
15, 21, 28, 36, 45, 55
.
Mapping operators.
These operators have the same meaning as function map
but are sometimes more readable than this function, when chaining several transformations in a row.
Map combined with filter. Same as filter_map
.
Other operations on enumerations
val exists : ('a -> bool) -> 'a BatEnum.t -> bool
exists f e
returns true
if there is some x
in e
such that f x
val for_all : ('a -> bool) -> 'a BatEnum.t -> bool
for_all f e
returns true
if for every x
in e
, f x
is true
val find : ('a -> bool) -> 'a BatEnum.t -> 'a
find f e
returns the first element x
of e
such that f x
returns true
, consuming the enumeration up to and including the found element, or, raises Not_found
if no such element exists in the enumeration, consuming the whole enumeration in the search.
Since find
consumes a prefix of the enumeration, it can be used several times on the same enumeration to find the next element.
val peek : 'a BatEnum.t -> 'a option
peek e
returns None
if e
is empty or Some x
where x
is the next element of e
. The element is not removed from the enumeration.
val get : 'a BatEnum.t -> 'a option
get e
returns None
if e
is empty or Some x
where x
is the next element of e
, in which case the element is removed from the enumeration.
val push : 'a BatEnum.t -> 'a -> unit
push e x
will add x
at the beginning of e
.
val junk : 'a BatEnum.t -> unit
junk e
removes the first element from the enumeration, if any.
filter f e
returns an enumeration over all elements x
of e
such as f x
returns true
.
Filtering (pronounce this operator name "such that").
For instance, (1 -- 37) // odd
is the enumeration of all odd numbers between 1 and 37.
concat e
returns an enumeration over all elements of all enumerations of e
.
val (--) : int -> int -> int BatEnum.t
Enumerate numbers.
5 -- 10
is the enumeration 5,6,7,8,9,10. 10 -- 5
is the empty enumeration
val (--^) : int -> int -> int BatEnum.t
Enumerate numbers, without the right endpoint
5 -- 10
is the enumeration 5,6,7,8,9.
val (--.) : (float * float) -> float -> float BatEnum.t
(a, step) --. b)
creates a float enumeration from a
to b
with an increment of step
between elements.
(5.0, 1.0) --. 10.0
is the enumeration 5.0,6.0,7.0,8.0,9.0,10.0. (10.0, -1.0) --. 5.0
is the enumeration 10.0,9.0,8.0,7.0,6.0,5.0. (10.0, 1.0) --. 1.0
is the empty enumeration.
val (---) : int -> int -> int BatEnum.t
As --
, but accepts enumerations in reverse order.
5 --- 10
is the enumeration 5,6,7,8,9,10. 10 --- 5
is the enumeration 10,9,8,7,6,5.
val (--~) : char -> char -> char BatEnum.t
As ( -- ), but for characters.
val print :
?first:string ->
?last:string ->
?sep:string ->
('a BatInnerIO.output -> 'b -> unit) ->
'a BatInnerIO.output ->
'b BatEnum.t ->
unit
Print and consume the contents of an enumeration.
Results
type ('a, 'e) result = ('a, 'e) BatInnerPervasives.result =
This type represents the outcome of a function which has the possibility of failure. Normal results of type 'a
are marked with Ok
, while failure values of type 'b
are marked with Error
.
This is intended to be a safer alternative to functions raising exceptions to signal failure. It is safer in that the possibility of failure has to be handled before the result of that computation can be used.
For more functions related to this type, see the BatResult
module.
val ignore_ok : ('a, exn) result -> unit
ignore_ok (f x)
ignores the result of f x
if it's ok, but throws the exception contained if Error
is returned.
val ok : ('a, exn) result -> 'a
f x |> ok
unwraps the Ok
result of f x
and returns it, or throws the exception contained if Error
is returned.
val wrap : ('a -> 'b) -> 'a -> ('b, exn) result
wrap f x
wraps a function that would normally throw an exception on failure such that it now returns a result with either the Ok
return value or the Error
exception.
Thread-safety internals
Unless you are attempting to adapt Batteries Included to a new model of concurrency, you probably won't need this.
val lock : BatConcurrent.lock Pervasives.ref
A lock used to synchronize internal operations.
By default, this is BatConcurrent.nolock
. However, if you're using a version of Batteries compiled in threaded mode, this uses BatMutex
. If you're attempting to use Batteries with another concurrency model, set the lock appropriately.
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