Index of values


( * ) [BatNumber.Numeric]
( * ) [BatNum]
( * ) [BatNativeint]
( * ) [BatInt.Safe_int]
Multiplication.
( * ) [BatInt]
Multiplication.
( * ) [BatFloat.Safe_float]
( * ) [BatFloat]
( * ) [BatComplex]
( * ) [BatBool]
( * ) [BatBig_int]
( ** ) [BatNumber.Numeric]
( ** ) [BatNum]
( ** ) [BatNativeint]
( ** ) [BatInt.Safe_int]
a ** b computes ab
( ** ) [BatInt]
a ** b computes ab
( ** ) [BatFloat.Safe_float]
( ** ) [BatFloat]
( ** ) [BatComplex]
( ** ) [BatBool]
( ** ) [BatBig_int]
( *** ) [BatStd]
Function pairing.
( *** ) [BatPervasives]
Function pairing.
( **> ) [BatPervasives]
Function application.
( ~* ) [BatParserCo]
As zero_plus without arguments.
(!!) [BatPathGen.PathType.OperatorLift]
Prefix operator that converts primitive string to ustring.
(!) [BatRef]
!r returns the current contents of reference r.
(&&&) [BatStd]
Applying two functions to the same argument.
(&&&) [BatPervasives]
Applying two functions to the same argument.
(&&) [BatBool]
The boolean ``and''.
(+) [BatNumber.Numeric]
(+) [BatNum]
(+) [BatNativeint]
(+) [BatInt.Safe_int]
Addition.
(+) [BatInt]
Addition.
(+) [BatFloat.Safe_float]
(+) [BatFloat]
(+) [BatComplex]
(+) [BatBool]
(+) [BatBig_int]
(-) [BatNumber.Numeric]
(-) [BatNum]
(-) [BatNativeint]
(-) [BatInt.Safe_int]
Substraction.
(-) [BatInt]
Subtraction.
(-) [BatFloat.Safe_float]
(-) [BatFloat]
(-) [BatComplex]
(-) [BatBool]
(-) [BatBig_int]
(--) [BatPervasives]
Enumerate numbers.
(--) [BatNumber.Discrete]
(--) [BatNativeint]
Enumerate an interval.
(--) [BatInt64]
Enumerate an interval.
(--) [BatInt32]
Enumerate an interval.
(--) [BatInt]
Enumerate an interval.
(--) [BatEnum]
As range, without the label.
(--) [BatChar]
Produce the enumeration of a segment of characters.
(--) [BatBig_int]
(---) [BatPervasives]
As --, but accepts enumerations in reverse order.
(---) [BatNumber.Discrete]
(---) [BatNativeint]
Enumerate an interval.
(---) [BatInt64]
Enumerate an interval.
(---) [BatInt32]
Enumerate an interval.
(---) [BatInt]
Enumerate an interval.
(---) [BatEnum]
As --, but accepts enumerations in reverse order.
(---) [BatBig_int]
(--.) [BatPervasives]
(a, step) --. b) creates a float enumeration from a to b with an increment of step between elements.
(--.) [BatEnum]
(a, step) --. b) creates a float enumeration from a to b with an increment of step between elements.
(--^) [BatPervasives]
Enumerate numbers, without the right endpoint
(--^) [BatEnum]
As (--) but without the right endpoint
(--~) [BatPervasives]
As ( -- ), but for characters.
(--~) [BatEnum]
As ( -- ), but for characters.
(-|) [BatStd]
Function composition.
(-|) [BatPervasives]
Function composition.
(/) [BatNumber.Numeric]
(/) [BatNum]
(/) [BatNativeint]
(/) [BatInt.Safe_int]
Integer division.
(/) [BatInt]
Integer division.
(/) [BatFloat.Safe_float]
(/) [BatFloat]
(/) [BatComplex]
(/) [BatBool]
(/) [BatBig_int]
(//) [BatPervasives]
Filtering (pronounce this operator name "such that").
(//) [BatEnum]
Filtering (pronounce this operator name "such that").
(//@) [BatPathGen.PathType.Operators]
basepath//@relpath catenates two paths.
(/:) [BatPathGen.PathType.Operators]
path/:name is a path of name located in a directory path.
(/@) [BatPervasives]
(/@) [BatEnum]
(:=) [BatRef]
r := a stores the value of a in reference r.
(<) [BatNumber.Numeric]
(<) [BatNum]
(<) [BatNativeint]
(<) [BatInt.Safe_int]
Comparaison: a < b is true if and only if a is strictly smaller than b.
(<) [BatInt]
(<) [BatFloat.Safe_float]
(<) [BatFloat]
(<) [BatComplex]
(<) [BatBool]
(<) [BatBig_int]
(</) [BatNum]
(<=) [BatNumber.Numeric]
(<=) [BatNum]
(<=) [BatNativeint]
(<=) [BatInt.Safe_int]
Comparaison: a <= b is true if and only if a is smaller or equalto b.
(<=) [BatInt]
(<=) [BatFloat.Safe_float]
(<=) [BatFloat]
(<=) [BatComplex]
(<=) [BatBool]
(<=) [BatBig_int]
(<=/) [BatNum]
(<>) [BatNumber.Numeric]
(<>) [BatNum]
(<>) [BatNativeint]
(<>) [BatInt.Safe_int]
Comparaison: a <> b is true if and only if a and b have different values.
(<>) [BatInt]
(<>) [BatFloat.Safe_float]
(<>) [BatFloat]
(<>) [BatComplex]
(<>) [BatBool]
(<>) [BatBig_int]
(<>/) [BatNum]
(<|) [BatStd]
Function application.
(<|>) [BatParserCo]
Accept one of two parsers
(=) [BatNumber.Numeric]
(=) [BatNum]
(=) [BatNativeint]
(=) [BatInt.Safe_int]
Comparaison: a = b if and only if a and b have the same value.
(=) [BatInt]
(=) [BatFloat.Safe_float]
(=) [BatFloat]
(=) [BatComplex]
(=) [BatBool]
(=) [BatBig_int]
(=/) [BatNum]
(>) [BatNumber.Numeric]
(>) [BatNum]
(>) [BatNativeint]
(>) [BatInt.Safe_int]
Comparaison: a > b is true if and only if a is strictly greater than b.
(>) [BatInt]
(>) [BatFloat.Safe_float]
(>) [BatFloat]
(>) [BatComplex]
(>) [BatBool]
(>) [BatBig_int]
(>/) [BatNum]
(>::) [BatParserCo]
As cons
(>=) [BatNumber.Numeric]
(>=) [BatNum]
(>=) [BatNativeint]
(>=) [BatInt.Safe_int]
Comparaison: a >= b is true if and only if a is greater or equal to b.
(>=) [BatInt]
(>=) [BatFloat.Safe_float]
(>=) [BatFloat]
(>=) [BatComplex]
(>=) [BatBool]
(>=) [BatBig_int]
(>=/) [BatNum]
(>>=) [BatResult]
as bind
(>>=) [BatParserCo]
As bind
(>>>) [BatParserCo]
As bind, but ignoring the result
(@) [BatPervasives]
List concatenation.
(@) [BatList]
the new implementation for ( @ ) operator, see List.append.
(@/) [BatPervasives]
Mapping operators.
(@/) [BatEnum]
Mapping operators.
(^:^) [BatLazyList]
As cons: x^:^l is the lazy list with head x and tail l
(^@^) [BatLazyList]
As lazy append
(^^) [BatParserCo]
p ^^ n is the same thing as times n p
(^^^) [BatRope]
(|-) [BatStd]
Function composition.
(|-) [BatPervasives]
Function composition.
(|>) [BatStd]
Operators
(|>) [BatPervasives]
Function application.
(||) [BatBool]
The boolean ``or''.
(~+) [BatParserCo]
As one_plus
(~?) [BatParserCo]
As maybe

A
abs [BatNumber.Numeric]
abs [BatNum]
abs [BatNativeint]
Return the absolute value of its argument.
abs [BatInt64]
Return the absolute value of its argument.
abs [BatInt32]
Return the absolute value of its argument.
abs [BatInt.Safe_int]
Return the absolute value of its argument.
abs [BatInt]
Return the absolute value of its argument.
abs [BatFloat.Safe_float]
The absolute value of a floating point number.
abs [BatFloat]
The absolute value of a floating point number.
abs [BatComplex]
abs c returns the module of this complex number, i.e.
abs [BatBool]
abs [BatBig_int]
acos [BatFloat.Safe_float]
acos [BatFloat]
add [BatSet.S]
add x s returns a set containing all elements of s, plus x.
add [BatRefList]
Adds an element at the end - O(n)
add [BatQueue.Queue]
add x q adds the element x at the end of the queue q.
add [BatPSet]
add x s returns a set containing all elements of s, plus x.
add [BatPMap]
add x y m returns a map containing the same bindings as m, plus a binding of x to y.
add [BatOptParse.OptParser]
Add an option to the option parser.
add [BatNumber.Numeric]
add [BatNum]
add [BatNativeint]
Addition.
add [BatMultiPMap]
add x y m returns a map containing the same bindings as m, plus a binding of x to y.
add [BatMap.S.Labels]
add [BatMap.S]
add x y m returns a map containing the same bindings as m, plus a binding of x to y.
add [BatInt64]
Addition.
add [BatInt32]
Addition.
add [BatInt.Safe_int]
Addition.
add [BatInt]
Addition.
add [BatInnerWeaktbl]
Weaktbl.add tbl x y adds a binding of x to y in table tbl.
add [BatISet]
add [BatIMap]
add [BatHashtbl.Cap.Labels]
add [BatHashtbl.Cap]
Hashtbl.add tbl x y adds a binding of x to y in table tbl.
add [BatHashtbl.S.Labels]
add [BatHashtbl.S]
add [BatHashtbl.Labels]
add [BatHashtbl]
Hashtbl.add tbl x y adds a binding of x to y in table tbl.
add [BatFloat.Safe_float]
add [BatFloat]
add [BatDynArray]
add darr v appends v onto darr.
add [BatDllist]
add n a Creates a new node containing data a and inserts it into the list after node n.
add [BatComplex]
Addition
add [BatBool]
add [BatBig_int]
add_buffer [BatUTF8.Buf]
add_buffer b1 b2 adds the contents of b2 to b1.
add_carry [BatPMap]
add_carry k v m adds the binding (k,v) to m, returning the new map and optionally the previous value bound to k.
add_channel [BatBuffer]
add_char [BatUTF8.Buf]
Add one Unicode character to the buffer.
add_group [BatOptParse.OptParser]
Add a group to the option parser.
add_initializer [BatOo.Oo.Internal]
add_input [BatBuffer]
add_input b ic n reads exactly n character from the input ic and stores them at the end of buffer b.
add_int_big_int [BatBig_int]
Addition of a small integer to a big integer.
add_range [BatISet]
add_range [BatIMap]
add_sort [BatRefList]
Adds an element in a sorted list, using optional comparator or 'compare' as default.
add_string [BatUTF8.Buf]
Add the UTF-8 string to the buffer.
advance [BatUCharParser]
Advance by one char.
advance [BatCharParser]
Advance by one char.
after [BatISet]
after [BatIMap]
all [BatSubstring]
all s is the substring (s, 0, size s).
any [BatParserCo]
Accept any singleton value.
apnd [BatStream]
apnd fla flb equals [<fla;flb>].
append [BatVect.RANDOMACCESS]
append [BatVect.Make]
append c r returns a new vect with the c element at the end in amortized O(1) time.
append [BatVect]
append c r returns a new vect with the c element at the end in amortized O(1) time.
append [BatUTF8]
Concatenate two UTF8 strings
append [BatSeq]
append s1 s2 returns the sequence which first returns all elements of s1 then all elements of s2.
append [BatRope]
append r u concatenates the r and u ropes.
append [BatPathGen.PathType]
Alternative name for BatPathGen.PathType.Operators.(/:)
append [BatList]
Catenate two lists.
append [BatLazyList]
Lazy append
append [BatEnum]
append e1 e2 returns an enumeration that will enumerate over all elements of e1 followed by all elements of e2.
append [BatDynArray]
append src dst adds all elements of src to the end of dst.
append [BatDllist]
append n a Creates a new node containing data a and inserts it into the list after node n.
append [BatArray.Cap]
Array.append v1 v2 returns a fresh array containing the concatenation of the arrays v1 and v2.
append [BatArray]
Array.append v1 v2 returns a fresh array containing the concatenation of the arrays v1 and v2.
append_char [BatRope]
append_char c r returns a new rope with the c character at the end in amortized O(1) time.
approx [BatNum]
approx n return the integer closest to n
approx_num_exp [BatNum]
Approximate a number by a decimal.
approx_num_fix [BatNum]
See Num.approx_num_exp.
arg [BatComplex]
Argument.
args [BatStd]
An enumeration of the arguments passed to this program through the command line.
args [BatPervasives]
An enumeration of the arguments passed to this program through the command line.
array1_of_genarray [BatBigarray]
Return the one-dimensional big array corresponding to the given generic big array.
array2_of_genarray [BatBigarray]
Return the two-dimensional big array corresponding to the given generic big array.
array3_of_genarray [BatBigarray]
Return the three-dimensional big array corresponding to the given generic big array.
as_encoded [BatCharEncodings]
as_encoded x enc returns an element of type t used to mark that x is encoded with encoding enc.
asin [BatFloat.Safe_float]
asin [BatFloat]
assoc [BatSeq]
assoc a s returns the value associated with key a in the sequence of pairs s.
assoc [BatList.Labels.LExceptionless]
assoc [BatList.Exceptionless]
assoc a l returns Some b where b is the value associated with key a in the list of pairs l.
assoc [BatLazyList.Labels.Exceptionless]
assoc [BatLazyList.Exceptionless]
assoc a l returns Some b where b is the value associated with key a in the list of pairs l.
assoc [BatLazyList]
assoc a l returns the value associated with key a in the list of pairs l.
assoc_inv [BatList.Labels.LExceptionless]
assoc_inv [BatList.Exceptionless]
assoc_inv b l returns Some a where a is the key associated with value a in the list of pairs l.
assoc_inv [BatList]
assoc_inv b l returns the key associated with value b in the list of pairs l.
assq [BatList.Labels.LExceptionless]
assq [BatList.Exceptionless]
As BatList.Exceptionless.assoc but with physical equality.
assq [BatLazyList.Labels.Exceptionless]
assq [BatLazyList.Exceptionless]
As BatLazyList.Exceptionless.assoc but with physical equality
assq [BatLazyList]
As BatLazyList.assoc but with physical equality
at [BatVect]
as get
at [BatSeq.Exceptionless]
at [BatSeq]
at l n returns the n-th element of the sequence l or raise Invalid_argument is the index is outside of l bounds.
at [BatList.Labels.LExceptionless]
at [BatList.Exceptionless]
If n is inside the bounds of l, at l n returns Ok x, where x is the n-th element of the list l.
at [BatList]
at l n returns the n-th element of the list l or raise Invalid_index is the index is outside of l bounds.
at [BatLazyList.Labels.Exceptionless]
at [BatLazyList.Exceptionless]
If n is inside the bounds of l, at l n returns `Ok x, where x is the n-th element of the list l.
at [BatLazyList]
at l n returns the n-th element of the list l or raise Invalid_index is the index is outside of l bounds.
at_end [BatUTF8.Byte]
at_index [BatRefList.Index]
Return the element of ref list at the specified index raise Invalid_index if the index is outside 0 ; length-1
atan [BatFloat.Safe_float]
atan [BatFloat]
atan2 [BatFloat.Safe_float]
The usual trigonometric functions.
atan2 [BatFloat]
The usual trigonometric functions.

B
backwards [BatVect.RANDOMACCESS]
backwards [BatVect]
Returns an enumeration of the elements of a vector, from last to first.
backwards [BatUTF8]
As String.backwards
backwards [BatString]
Returns an enumeration of the characters of a string, from last to first.
backwards [BatSet.S]
Return an enumeration of all elements of the given set.
backwards [BatRope]
Returns an enumeration of the characters of a rope, from last to first.
backwards [BatRefList]
Returns an enumeration of current elements in the ref list, going from last to first
backwards [BatList]
Returns an enumeration of the elements of a list.
backwards [BatArray.Cap]
Returns an enumeration of the elements of an array, from end to start.
backwards [BatArray]
Returns an enumeration of the elements of an array, from last to first.
balance [BatVect.Make]
balance r returns a balanced copy of the r vect.
balance [BatVect]
balance r returns a balanced copy of the r vect.
balance [BatRope]
balance r returns a balanced copy of the r rope.
base [BatSubstring]
base sus is the concrete triple (s, i, n), where sus = (s, i, n).
before [BatISet]
before [BatIMap]
beginning_of_input [BatScanf.Scanning]
Scanning.beginning_of_input ib tests the beginning of input condition of the given scanning buffer.
belongs [BatPathGen.PathType]
belongs base sub is true when sub descends from base, i.e.
big_int_of_int [BatBig_int]
Convert a small integer to a big integer.
big_int_of_num [BatNum]
big_int_of_string [BatBig_int]
Convert a string to a big integer, in decimal.
bind [BatResult]
Monadic composition.
bind [BatParserCo]
Monadic-style combination:
bind [BatOption.Monad]
bind m f combines the calculation result m with the function f.
bind [BatOption]
bind f (Some x) returns f x and bind f None returns None.
bind [BatMonad.S]
Monadic binding.
bind [BatEnum.Monad]
bind m f takes the result of the monadic computation m, puts the f function in the monadic context passing it the result of m and then returning a monadic result.
bits [BatRandom.State]
bits [BatRandom]
Return 30 random bits in a nonnegative integer.
bits_of [BatIO]
Read an enumeration of bits
bits_of_float [BatInt64]
Return the internal representation of the given float according to the IEEE 754 floating-point ``double format'' bit layout.
bits_of_float [BatInt32]
Return the internal representation of the given float according to the IEEE 754 floating-point ``single format'' bit layout.
blit [BatRope]
blit src srcoff dst dstoff len returns a copy of dst in which len characters have been copied from rope src, starting at character number srcoff, to rope dst, starting at character number dstoff.
blit [BatDynArray]
blit src srcidx dst dstidx len copies len elements from src starting with index srcidx to dst starting at dstidx.
blit [BatBuffer]
Buffer.blit b srcoff dst dstoff len copies len characters from the current contents of the buffer b starting at offset off, starting at character number srcoff, to string dst, starting at character number dstoff.
blit [BatBigarray.Array3]
Copy the first big array to the second big array.
blit [BatBigarray.Array2]
Copy the first big array to the second big array.
blit [BatBigarray.Array1]
Copy the first big array to the second big array.
blit [BatBigarray.Genarray]
Copy all elements of a big array in another big array.
blit [BatArray.Labels]
blit [BatArray.Cap.Labels]
blit [BatArray.Cap]
Array.blit v1 o1 v2 o2 len copies len elements from array v1, starting at element number o1, to array v2, starting at element number o2.
blit [BatArray]
Array.blit v1 o1 v2 o2 len copies len elements from array v1, starting at element number o1, to array v2, starting at element number o2.
bool [BatRandom.State]
bool [BatRandom]
Random.bool () returns true or false with probability 0.5 each.
bounded_full_split [BatStr.Str]
Same as BatStr.Str.bounded_split_delim, but returns the delimiters as well as the substrings contained between delimiters.
bounded_split [BatStr.Str]
Same as BatStr.Str.split, but splits into at most n substrings, where n is the extra integer parameter.
bounded_split_delim [BatStr.Str]
Same as BatStr.Str.bounded_split, but occurrences of the delimiter at the beginning and at the end of the string are recognized and returned as empty strings in the result.
bprintf [BatPrintf]
As BatPrintf.fprintf, but with buffers instead of outputs.
bprintf [BatPrint]
This function behaves as BatPrint.fprintf but prints into a buffer rather than into an output.
bprintf [BatInnerIO.Printf]
As BatInnerIO.Printf.fprintf, but with buffers instead of outputs.
bprintf2 [BatPrintf]
As BatPrintf.printf but writes to a buffer instead of printing to the output.
bprintf2 [BatInnerIO.Printf]
As BatInnerIO.Printf.printf but writes to a buffer instead of printing to the output.
break [BatEnum]
Negated span.
browse [Batteries_config]
browse s opens the platform's default www browser to browse url s.
bscanf [BatScanf]
bscanf ib fmt r1 ... rN f reads arguments for the function f, from the scanning buffer ib, according to the format string fmt, and applies f to these values.
bscanf_format [BatScanf]
bscanf_format ib fmt f reads a format string token from the scannning buffer ib, according to the given format string fmt, and applies f to the resulting format string value.
bulk_enum [BatRope]
Returns an enumeration of the UTF-8 encoded strings of a rope.
bulk_filter_map [BatRope]
bulk_filter_map f l calls (f a0) (f a1).... (f an) where a0..an are the UTF-encoded strings of l.
bulk_fold [BatRope]
As BatRope.fold but over larger chunks of data.
bulk_iter [BatRope]
as iter but over larger chunks of data
bulk_iteri [BatRope]
as iteri but over larger chunks of data.
bulk_map [BatRope]
map f s returns a rope where all ropes c in s have been replaced by f c.
bytes_of [BatIO]
Read an enumeration of unsigned 8-bit integers.

C
c_layout [BatBigarray]
callback_option [BatOptParse.Opt]
Make a callback option which takes a single argument.
capitalize [BatRope]
Return a copy of the argument, with the first character set to uppercase.
cardinal [BatSet.S]
Return the number of elements of a set.
cardinal [BatPSet]
Return the number of elements of a set.
cardinal [BatISet]
cartesian_product [BatList]
Different from List.combine, this returns every pair of elements formed out of the two lists.
case_char [BatUCharParser]
As char, but case-insensitive
case_char [BatCharParser]
As char, but case-insensitive
case_rope [BatUCharParser]
As rope, but case-insensitive
case_sensitive [BatGenlex.Languages.Definition]
true if the language is case-sensitive, false otherwise.
case_string [BatUCharParser]
As string, but case-insensitive
case_string [BatCharParser]
As case_string, but case-insensitive
case_ustring [BatUCharParser]
As ustring, but case-insensitive
cast_output [BatInnerIO]
You can safely transform any output to an unit output in a safe way by using this function.
cast_output [BatIO]
You can safely transform any output to an unit output in a safe way by using this function.
catch [BatResult]
Execute a function and catch any exception as a !result
category [BatUChar]
Determine to which category the character belongs.
ceil [BatNum]
ceil [BatFloat.Safe_float]
ceil [BatFloat]
channel [BatDigest]
If len is nonnegative, Digest.channel ic len reads len characters from channel ic and returns their digest, or raises End_of_file if end-of-file is reached before len characters are read.
char [BatUCharParser]
Recognize exactly one char
char [BatRandom.State]
char [BatRandom]
Return a random Latin-1 character.
char [BatGenlex.Languages.Make]
Low-level API
char [BatCharParser]
Recognize exactly one char
char [BatBigarray]
As shown by the types of the values above, big arrays of kind float32_elt and float64_elt are accessed using the Caml type float.
char_literal [BatGenlex.Languages.Make]
Accepts a character literal, i.e.
chars_of [BatIO]
Read an enumeration of Latin-1 characters.
chmod [BatFile]
choice [BatRandom]
choice e returns a randomly-chosen element of e.
choose [BatSet.S.Exceptionless]
choose [BatSet.S]
Return one element of the given set, or raise Not_found if the set is empty.
choose [BatPSet]
returns one binding of the given map, deterministically.
choose [BatPMap]
returns one pair of the given map, deterministically
choose [BatMap.S]
return an implementation defined (key,value) pair.
choose [BatISet]
chunks_of [BatIO]
Read an input as an enumeration of strings of given maximal length.
classify [BatFloat.Safe_float]
Return the class of the given floating-point number: normal, subnormal, zero, infinite, or not a number.
classify [BatFloat]
Return the class of the given floating-point number: normal, subnormal, zero, infinite, or not a number.
clear [BatUTF8.Buf]
Empty the buffer, but retains the internal storage which was holding the contents
clear [BatRefList]
Removes all elements
clear [BatQueue.Queue]
Discard all elements from a queue.
clear [BatInnerWeaktbl]
Empty a hash table.
clear [BatHashtbl.Cap]
Empty a hash table.
clear [BatHashtbl.S]
clear [BatHashtbl]
Empty a hash table.
clear [BatDynArray]
remove all elements from the array and resize it to 0.
clone [BatEnum]
clone e creates a new enumeration that is copy of e.
clone [BatBitSet]
Same as copy
close_all [BatInnerIO]
Close all outputs.
close_in [BatPervasives]
Close the given channel.
close_in [BatInnerIO]
Close the input.
close_in [BatIO]
Close the input.
close_in_noerr [BatPervasives]
Same as close_in, but ignore all errors.
close_out [BatPervasives]
Close the given channel, flushing all buffered write operations.
close_out [BatInnerIO]
Close the output and return its accumulator data.
close_out [BatIO]
Close the output and return its accumulator data.
close_out_noerr [BatPervasives]
Same as close_out, but ignore all errors.
close_process [BatUnix]
Close input/output opened by Unix.open_process, wait for the associated command to terminate, and return its termination status.
close_process_full [BatUnix]
Close i/o opened by Unix.open_process_full, wait for the associated command to terminate, and return its termination status.
close_process_in [BatUnix]
Close input opened by Unix.open_process_in, wait for the associated command to terminate, and return its termination status.
close_process_out [BatUnix]
Close output opened by Unix.open_process_out, wait for the associated command to terminate, and return its termination status.
clump [BatEnum]
clump size add get e runs add on size (or less at the end) elements of e and then runs get to produce value for the result enumeration.
comb [BatStream]
comb transform a pair of stream into a stream of pairs of corresponding elements.
combine [BatSeq.Exceptionless]
combine [BatSeq]
Transform a pair of sequences into a sequence of pairs.
combine [BatList]
Transform a pair of lists into a list of pairs: combine [a1; ...; an] [b1; ...; bn] is [(a1,b1); ...; (an,bn)].
combine [BatLazyList]
Transform a pair of lists into a list of pairs: combine [a1; ...; an] [b1; ...; bn] is [(a1,b1); ...; (an,bn)].
combine [BatIO]
combine (a,b) creates a new output c such that writing to c will actually write to both a and b
combine [BatEnum]
combine transform a pair of stream into a stream of pairs of corresponding elements.
command [BatArg]
Construct a new command, i.e.
comment [BatGenlex.Languages.Make]
comment_delimiters [BatGenlex.Languages.Definition]
compact [BatDynArray]
compact darr ensures that the space allocated by the array is minimal.
compare [BatUnit]
Compare two units.
compare [BatUTF8]
Code point comparison by lexicographic order.
compare [BatSubstring]
compare (sus1, sus2) performs lexicographic comparison, using the standard ordering Char.compare on the characters.
compare [BatString]
The comparison function for strings, with the same specification as Pervasives.compare.
compare [BatSet.S]
Total ordering between sets.
compare [BatRope]
The comparison function for ropes, with the same specification as Pervasives.compare.
compare [BatPathGen.StringType]
Usual comparison function.
compare [BatPair]
Compare two pairs in lexicographic order, possibly using custom comparators for the two fields
compare [BatNumber.Numeric]
compare [BatNum]
compare [BatNativeint]
The comparison function for native integers, with the same specification as Pervasives.compare.
compare [BatMap.S.Labels]
compare [BatMap.S]
Total ordering between maps.
compare [BatInterfaces.OrderedType]
A total ordering function This is a two-argument function f such that f e1 e2 is zero if the values e1 and e2 are equal, f e1 e2 is strictly negative if e1 is smaller than e2, and f e1 e2 is strictly positive if e1 is greater than e2.
compare [BatInt64]
The comparison function for 64-bit integers, with the same specification as Pervasives.compare.
compare [BatInt32]
The comparison function for 32-bit integers, with the same specification as Pervasives.compare.
compare [BatInt.Safe_int]
The comparison function for integers, with the same specification as Pervasives.compare.
compare [BatInt]
The comparison function for integers, with the same specification as Pervasives.compare.
compare [BatInnerIO.Output]
A total order on outputs
compare [BatInnerIO.Input]
A total order on inputs
compare [BatISet]
compare [BatFloat.Safe_float]
compare [BatFloat]
compare [BatEnum.Labels]
compare [BatEnum]
compare cmp a b compares enumerations a and b by lexicographical order using comparison cmp.
compare [BatComplex]
compare [BatBool]
compare [BatBitSet]
compare s1 s2 compares two bitsets.
compare [BatBig_int]
compare_big_int [BatBig_int]
compare_big_int a b returns 0 if a and b are equal, 1 if a is greater than b, and -1 if a is smaller than b.
compare_index [BatUTF8]
compare_index s i1 i2 returns a value < 0 if i1 is the position located before i2, 0 if i1 and i2 points the same location, a value > 0 if i1 is the position located after i2.
compare_subset [BatSet.S]
Partial ordering between sets as generated by subset
compl [BatISet]
complex32 [BatBigarray]
See Bigarray.char.
complex64 [BatBigarray]
See Bigarray.char.
compose [BatConcurrent]
Compose two lock systems into a third lock system.
concat [BatVect.RANDOMACCESS]
concat [BatVect.Make]
concat r u concatenates the r and u vects.
concat [BatVect]
concat r u concatenates the r and u vects.
concat [BatUTF8]
concat sep [a;b;c...] returns the concatenation of a, sep, b, sep, c, sep...
concat [BatSubstring]
concat suss returns a string consisting of the concatenation of the substrings.
concat [BatStream]
concatenate a stream of streams
concat [BatSeq]
concat s returns the sequence which returns all the elements of all the elements of s, in the same order.
concat [BatRope]
concat sep sl concatenates the list of ropes sl, inserting the separator rope sep between each.
concat [BatPervasives]
concat e returns an enumeration over all elements of all enumerations of e.
concat [BatPathGen.PathType]
concat [BatList]
Concatenate a list of lists.
concat [BatLazyList]
Lazy concatenation of a lazy list of lazy lists
concat [BatEnum]
concat e returns an enumeration over all elements of all enumerations of e.
concat [BatAvlTree]
concat [BatArray.Cap]
Same as Array.append, but concatenates a list of arrays.
concat [BatArray]
Same as Array.append, but concatenates a list of arrays.
concat_with_separators [BatPathGen.StringType]
concat_with_separators sep lst catenates all n elements of lst inserting (n-1) copies of sep in between.
conj [BatComplex]
Conjugate: given the complex x + i.y, returns x - i.y.
cons [BatStream]
cons x stream equals [<'x; stream>].
cons [BatSeq]
cons e s = fun () -> Cons(e, s)
cons [BatParserCo]
cons p q applies parser p then parser q and conses the results into a list.
cons [BatList]
cons h t returns the list starting with h and continuing as t
cons [BatLazyList]
Build a list from a head and a tail.
conservative_exponential_resizer [BatDynArray]
conservative_exponential_resizer is an example resizer function which uses the oldlength parameter.
const [BatStd]
Ignore its second argument.
const [BatPervasives]
Ignore its second argument.
contains [BatUTF8]
As String.contains
contains [BatRope]
contains s c tests if character c appears in the rope s.
contains_from [BatUTF8]
contains_from [BatRope]
contains_from s start c tests if character c appears in the subrope of s starting from start to the end of s.
contents [BatUTF8.Buf]
contents buf returns the contents of the buffer.
copy [BatVect.RANDOMACCESS]
copy [BatRefList]
Makes a copy of a ref list - O(1)
copy [BatRef]
copy r returns a new reference with the same initial content as r.
copy [BatRandom.State]
Return a copy of the given state.
copy [BatQueue.Queue]
Return a copy of the given queue.
copy [BatOo.Oo.Internal]
copy [BatOo.Oo]
Oo.copy o returns a copy of object o, that is a fresh object with the same methods and instance variables as o
copy [BatInnerWeaktbl]
Return a copy of the given hashtable.
copy [BatIO]
Read everything from an input and copy it to an output.
copy [BatHashtbl.Cap]
Return a copy of the given hashtable.
copy [BatHashtbl.S]
copy [BatHashtbl]
Return a copy of the given hashtable.
copy [BatDynArray]
copy src returns a fresh copy of src, such that no modification of src affects the copy, or vice versa (all new memory is allocated for the copy).
copy [BatDllist]
Copy the list attached to the given node and return the copy of the given node.
copy [BatBitSet]
Copy a bitset : further modifications of first one will not affect the copy.
copy [BatArray.Cap]
Array.copy a returns a copy of a, that is, a fresh array containing the same elements as a.
copy [BatArray]
Array.copy a returns a copy of a, that is, a fresh array containing the same elements as a.
copy_enum [BatRefList]
Makes a copy of a enum.
copy_list [BatRefList]
Makes a copy of a list - O(1)
cos [BatFloat.Safe_float]
cos [BatFloat]
cosh [BatFloat.Safe_float]
cosh [BatFloat]
count [BatEnum]
count e returns the number of remaining elements in e without consuming the enumeration.
count [BatBitSet]
count s returns the number of bits set in the bitset s.
count_option [BatOptParse.StdOpt]
Create a counting option which increments its value each time the option is encountered on the command line.
create [BatUTF8.Buf]
create n creates the buffer with the initial size n-bytes.
create [BatSubstring]
create [BatRMutex]
Return a new mutex.
create [BatQueue.Queue]
Return a new queue, initially empty.
create [BatPSet]
Creates a new empty set, using the provided function for key comparison.
create [BatPMap]
creates a new empty map, using the provided function for key comparison.
create [BatMutex.Mutex]
Return a new mutex.
create [BatMultiPMap]
creates a new empty map, using the provided function for key comparison.
create [BatInnerWeaktbl]
Weaktbl.create n creates a new, empty hash table, with initial size n.
create [BatHashtbl.Cap]
Hashtbl.create n creates a new, empty hash table, with initial size n.
create [BatHashtbl.S]
create [BatHashtbl]
Hashtbl.create n creates a new, empty hash table, with initial size n.
create [BatDynArray]
create() returns a new empty dynamic array.
create [BatDllist]
Creates a node.
create [BatConcurrent.BaseLock]
create [BatConcurrent.Lock]
create [BatConcurrent]
Create a lock from a pair of locking/unlocking functions
create [BatBitSet]
Create an empty bitset with an initial size (in number of bits).
create [BatBigarray.Array3]
Array3.create kind layout dim1 dim2 dim3 returns a new bigarray of three dimension, whose size is dim1 in the first dimension, dim2 in the second dimension, and dim3 in the third.
create [BatBigarray.Array2]
Array2.create kind layout dim1 dim2 returns a new bigarray of two dimension, whose size is dim1 in the first dimension and dim2 in the second dimension.
create [BatBigarray.Array1]
Array1.create kind layout dim returns a new bigarray of one dimension, whose size is dim.
create [BatBigarray.Genarray]
Genarray.create kind layout dimensions returns a new big array whose element kind is determined by the parameter kind (one of float32, float64, int8_signed, etc) and whose layout is determined by the parameter layout (one of c_layout or fortran_layout).
create [BatArray.Labels]
create [BatArray.Cap.Labels]
create [BatArray.Cap]
create [BatArray]
create_full [BatBitSet]
Create a full bitset with an initial size (in number of bits).
create_in [BatInnerIO]
Fully create an input by giving all the needed functions.
create_in [BatIO]
Fully create an input by giving all the needed functions.
create_matrix [BatArray.Labels]
create_matrix [BatArray.Cap.Labels]
create_matrix [BatArray.Cap]
create_matrix [BatArray]
create_object [BatOo.Oo.Internal]
create_object_and_run_initializers [BatOo.Oo.Internal]
create_object_opt [BatOo.Oo.Internal]
create_out [BatInnerIO]
Fully create an output by giving all the needed functions.
create_out [BatIO]
Fully create an output by giving all the needed functions.
create_table [BatOo.Oo.Internal]
curry [BatStd]
Turn a function that takes a pair into a function that takes its arguments one at a time.
curry [BatPervasives]
Convert a function which accepts a pair of arguments into a function which accepts two arguments.
cycle [BatEnum]
cycle is similar to repeat, except that the content to fill is a subenum rather than a single element.

D
dbg_formatter [BatLogger]
dbg_formatter is a debug formatter that outputs log events to stderr using the same format as make_dbg_formatter.
debug_mode [BatParserCo]
If set to true, debugging information will be printed to the standard error.
decode [BatBase64]
Generic base64 decoding over an input.
decorate_fast_sort [BatArray]
As Array.decorate_sort, but uses fast_sort internally
decorate_stable_sort [BatArray]
decorate_sort f a returns a sorted copy of a such that if f x < f y then x is earlier in the result than y.
decr_option [BatOptParse.StdOpt]
Exactly identical to count_option ~dest:dest ~increment:(-1) ().
default [BatOption]
default x (Some v) returns v and default x None returns x.
default_buffer_size [BatInnerIO]
The default size of buffers.
default_buffer_size [BatIO]
The default size for internal buffers.
default_permission [BatFile]
Default permissions.
default_resizer [BatDynArray]
The default resizer function the library is using - in this version of DynArray, this is the exponential_resizer but should change in next versions.
default_validator [BatPathGen.PathType]
Forward slash and code zero are considered invalid.
delay [BatEnum]
delay (fun () -> e) produces an enumeration which behaves as e.
delete [BatDynArray]
delete darr idx deletes the element of darr at idx.
delete_last [BatDynArray]
delete_last darr deletes the last element of darr.
delete_range [BatDynArray]
delete_range darr p len deletes len elements starting at index p.
demote [BatDllist]
demote n Swaps n with prev n.
descr_of_in_channel [BatUnix]
descr_of_input [BatUnix]
Return the descriptor corresponding to an input.
descr_of_out_channel [BatUnix]
descr_of_output [BatUnix]
Return the descriptor corresponding to an output.
destructive_set [BatVect]
destructive_set n e v sets the element of index n in the v vect to e.
diff [BatSet.S]
Set difference.
diff [BatISet]
diff [BatBitSet]
diff s t returns s-t.
differentiate [BatBitSet]
differentiate s t removes the elements of t from s.
differentiate_sym [BatBitSet]
differentiate_sym s t sets s to the symmetrical difference of the sets s and t.
digit [BatUCharParser]
Recognizes one decimal digit
digit [BatCharParser]
Recognizes one decimal digit
dim [BatBigarray.Array1]
Return the size (dimension) of the given one-dimensional big array.
dim1 [BatBigarray.Array3]
Return the first dimension of the given three-dimensional big array.
dim1 [BatBigarray.Array2]
Return the first dimension of the given two-dimensional big array.
dim2 [BatBigarray.Array3]
Return the second dimension of the given three-dimensional big array.
dim2 [BatBigarray.Array2]
Return the second dimension of the given two-dimensional big array.
dim3 [BatBigarray.Array3]
Return the third dimension of the given three-dimensional big array.
dims [BatBigarray.Genarray]
Genarray.dims a returns all dimensions of the big array a, as an array of integers of length Genarray.num_dims a.
div [BatNumber.Numeric]
div [BatNum]
div [BatNativeint]
Integer division.
div [BatInt64]
Integer division.
div [BatInt32]
Integer division.
div [BatInt.Safe_int]
Integer division.
div [BatInt]
Integer division.
div [BatFloat.Safe_float]
div [BatFloat]
div [BatComplex]
Division
div [BatBool]
div [BatBig_int]
documentation_root [Batteries_config]
A path to the root of the documentation.
domain [BatIMap]
doubles_of [BatIO.BigEndian]
Read an enumeration of IEEE double precision floating point values.
doubles_of [BatIO]
Read an enumeration of IEEE double precision floating point values.
drive_letter [BatPathGen.PathType]
Return drive letter of the given absolute path.
drop [BatStream]
drop n stream returns the suffix of stream after the first n elements, or a empty stream if n is greater than the length of stream
drop [BatSeq]
drop n s returns s without the first n elements, or the empty sequence if s have less than n elements.
drop [BatList]
drop n l returns l without the first n elements, or the empty list if l have less than n elements.
drop [BatLazyList]
drop n l returns l without the first n elements, or the empty list if l have less than n elements.
drop [BatEnum]
drop n e removes the first n element from the enumeration, if any.
drop [BatDllist]
Remove node from the list no matter where it is.
drop_bits [BatIO]
Drop up to 7 buffered bits and restart to next input character.
drop_while [BatStream.StreamLabels]
drop_while test stream returns the remaining suffix of take_while test stream.
drop_while [BatStream]
drop_while test stream returns the remaining suffix of take_while test stream.
drop_while [BatSeq]
drop_while f s returns the sequence s with the first elements satisfying the predicate f dropped.
drop_while [BatList.Labels]
drop_while [BatList]
dropwhile f xs returns the list xs with the first elements satisfying the predicate f dropped.
drop_while [BatLazyList.Labels]
drop_while [BatLazyList]
drop_while f xs returns the list xs with the first elements satisfying the predicate f dropped.
drop_while [BatEnum.Labels]
drop_while [BatEnum]
drop_while p e produces a new enumeration in which only all the first elements such that f e have been junked.
dropl [BatSubstring]
dropl p sus drops the longest prefix (left substring) of sus all of whose characters satisfy predicate p.
dropr [BatSubstring]
dropr p sus drops the longest suffix (right substring) of sus all of whose characters satisfy predicate p.
dropwhile [BatList]
obsolete, as BatList.drop_while
dummy_class [BatOo.Oo.Internal]
dummy_table [BatOo.Oo.Internal]
dump [BatStd]
represent a runtime value as a string.
dump [BatPervasives]
Attempt to convert a value to a string.
dup [BatStream]
dup stream returns a pair of streams which are identical to stream.
dup [BatEnum]
dup stream returns a pair of streams which are identical to stream.

E
eager_append [BatLazyList]
Evaluate a list and append another list after this one.
eager_of_list [BatLazyList]
Eager conversion from lists.
either [BatParserCo]
Accept one of several parsers.
elements [BatSet.S]
Return the list of all elements of the given set.
elements [BatISet]
empty [BatVect.RANDOMACCESS]
empty [BatVect.Make]
The empty vect.
empty [BatVect]
The empty vect.
empty [BatUTF8]
The empty UTF8 string
empty [BatSubstring]
empty [BatSet.S]
The empty set.
empty [BatRope]
The empty rope.
empty [BatRefList]
Returns a new empty ref list
empty [BatPSet]
The empty set, using compare as comparison function
empty [BatPMap]
The empty map, using compare as key comparison function.
empty [BatMultiPMap]
The empty map, using compare as key comparison function.
empty [BatMap.S]
The empty map.
empty [BatISet]
empty [BatIMap]
empty [BatGlobal]
Returns an new named empty global.
empty [BatEnum]
The empty enumeration : contains no element
empty [BatDynArray]
Return true if the number of elements in the array is 0.
empty [BatBitSet]
Create an empty bitset of size 0, the bitset will automatically expand when needed.
empty [BatAvlTree]
encode [BatBase64]
Generic base64 encoding over an output.
encoded_as [BatCharEncodings]
encoded_as t returns the x such that t = as_encoded x enc.
encoding_of_t [BatCharEncodings]
Return the encoding of a t.
end_of_input [BatScanf.Scanning]
Scanning.end_of_input ib tests the end-of-input condition of the given scanning buffer.
ends_with [BatString]
ends_with s x returns true if the string s is ending with x, false otherwise.
ends_with [BatRope]
ends_with s x returns true if the rope s is ending with x, false otherwise.
enum [BatVect.RANDOMACCESS]
enum [BatVect]
Returns an enumeration of the elements of the vector.
enum [BatUTF8]
As String.enum
enum [BatString]
Conversions
enum [BatStream]
Convert an enumeration to a stream.
enum [BatStack]
enum s returns a destructive enumeration of the elements of stack s, from the most recently entered to the least recently entered.
enum [BatSet.S]
Return an enumeration of all elements of the given set.
enum [BatSeq]
enum s returns the enumeration of all element of s.
enum [BatRope]
Returns an enumeration of the characters of a rope.
enum [BatRefList]
Returns an enumeration of current elements in the ref list
enum [BatQueue.Queue]
enum q returns a destructive enumeration of the elements of queue q, from the least recently entered to the most recently entered.
enum [BatPair]
builds a two-element enum of a pair
enum [BatPSet]
Return an enumeration of all elements of the given set.
enum [BatPMap]
creates an enumeration for this map.
enum [BatOption]
enum (Some x) returns the singleton x, while enum None returns the empty enumeration
enum [BatMultiPMap]
creates an enumeration for this map.
enum [BatMap.S]
Return an enumeration of (key, value) pairs of a map.
enum [BatList]
Returns an enumeration of the elements of a list.
enum [BatLazyList]
Lazy conversion to enumeration
enum [BatISet]
enum [BatIMap]
enum [BatHashtbl.Cap]
Return an enumeration of (key,value) pairs of a hashtable.
enum [BatHashtbl.S]
enum [BatHashtbl]
Return an enumeration of (key,value) pairs of a hashtable.
enum [BatEnum.Enumerable]
Return an enumeration of the elements of the data structure
enum [BatEnum]
identity : added for consistency with the other data structures
enum [BatDynArray]
enum darr returns the enumeration of darr elements.
enum [BatDllist]
Create an enum of the list.
enum [BatChar]
Produce the enumeration of all characters
enum [BatBuffer]
Returns an enumeration of the characters of a buffer.
enum [BatBitSet]
enum s returns an enumeration of bits which are set in the bitset s.
enum [BatBigarray.Array3]
enum e returns an enumeration on the elements of e.
enum [BatBigarray.Array2]
enum e returns an enumeration on the elements of e.
enum [BatBigarray.Array1]
enum e returns an enumeration on the elements of e.
enum [BatBigarray.Genarray]
enum e returns an enumeration on the elements of e.
enum [BatAvlTree]
enum [BatArray.Cap]
Returns an enumeration of the elements of an array.
enum [BatArray]
Returns an enumeration of the elements of an array.
enum_bits [BatRandom.State]
enum_bits [BatRandom]
enum_bool [BatRandom.State]
enum_bool [BatRandom]
enum_char [BatRandom.State]
enum_char [BatRandom]
enum_float [BatRandom.State]
enum_float [BatRandom]
enum_int [BatRandom.State]
enum_int [BatRandom]
enum_int32 [BatRandom.State]
enum_int32 [BatRandom]
enum_int64 [BatRandom.State]
enum_int64 [BatRandom]
enum_nativeint [BatRandom.State]
enum_nativeint [BatRandom]
eof [BatParserCo]
Accept the end of an enumeration.
eprintf [BatPrintf]
The usual eprintf function, prints to the standard error output stderr, used to display warnings and errors.
eprintf [BatPrint]
eprintf fmt args behaves as printf fmt args but prints the result on the error out put BatIO.stderr rather on the screen.
eprintf [BatInnerIO.Printf]
The usual eprintf function, prints to the standard error output BatInnerIO.stderr, used to display warnings and errors.
epsilon [BatFloat.Safe_float]
The smallest positive float x such that 1.0 +. x <> 1.0.
epsilon [BatFloat]
The smallest positive float x such that 1.0 +. x <> 1.0.
eq_big_int [BatBig_int]
eq_num [BatNum]
equal [BatSet.S]
equal s1 s2 tests whether the sets s1 and s2 are equal, that is, contain equal elements.
equal [BatMap.S.Labels]
equal [BatMap.S]
equal cmp m1 m2 tests whether the maps m1 and m2 are equal, that is, contain equal keys and associate them with equal data.
equal [BatInnerIO.Output]
equal [BatInnerIO.Input]
equal [BatISet]
equal [BatHashtbl.HashedType]
The equality predicate used to compare keys.
equals [BatBitSet]
equals s1 s2 returns true if, and only if, all bits values in s1 are the same as in s2.
err_formatter [BatFormat]
A formatter to use with formatting functions below for output to standard error.
error [BatOptParse.OptParser]
Display an error message and exit the program.
escaped [BatUTF8]
escaped [BatRope]
Return a copy of the argument, with special characters represented by escape sequences, following the lexical conventions of Objective Caml.
establish_server [BatUnix]
Establish a server on the given address.
eternity [BatLazyList]
An infinite list of nothing
exactly [BatParserCo]
Singletons
exe [BatStd]
The name of the current executable.
exe [BatPervasives]
The name of the current executable.
exists [BatVect]
exists p [a1; ...; an] checks if at least one element of the array satisfies the predicate p.
exists [BatString]
exists str sub returns true if sub is a substring of str or false otherwise.
exists [BatSet.S.Labels]
exists [BatSet.S]
exists p s checks if at least one element of the set satisfies the predicate p.
exists [BatSeq]
exists p (cons a1 (... an)) checks if at least one element of the sequence satisfies the predicate p.
exists [BatRope]
exists str sub returns true if sub is a subrope of str or false otherwise.
exists [BatRefList]
Return true if an element matches the specified predicate
exists [BatPervasives]
exists f e returns true if there is some x in e such that f x
exists [BatPSet]
exists p s checks if at least one element of the set satisfies the predicate p.
exists [BatPMap]
same as mem.
exists [BatList.Labels]
exists [BatLazyList.Labels]
exists [BatLazyList]
Eager existential.
exists [BatISet]
exists [BatEnum.Labels]
exists [BatEnum]
exists f e returns true if there is some x in e such that f x
exists [BatDllist]
exists [BatArray.Labels]
exists [BatArray.Cap.Labels]
exists [BatArray.Cap]
exists p [a1; ...; an] checks if at least one element of the array satisfies the predicate p.
exists [BatArray]
exists p [a1; ...; an] checks if at least one element of the array satisfies the predicate p.
exists2 [BatList.Labels]
exists2 [BatList]
Same as List.exists, but for a two-argument predicate.
exists2 [BatLazyList.Labels]
exists2 [BatLazyList]
Same as BatLazyList.exists, but for a two-argument predicate.
exists2 [BatArray]
As Array.exists but on two arrays.
exists_f [BatPMap]
Tests whether some key value pair satisfies some predicate function
exp [BatFloat.Safe_float]
Exponential.
exp [BatFloat]
Exponential.
exp [BatComplex]
Exponentiation.
explode [BatSubstring]
explode sus returns the list of characters of sus, that is, s(i), s(i+1), ..., s(i+n-1) where sus = (s, i, n).
explode [BatString]
explode s returns the list of characters in the string s.
explode [BatRope]
explode s returns the list of characters in the rope s.
exponential_resizer [BatDynArray]
The exponential resizer- The default resizer except when the resizer is being copied from some other darray.
ext [BatPathGen.PathType]
Returns extension of the name of the object the pathname points to.
extract [BatSubstring]
extract(s, i, NONE) creates the substring (s, i, size s-i) consisting of the tail of s starting at i.
extract [BatPMap]
extract k m removes the current binding of k from m, returning the value k was bound to and the updated m.

F
fail [BatParserCo]
Always fail, without consuming anything.
fast_count [BatEnum]
For users worried about the speed of count you can call the fast_count function that will give an hint about count implementation.
fast_sort [BatList.Labels]
fast_sort [BatArray.Labels]
fast_sort [BatArray.Cap.Labels]
fast_sort [BatArray.Cap]
Same as Array.sort or Array.stable_sort, whichever is faster on typical input.
fast_sort [BatArray]
Same as Array.sort or Array.stable_sort, whichever is faster on typical input.
fatal [BatParserCo]
feed [BatGenlex.Languages.Make]
Drop comments, present reserved operators and reserved names as Kwd, operators and identifiers as Ident, integer numbers as Int, floating-point numbers as Float and characters as Char.
fields [BatSubstring]
fields p sus returns the list of fields in sus, from left to right, where a field is a (possibly empty) maximal substring of sus not containing any delimiter, and a delimiter is a character satisfying p.
files_of [BatSys]
As readdir but the results are presented as an enumeration of names.
fill [BatRope]
fill s start len c returns the rope in which characters number start to start + len - 1 of s has been replaced by c.
fill [BatOptParse.Formatter]
See OptParse.Formatter.wrap.
fill [BatBigarray.Array3]
Fill the given big array with the given value.
fill [BatBigarray.Array2]
Fill the given big array with the given value.
fill [BatBigarray.Array1]
Fill the given big array with the given value.
fill [BatBigarray.Genarray]
Set all elements of a big array to a given value.
fill [BatArray.Labels]
fill [BatArray.Cap.Labels]
fill [BatArray.Cap]
Array.fill a ofs len x modifies the array a in place, storing x in elements number ofs to ofs + len - 1.
fill [BatArray]
Array.fill a ofs len x modifies the array a in place, storing x in elements number ofs to ofs + len - 1.
filter [BatVect.Make]
filter f v returns a vect with the elements x from v such that f x returns true.
filter [BatVect]
filter f v returns a vect with the elements x from v such that f x returns true.
filter [BatUTF8]
As String.filter
filter [BatString]
filter f s returns a copy of string s in which only characters c such that f c = true remain.
filter [BatStream.StreamLabels]
filter test stream picks all the elements satisfying test from stream and return the results in the same order as a stream.
filter [BatStream]
filter test stream picks all the elements satisfying test from stream and return the results in the same order as a stream.
filter [BatSet.S.Labels]
filter [BatSet.S]
filter p s returns the set of all elements in s that satisfy predicate p.
filter [BatSeq]
filter p s returns the sequence of elements of s satisfying p.
filter [BatRope]
filter f s returns a copy of rope s in which only characters c such that f c = true remain.
filter [BatRefList]
Remove all elements that do not match the specified predicate
filter [BatPervasives]
filter f e returns an enumeration over all elements x of e such as f x returns true.
filter [BatParserCo]
filter f p is only accepts values x such that p accepts x and f (p x) is true
filter [BatPSet]
filter p s returns the set of all elements in s that satisfy predicate p.
filter [BatPMap]
filter f m returns a map where only the values a of m such that f a = true remain.
filter [BatMap.S.Labels]
filter [BatMap.S]
filter f m returns a map where only the values a of m such that f a = true remain.
filter [BatList.Labels]
filter [BatList]
filter p l returns all the elements of the list l that satisfy the predicate p.
filter [BatLazyList.Labels]
filter [BatLazyList]
Lazy filtering.
filter [BatISet]
filter [BatHashtbl.Cap]
filter f m returns a new hashtable where only the values a of m such that f a = true remain.
filter [BatHashtbl.S.Labels]
filter [BatHashtbl.S]
filter [BatHashtbl.Labels]
filter [BatHashtbl]
filter f m returns a new hashtable where only the values a of m such that f a = true remain.
filter [BatEnum.Labels]
filter [BatEnum]
filter f e returns an enumeration over all elements x of e such as f x returns true.
filter [BatDynArray]
filter p a returns all the elements of the array a that satisfy the predicate p.
filter [BatDllist]
filter p l returns a new list, with entirely new nodes, whose values are all the elements of the list l that satisfy the predicate p.
filter [BatArray.Labels]
filter [BatArray.Cap.Labels]
filter [BatArray.Cap]
filter p a returns all the elements of the array a that satisfy the predicate p.
filter [BatArray]
filter p a returns all the elements of the array a that satisfy the predicate p.
filter_map [BatVect.Make]
filter_map f e returns a vect consisting in all elements x such that f y returns Some x , where y is an element of e.
filter_map [BatVect]
filter_map f e returns a vect consisting in all elements x such that f y returns Some x , where y is an element of e.
filter_map [BatUTF8]
As String.filter_map
filter_map [BatString]
filter_map f s calls (f a0) (f a1).... (f an) where a0..an are the characters of s.
filter_map [BatSet.S.Labels]
filter_map [BatSet.S]
filter_map f m combines the features of filter and map.
filter_map [BatSeq]
filter_map f s returns the sequence of elements filtered and mapped by f.
filter_map [BatRope]
filter_map f l calls (f a0) (f a1).... (f an) where a0..an are the characters of l.
filter_map [BatPSet]
filter_map f m combines the features of filter and map.
filter_map [BatPMap]
filter_map f m combines the features of filteri and map.
filter_map [BatMap.S]
filter_map f m combines the features of filteri and map.
filter_map [BatList.Labels]
filter_map [BatList]
filter_map f l calls (f a0) (f a1).... (f an) where a0..an are the elements of l.
filter_map [BatLazyList.Labels]
filter_map [BatLazyList]
Lazily eliminate some elements and transform others.
filter_map [BatHashtbl.Cap]
filter_map f m combines the features of filteri and map.
filter_map [BatHashtbl.S.Labels]
filter_map [BatHashtbl.S]
filter_map [BatHashtbl.Labels]
filter_map [BatHashtbl]
filter_map f m combines the features of filteri and map.
filter_map [BatEnum.Labels]
filter_map [BatEnum]
filter_map f e returns an enumeration over all elements x such as f y returns Some x , where y is an element of e.
filter_map [BatDynArray]
filter_map f e returns an array consisting in all elements x such that f y returns Some x , where y is an element of e.
filter_map [BatDllist]
filter_map f l calls (f a0) (f a1).... (f an) where a0..an are the elements of l.
filter_map [BatArray.Labels]
filter_map [BatArray.Cap.Labels]
filter_map [BatArray.Cap]
filter_map f e returns an array consisting in all elements x such that f y returns Some x , where y is an element of e.
filter_map [BatArray]
filter_map f e returns an array consisting in all elements x such that f y returns Some x , where y is an element of e.
filteri [BatPMap]
filter f m returns a map where only the (key, value) pairs key, a of m such that f key a = true remain.
filteri [BatMap.S.Labels]
filteri [BatMap.S]
filter f m returns a map where only the key, values pairs key, a of m such that f key a = true remain.
filteri [BatHashtbl.Cap]
filter f m returns a map where only the key, values pairs key, a of m such that f key a = true remain.
filteri [BatHashtbl.S.Labels]
filteri [BatHashtbl.S]
filteri [BatHashtbl.Labels]
filteri [BatHashtbl]
filter f m returns a map where only the key, values pairs key, a of m such that f key a = true remain.
finally [BatStd]
finally fend f x calls f x and then fend() even if f x raised an exception.
finally [BatPervasives]
finally fend f x calls f x and then fend() even if f x raised an exception.
find [BatVect]
find p a returns the first element of array a that satisfies the predicate p.
find [BatString]
find s x returns the starting index of the first occurrence of string x within string s.
find [BatSeq]
find p s returns the first element of s such as p e returns true, if any.
find [BatRope]
find s x returns the starting index of the first occurrence of rope x within rope s.
find [BatRefList]
Find the first element matching the specified predicate raise Not_found if no element is found
find [BatPervasives]
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.
find [BatPMap]
find x m returns the current binding of x in m, or raises Not_found if no such binding exists.
find [BatMultiPMap]
find x m returns the current binding of x in m
find [BatMap.S.Exceptionless]
find [BatMap.S]
find x m returns the current binding of x in m, or raises Not_found if no such binding exists.
find [BatList.Labels.LExceptionless]
find [BatList.Labels]
find [BatList.Exceptionless]
find p l returns Some x where x is the first element of l such as p x returns true or None if such an element has not been found.
find [BatLazyList.Labels.Exceptionless]
find [BatLazyList.Labels]
find [BatLazyList.Exceptionless]
rfind p l returns Some x where x is the first element of l such that p x returns true or None if such element as not been found.
find [BatLazyList]
find p l returns the first element of l such as p x returns true or raises Not_found if such an element has not been found.
find [BatInnerWeaktbl]
Weaktbl.find tbl x returns the current binding of x in tbl, or raises Not_found if no such binding exists.
find [BatIMap]
find [BatHashtbl.Cap.Exceptionless]
find [BatHashtbl.Cap]
Hashtbl.find tbl x returns the current binding of x in tbl, or raises Not_found if no such binding exists.
find [BatHashtbl.S.Exceptionless]
find [BatHashtbl.S]
find [BatHashtbl.Exceptionless]
find [BatHashtbl]
Hashtbl.find tbl x returns the current binding of x in tbl, or raises Not_found if no such binding exists.
find [BatEnum.Labels.LExceptionless]
find [BatEnum.Labels]
find [BatEnum.Exceptionless]
find f e returns Some x where x is the first element x of e such that f x returns true, consuming the enumeration up to and including the found element, or None if no such element exists in the enumeration, consuming the whole enumeration in the search.
find [BatEnum]
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.
find [BatArray.Labels.LExceptionless]
find [BatArray.Labels]
find [BatArray.Exceptionless]
find p a returns Some x, where x is the first element of array a that satisfies the predicate p, or None if there is no such element.
find [BatArray.Cap.Labels]
find [BatArray.Cap.Exceptionless]
find p a returns Some x, where x is the first element of array a that satisfies the predicate p, or None if there is no such element.
find [BatArray.Cap]
find p a returns the first element of array a that satisfies the predicate p.
find [BatArray]
find p a returns the first element of array a that satisfies the predicate p.
find_all [BatVect.Make]
find_all is another name for Array.filter.
find_all [BatVect]
find_all is another name for Array.filter.
find_all [BatList.Labels]
find_all [BatList]
find_all is another name for List.filter.
find_all [BatInnerWeaktbl]
Weaktbl.find_all tbl x returns the list of all data associated with x in tbl.
find_all [BatHashtbl.Cap]
Hashtbl.find_all tbl x returns the list of all data associated with x in tbl.
find_all [BatHashtbl.S]
find_all [BatHashtbl]
Hashtbl.find_all tbl x returns the list of all data associated with x in tbl.
find_all [BatArray.Cap]
find_all is another name for Array.filter.
find_all [BatArray]
find_all is another name for Array.filter.
find_default [BatHashtbl.Cap]
Find a binding for the key, and return a default value if not found
find_default [BatHashtbl.S]
find_default [BatHashtbl]
Find a binding for the key, and return a default value if not found
find_exc [BatRefList]
Same as find but takes an exception to be raised when no element is found as additional parameter
find_exn [BatList.Labels]
find_exn [BatList]
find_exn p e l returns the first element of l such as p x returns true or raises e if such an element has not been found.
find_exn [BatLazyList.Labels]
find_exn [BatLazyList]
find_exn p e l returns the first element of l such as p x returns true or raises e if such an element has not been found.
find_from [BatString]
find_from s ofs x behaves as find s x but starts searching at offset ofs.
find_from [BatRope]
find_from s ofs x behaves as find s x but starts searching at offset ofs.
find_map [BatSeq]
find_map p s finds the first element of s for which p e returns Some r, if any.
find_map [BatList]
find_map pred list finds the first element of list for which pred element returns Some r.
find_option [BatHashtbl.Cap]
Find a binding for the key, or return None if no value is found
find_option [BatHashtbl.S]
find_option [BatHashtbl]
Find a binding for the key, or return None if no value is found
findi [BatVect]
findi p a returns the index of the first element of array a that satisfies the predicate p.
findi [BatList.Labels.LExceptionless]
findi [BatList.Labels]
findi [BatList.Exceptionless]
findi p e l returns Some (i, ai) where ai and i are respectively the first element of l and its index, such that p i ai is true, or None if no such element has been found.
findi [BatList]
findi p e l returns the first element ai of l along with its index i such that p i ai is true, or raises Not_found if no such element has been found.
findi [BatLazyList.Labels.Exceptionless]
findi [BatLazyList.Labels]
findi [BatLazyList.Exceptionless]
findi p e l returns Some (i, ai) where ai and i are respectively the first element of l and its index, such that p i ai is true, or None if no such element has been found.
findi [BatLazyList]
findi p e l returns the first element ai of l along with its index i such that p i ai is true, or raises Not_found if no such element has been found.
findi [BatArray.Labels.LExceptionless]
findi [BatArray.Labels]
findi [BatArray.Exceptionless]
findi p a returns Some n, where n is the index of the first element of array a that satisfies the predicate p, or None if there is no such element.
findi [BatArray.Cap.Exceptionless]
findi p a returns Some n, where n is the index of the first element of array a that satisfies the predicate p, or None if there is no such element.
findi [BatArray.Cap]
findi p a returns the index of the first element of array a that satisfies the predicate p.
findi [BatArray]
findi p a returns the index of the first element of array a that satisfies the predicate p.
first [BatVect]
Convenience Functions
first [BatUTF8.Byte]
first [BatSubstring]
first sus returns SOME c where c is the first character in sus, if sus is non-empty; otherwise returns NONE.
first [BatStd]
Projection of a pair to its first element.
first [BatSeq.Exceptionless]
first [BatSeq]
Same as BatSeq.hd
first [BatRefList]
Returns the first element or raises Empty_list if the ref list is empty
first [BatPervasives]
Apply a function to the first element of a pair.
first [BatList]
Returns the first element of the list, or raise Empty_list if the list is empty (similar to hd).
first [BatLazyList]
As hd
first_chars [BatStr.Str]
first_chars s n returns the first n characters of s.
flatten [BatSeq]
Same as BatSeq.concat.
flatten [BatList]
Same as concat.
flatten [BatLazyList]
Lazy concatenation of a list of lazy lists
flatten [BatEnum]
Synonym of BatEnum.concat
flip [BatStd]
Argument flipping.
flip [BatPervasives]
Argument flipping.
float [BatRandom.State]
float [BatRandom]
Random.float bound returns a random floating-point number between 0 (inclusive) and bound (exclusive).
float [BatGenlex.Languages.Make]
Parse a floating-point number.
float32 [BatBigarray]
See Bigarray.char.
float64 [BatBigarray]
See Bigarray.char.
float_callback [BatOptParse.StdOpt]
See OptParse.StdOpt.int_callback.
float_of_big_int [BatBig_int]
Returns a floating-point number approximating the given big integer.
float_of_bits [BatInt64]
Return the floating-point number whose internal representation, according to the IEEE 754 floating-point ``double format'' bit layout, is the given int64.
float_of_bits [BatInt32]
Return the floating-point number whose internal representation, according to the IEEE 754 floating-point ``single format'' bit layout, is the given int32.
float_of_num [BatNum]
float_option [BatOptParse.StdOpt]
See OptParse.StdOpt.int_option.
floor [BatNum]
floor [BatFloat.Safe_float]
Round the given float to an integer value.
floor [BatFloat]
Round the given float to an integer value.
flush [BatPervasives]
Flush the buffer associated with the given output, performing all pending writes on that channel.
flush [BatInnerIO]
Flush an output.
flush [BatIO]
Flush an output.
flush_all [BatPervasives]
Write all pending data to output channels, ignore all errors.
flush_all [BatInnerIO]
Flush all outputs.
flush_all [BatIO]
Flush all outputs, ignore errors.
flush_bits [BatIO]
Flush remaining unwritten bits, adding up to 7 bits which values 0.
fold [BatVect.Make]
as fold_left
fold [BatVect]
fold f a r computes f (... (f (f a r0) r1)...) rN-1 where rn = Vect.get n r and N = length r.
fold [BatStream.StreamLabels]
fold is foldl without initialization value, where the first element of stream is taken as init.
fold [BatStream]
fold is foldl without initialization value, where the first element of stream is taken as init.
fold [BatSet.S.Labels]
fold [BatSet.S]
fold f s a computes (f xN ... (f x2 (f x1 a))...), where x1 ... xN are the elements of s, in increasing order.
fold [BatRope]
Rope.fold f a r computes f (... (f (f a r0) r1)...) rN-1 where rn = Rope.get n r and N = length r.
fold [BatQueue.Queue]
fold f accu q is equivalent to List.fold_left f accu l, where l is the list of q's elements.
fold [BatPervasives]
Transformation loop on an enumeration, used to build a single value from an enumeration.
fold [BatPSet]
fold f s a computes (f xN ... (f x2 (f x1 a))...), where x1 ... xN are the elements of s, in increasing order.
fold [BatPMap]
fold f m a computes (f kN dN ... (f k1 d1 a)...), where k1 ... kN are the keys of all bindings in m, and d1 ... dN are the associated data.
fold [BatMultiPMap]
fold f m a computes (f kN dN ... (f k1 d1 a)...), where k1 ... kN are the keys of all bindings in m, and d1 ... dN are the associated data.
fold [BatMap.S.Labels]
fold [BatMap.S]
fold f m a computes (f kN dN ... (f k1 d1 a)...), where k1 ... kN are the keys of all bindings in m (in increasing order), and d1 ... dN are the associated data.
fold [BatInnerWeaktbl]
Weaktbl.fold f tbl init computes (f kN dN ... (f k1 d1 init)...), where k1 ... kN are the keys of all bindings in tbl, and d1 ... dN are the associated values.
fold [BatISet]
fold [BatIMap]
fold [BatHashtbl.Cap.Labels]
fold [BatHashtbl.Cap]
Hashtbl.fold f tbl init computes (f kN dN ... (f k1 d1 init)...), where k1 ... kN are the keys of all bindings in tbl, and d1 ... dN are the associated values.
fold [BatHashtbl.S.Labels]
fold [BatHashtbl.S]
fold [BatHashtbl.Labels]
fold [BatHashtbl]
Hashtbl.fold f tbl init computes (f kN dN ... (f k1 d1 init)...), where k1 ... kN are the keys of all bindings in tbl, and d1 ... dN are the associated values.
fold [BatEnum.Labels]
fold [BatEnum]
A general loop on an enumeration.
fold [BatAvlTree]
fold2 [BatEnum.Labels]
fold2 [BatEnum]
fold2 is similar to fold but will fold over two enumerations at the same time until one of the two enumerations ends.
fold2_range [BatIMap]
fold2i [BatEnum.Labels]
fold2i [BatEnum]
fold_left [BatVect.Make]
fold_left f a r computes f (... (f (f a r0) r1)...) rN-1 where rn = Vect.get n r and N = length r.
fold_left [BatVect]
fold_left f a r computes f (... (f (f a r0) r1)...) rN-1 where rn = Vect.get n r and N = length r.
fold_left [BatSubstring]
foldl f e sus folds f over sus from left to right.
fold_left [BatString]
fold_left f a s is f (... (f (f a s.[0]) s.[1]) ...) s.[n-1]
fold_left [BatSeq]
fold_left f a (cons b1 (... bn)) is f (... (f (f a b1) b2) ...) bn.
fold_left [BatRefList]
List.fold_left f a [b1; ...; bn] is f (... (f (f a b1) b2) ...) bn.
fold_left [BatList.Labels]
fold_left [BatLazyList.Labels]
fold_left [BatLazyList]
Eager fold_left
fold_left [BatDynArray]
fold_left f x darr computes f ( ... ( f ( f (get darr 0) x) (get darr 1) ) ... ) (get darr n-1), similar to Array.fold_left or List.fold_left.
fold_left [BatDllist]
Accumulate a value over the entire list.
fold_left [BatArray.Labels]
fold_left [BatArray.Cap.Labels]
fold_left [BatArray.Cap]
Array.fold_left f x a computes f (... (f (f x a.(0)) a.(1)) ...) a.(n-1), where n is the length of the array a.
fold_left [BatArray]
Array.fold_left f x a computes f (... (f (f x a.(0)) a.(1)) ...) a.(n-1), where n is the length of the array a.
fold_left2 [BatList.Labels]
fold_left2 [BatList]
List.fold_left2 f a [b1; ...; bn] [c1; ...; cn] is f (... (f (f a b1 c1) b2 c2) ...) bn cn.
fold_left2 [BatLazyList]
fold_left2 f a [b1; ...; bn] [c1; ...; cn] is f (... (f (f a b1 c1) b2 c2) ...) bn cn.
fold_lefti [BatArray]
fold_monad [BatEnum.WithMonad]
fold_monad f init e does a folding of the enumeration e applying step by step the function f that gives back results in the Mon monad, with the init initial element.
fold_range [BatISet]
fold_range [BatIMap]
fold_right [BatVect.RANDOMACCESS]
fold_right [BatVect.Make]
fold_right f r a computes f (r0 ... (f rN-2 (f rN-1 a)) ...)) where rn = Vect.get n r and N = length r.
fold_right [BatVect]
fold_right f r a computes f (r0 ... (f rN-2 (f rN-1 a)) ...)) where rn = Vect.get n r and N = length r.
fold_right [BatSubstring]
foldr f e sus folds f over sus from right to left.
fold_right [BatString]
fold_right f s b is f s.[0] (f s.[1] (... (f s.[n-1] b) ...))
fold_right [BatSeq]
fold_right f (cons a1 (... an)) b is f a1 (f a2 (... (f an b) ...)).
fold_right [BatRefList]
List.fold_right f [a1; ...; an] b is f a1 (f a2 (... (f an b) ...)).
fold_right [BatList.Labels]
fold_right [BatList]
List.fold_right f [a1; ...; an] b is f a1 (f a2 (... (f an b) ...)).
fold_right [BatLazyList.Labels]
fold_right [BatLazyList]
Eager fold_right
fold_right [BatDynArray]
fold_right f darr x computes f (get darr 0) (f (get darr 1) ( ... ( f (get darr n-1) x ) ... ) ) similar to Array.fold_right or List.fold_right.
fold_right [BatDllist]
Accumulate a value over the entire list.
fold_right [BatArray.Labels]
fold_right [BatArray.Cap.Labels]
fold_right [BatArray.Cap]
Array.fold_right f a x computes f a.(0) (f a.(1) ( ... (f a.(n-1) x) ...)), where n is the length of the array a.
fold_right [BatArray]
Array.fold_right f a x computes f a.(0) (f a.(1) ( ... (f a.(n-1) x) ...)), where n is the length of the array a.
fold_right2 [BatList.Labels]
fold_right2 [BatList]
List.fold_right2 f [a1; ...; an] [b1; ...; bn] c is f a1 b1 (f a2 b2 (... (f an bn c) ...)).
fold_right2 [BatLazyList.Labels]
fold_right2 [BatLazyList]
fold_right2 f [a1; ...; an] [b1; ...; bn] c is f a1 b1 (f a2 b2 (... (f an bn c) ...)).
foldi [BatVect]
As BatVect.fold, but with the position of each value passed to the folding function
foldi [BatPMap]
Same as fold, but the function receives as arguments both the key and the associated value for each binding of the map.
foldi [BatMultiPMap]
Same as fold, but the function receives as arguments both the key and the associated value for each binding of the map.
foldi [BatEnum.Labels]
foldi [BatEnum]
foldl [BatStream.StreamLabels]
foldl f init stream is a lazy fold_left.
foldl [BatStream]
foldl f init stream is a lazy fold_left.
foldr [BatStream.StreamLabels]
foldr f init stream is a lazy fold_right.
foldr [BatStream]
foldr f init stream is a lazy fold_right.
for_all [BatVect]
for_all p [a1; ...; an] checks if all elements of the array satisfy the predicate p.
for_all [BatSet.S.Labels]
for_all [BatSet.S]
for_all p s checks if all elements of the set satisfy the predicate p.
for_all [BatSeq]
for_all p (cons a1 (... an)) checks if all elements of the given sequence satisfy the predicate p.
for_all [BatRefList]
Return true if all elements match the specified predicate
for_all [BatPervasives]
exists f e returns true if for every x in e, f x is true
for_all [BatPSet]
Returns whether the given predicate applies to all elements in the set
for_all [BatPMap]
Tests whether all key value pairs satisfy some predicate function
for_all [BatList.Labels]
for_all [BatLazyList.Labels]
for_all [BatLazyList]
Eager universal.
for_all [BatISet]
for_all [BatEnum.Labels]
for_all [BatEnum]
for_all f e returns true if for every x in e, f x is true
for_all [BatDllist]
for_all [BatArray.Labels]
for_all [BatArray.Cap.Labels]
for_all [BatArray.Cap]
Predicates
for_all [BatArray]
for_all p [a1; ...; an] checks if all elements of the array satisfy the predicate p.
for_all2 [BatList.Labels]
for_all2 [BatList]
Same as List.for_all, but for a two-argument predicate.
for_all2 [BatLazyList.Labels]
for_all2 [BatLazyList]
Same as BatLazyList.for_all, but for a two-argument predicate.
for_all2 [BatArray]
As Array.for_all but on two arrays.
forall2_range [BatIMap]
force [BatEnum]
force e forces the application of all lazy functions and the enumeration of all elements, exhausting the enumeration.
foreach [BatPervasives]
Imperative loop on an enumeration.
format_from_string [BatScanf]
format_from_string s fmt converts a string argument to a format string, according to the given format string fmt.
format_timestamp [BatLogger]
format_timestamp oc timestamp prints an ISO-8601 formatted timestamp (extended to specify higher-resolution seconds) to the output channel, oc.
formatter_of_out_channel [BatFormat]
formatter_of_out_channel oc returns a new formatter that writes to the corresponding channel oc.
formatter_of_output [BatFormat]
formatter_of_output out returns a new formatter that writes to the corresponding output out.
fortran_layout [BatBigarray]
fprintf [BatPrintf]
General function.
fprintf [BatPrint]
General formatting function.
fprintf [BatInnerIO.Printf]
General function.
frexp [BatFloat.Safe_float]
frexp f returns the pair of the significant and the exponent of f.
frexp [BatFloat]
frexp f returns the pair of the significant and the exponent of f.
from [BatLazyList]
from next creates a (possibly infinite) lazy list from the successive results of next.
from [BatISet]
from [BatIMap]
from [BatEnum.Labels]
from [BatEnum]
from next creates an enumeration from the next function.
from_channel [BatScanf.Scanning]
from_channel [BatMarshal]
from_channel [BatLexing]
from_file [BatScanf.Scanning]
Bufferized file reading in text mode.
from_file_bin [BatScanf.Scanning]
Bufferized file reading in binary mode.
from_function [BatScanf.Scanning]
Scanning.from_function f returns a scanning buffer with the given function as its reading method.
from_in_channel [BatIO]
from_in_chars [BatIO]
from_input [BatScanf.Scanning]
Scanning.from_channel ic returns a scanning buffer which reads from the input channel ic, starting at the current reading position.
from_input [BatLexing]
Create a lexer buffer on the given input Lexing.from_input inp returns a lexer buffer which reads from the input inp, at the current reading position.
from_loop [BatLazyList]
from_loop data next creates a (possibly infinite) lazy list from the successive results of applying next to data, then to the result, etc.
from_loop [BatEnum.Labels]
from_loop [BatEnum]
from_loop data next creates a (possibly infinite) enumeration from the successive results of applying next to data, then to the result, etc.
from_out_channel [BatIO]
from_out_chars [BatIO]
from_string [BatScanf.Scanning]
Scanning.from_string s returns a scanning buffer which reads from the given string.
from_while [BatLazyList]
from next creates a (possibly infinite) lazy list from the successive results of next.
from_while [BatEnum.Labels]
from_while [BatEnum]
from_while next creates an enumeration from the next function.
fscanf [BatScanf]
Same as Scanf.bscanf, but reads from the given channel.
fsum [BatList]
sum l returns the sum of the elements of l
full_init [BatRandom]
Same as Random.init but takes more data as seed.
full_split [BatStr.Str]
Same as BatStr.Str.split_delim, but returns the delimiters as well as the substrings contained between delimiters.

G
ge_big_int [BatBig_int]
ge_num [BatNum]
genarray_of_array1 [BatBigarray]
Return the generic big array corresponding to the given one-dimensional big array.
genarray_of_array2 [BatBigarray]
Return the generic big array corresponding to the given two-dimensional big array.
genarray_of_array3 [BatBigarray]
Return the generic big array corresponding to the given three-dimensional big array.
get [BatVect.RANDOMACCESS]
get [BatVect.Make]
get n r returns the (n+1)th element from the vect r; i.e.
get [BatVect]
get v n returns the (n+1)th element from the vect v; i.e.
get [BatUTF8]
get s n returns the n-th Unicode character of s.
get [BatSubstring]
sub (sus, k) returns the k'th character of the substring; that is, s(i+k) where sus = (s, i, n).
get [BatRope]
get r n returns the (n+1)th character from the rope r; i.e.
get [BatRef]
As !
get [BatPervasives]
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.
get [BatPathGen.StringType]
Usual get function.
get [BatOption]
get (Some x) returns x and get None raises No_value.
get [BatOptParse.Opt]
Get the value of an option.
get [BatLazyList]
get l returns the head and tail of l, if l is not empty.
get [BatGlobal]
Get the global value contents - raise Global_not_initialized if not defined.
get [BatEnum]
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.
get [BatDynArray]
get darr idx gets the element in darr at index idx.
get [BatDllist]
Given a node, get the data associated with that node.
get [BatBigarray.Array3]
Array3.get a x y z, also written a.{x,y,z}, returns the element of a at coordinates (x, y, z).
get [BatBigarray.Array2]
Array2.get a x y, also written a.{x,y}, returns the element of a at coordinates (x, y).
get [BatBigarray.Array1]
Array1.get a x, or alternatively a.{x}, returns the element of a at index x.
get [BatBigarray.Genarray]
Read an element of a generic big array.
get [BatArray.Cap]
Array.get a n returns the element number n of array a.
get [BatArray]
Array.get a n returns the element number n of array a.
get_exn [BatOption]
get_exn (Some x) e returns x and get_exn None e raises e.
get_method [BatOo.Oo.Internal]
get_method_label [BatOo.Oo.Internal]
get_method_labels [BatOo.Oo.Internal]
get_public_method [BatOo.Oo.Internal]
get_resizer [BatDynArray]
Get the current resizer function for a given array
get_state [BatRandom]
Return the current state of the generator used by the basic functions.
get_state [BatParserCo.Source]
get_variable [BatOo.Oo.Internal]
get_variables [BatOo.Oo.Internal]
getc [BatSubstring]
getc sus returns SOME(c, rst) where c is the first character and rst the remainder of sus, if sus is non-empty; otherwise returns NONE.
global_replace [BatStr.Str]
global_replace regexp templ s returns a string identical to s, except that all substrings of s that match regexp have been replaced by templ.
global_substitute [BatStr.Str]
global_substitute regexp subst s returns a string identical to s, except that all substrings of s that match regexp have been replaced by the result of function subst.
group [BatList]
group cmp l returns list of groups and each group consists of elements judged equal by comparison function cmp.
group [BatEnum]
group test e devides e into an enumeration of enumerations, where each sub-enumeration is the longest continuous enumeration of elements whose test results are the same.
group_beginning [BatStr.Str]
group_beginning n returns the position of the first character of the substring that was matched by the nth group of the regular expression.
group_end [BatStr.Str]
group_end n returns the position of the character following the last character of substring that was matched by the nth group of the regular expression.
group_exec [BatFile]
Give the permission to execute the file to the group containing the user.
group_read [BatFile]
Give the permission to read the file to the group containing the user.
group_write [BatFile]
Give the permission to write the file to the group containing the user.
gt_big_int [BatBig_int]
Usual boolean comparisons between two big integers.
gt_num [BatNum]

H
handle [BatArg]
Arg.handle commands parses the command-line and applies the specifications of commands and returns the list of anonymous arguments.
hard_count [BatEnum]
hard_count returns the number of remaining in elements in e, consuming the whole enumeration somewhere along the way.
hash [BatInnerIO.Output]
A hash function for outputs
hash [BatInnerIO.Input]
A hash function for inputs
hash [BatHashtbl.HashedType]
A hashing function on keys.
hash [BatHashtbl]
Hashtbl.hash x associates a positive integer to any value of any type.
hash_param [BatHashtbl]
Hashtbl.hash_param n m x computes a hash value for x, with the same properties as for hash.
hd [BatSeq.Exceptionless]
hd [BatSeq]
Returns the first element of the sequence or raise Invalid_argument if the sequence is empty.
hd [BatRefList]
same as first
hd [BatLazyList]
Return the first element of the given list.
head [BatString]
head [BatRope]
height [BatVect.Make]
Returns the height (depth) of the vect.
height [BatVect]
Returns the height (depth) of the vect.
height [BatRope]
Returns the height (depth) of the rope.
height [BatAvlTree]
help [Batteries_help]
help () opens the tutorial.
help_option [BatOptParse.StdOpt]
help_option () returns the standard help option which displays a usage message and exits the program when encountered on the command line.
hex [BatUCharParser]
Recognizes one hexadecimal digit (case-insensitive)
hex [BatCharParser]
Recognizes one hexadecimal digit (case-insensitive)

I
i [BatComplex]
The complex number i.
i16s_of [BatIO.BigEndian]
Read an enumartion of signed 16-bit words.
i16s_of [BatIO]
Read an enumartion of signed 16-bit words.
i32s_of [BatIO.BigEndian]
Read an enumeration of signed 32-bit integers.
i32s_of [BatIO]
Read an enumeration of signed 32-bit integers.
i64s_of [BatIO.BigEndian]
Read an enumeration of signed 64-bit integers as OCaml int64s.
i64s_of [BatIO]
Read an enumeration of signed 64-bit integers as OCaml int64s.
icompare [BatUChar]
Compare two unicode characters, case-insensitive.
icompare [BatString]
Compare two strings, case-insensitive.
icompare [BatRope]
Compare two ropes, case-insensitive.
id [BatOo.Oo]
Return an integer identifying this object, unique for the current execution of the program.
ident [BatGenlex.Languages.Make]
Accepts any non-reserved identifier/operator.
ident_letter [BatGenlex.Languages.Definition]
ident_start [BatGenlex.Languages.Definition]
identifier [BatGenlex.Languages.Make]
identity [BatStd]
the identity function.
identity [BatPervasives]
The identity function.
ifprintf [BatPrintf]
As BatPrintf.fprintf but doesn't actually print anything.
ifprintf [BatPrint]
As BatPrint.fprintf but doesn't actually print anything.
ifprintf [BatInnerIO.Printf]
As BatInnerIO.Printf.fprintf but doesn't actually print anything.
ignore_ok [BatStd]
ignore_ok (f x) ignores the result of f x if it's ok, but throws the exception contained if Bad is returned.
ignore_one_plus [BatParserCo]
Ignore a (non-empty) list of expressions.
ignore_zero_plus [BatParserCo]
Ignore a (possibly empty) list of expressions.
implode [BatString]
implode cs returns a string resulting from concatenating the characters in the list cs.
implode [BatRope]
implode cs returns a rope resulting from concatenating the characters in the list cs.
in_channel_of_descr [BatUnix]
incr_option [BatOptParse.StdOpt]
Exactly identical to count_option ~dest:dest ~increment:1 ().
indented_formatter [BatOptParse.Formatter]
Create an "indented" formatter with the given options.
index [BatUTF8]
As String.index
index [BatRope]
Rope.index s c returns the position of the leftmost occurrence of character c in rope s.
index [BatRefList.Index]
Return the index (position : 0 starting) of an element in a ref list, using the specified comparator raise Not_found if no element was found
index_from [BatRope]
Same as Rope.index, but start searching at the character position given as second argument.
index_of [BatRefList.Index]
Return the index (position : 0 starting) of an element in a ref list, using ( = ) for testing element equality raise Not_found if no element was found
index_of [BatList]
index_of e l returns the index of the first occurrence of e in l, or None if there is no occurrence of e in l
index_of [BatLazyList]
index_of e l returns the index of the first occurrence of e in l, or None if there is no occurrence of e in l
index_of [BatDynArray]
index_of f darr returns the index of the first element x in darr such as f x returns true or raise Not_found if not found.
index_ofq [BatList]
index_ofq e l behaves as index_of e l except it uses physical equality
index_ofq [BatLazyList]
index_ofq e l behaves as index_of e l except it uses physical equality
infinity [BatFloat.Safe_float]
Positive infinity.
infinity [BatFloat]
Positive infinity.
inherit_in [BatInnerIO]
Simplified and optimized version of BatInnerIO.wrap_in whenever only one input appears as dependency.
inherit_in [BatIO]
Simplified and optimized version of BatIO.wrap_in which may be used whenever only one input appears as dependency.
inherit_out [BatInnerIO]
Simplified and optimized version of BatInnerIO.wrap_out whenever only one output appears as dependency.
inherit_out [BatIO]
Simplified and optimized version of BatIO.wrap_out whenever only one output appears as dependency.
inherits [BatOo.Oo.Internal]
init [Batteries_help]
Proceed to initialization.
init [BatVect]
init n f returns a fresh vect of length n, with element number i initialized to the result of f i.
init [BatUTF8]
init len f returns a new string which contains len Unicode characters.
init [BatString]
init l f returns the string of length l with the chars f 0 , f 1 , f 2 ...
init [BatSeq]
init n f returns the sequence returning the results of f 0, f 1....
init [BatRope]
init l f returns the rope of length l with the chars f 0 , f 1 , f 2 ...
init [BatRandom]
Initialize the generator, using the argument as a seed.
init [BatLogger]
init name_level_list formatter initializes the logging system enabling the specified levels for each named logger.
init [BatList.Labels]
init [BatList]
Similar to Array.init, init n f returns the list containing the results of (f 0),(f 1)....
init [BatLazyList]
Similar to Array.init, init n f returns the lazy list containing the results of (f 0),(f 1)....
init [BatEnum.Labels]
init [BatEnum]
init n f creates a new enumeration over elements f 0, f 1, ..., f (n-1)
init [BatDynArray]
init n f returns an array of n elements filled with values returned by f 0 , f 1, ... f (n-1).
init [BatArray.Labels]
init [BatArray.Cap.Labels]
init [BatArray.Cap]
Array.init n f returns a fresh array of length n, with element number i initialized to the result of f i.
init [BatArray]
Array.init n f returns a fresh array of length n, with element number i initialized to the result of f i.
init_class [BatOo.Oo.Internal]
init_from_string [BatLogger]
init_from_string name_level_string formatter initializes the logging system enabling the specified levels for each named logger.
input [BatPervasives]
input ic buf pos len reads up to len characters from the given channel ic, storing them in string buf, starting at character number pos.
input [BatMarshal]
input inp reads from inp the byte representation of a structured value, as produced by one of the Marshal.to_* functions, and reconstructs and returns the corresponding value.
input [BatInnerIO]
input i s p l reads up to l characters from the given input, storing them in string s, starting at character number p.
input [BatIO]
input i s p l reads up to l characters from the given input, storing them in string s, starting at character number p.
input [BatDigest]
Read a digest from the given input.
input_binary_int [BatPervasives]
Read an integer encoded in binary format (4 bytes, big-endian) from the given input channel.
input_bits [BatIO]
Read bits from an input
input_byte [BatPervasives]
Same as Pervasives.input_char, but return the 8-bit integer representing the character.
input_channel [BatInnerIO]
Create an input that will read from a channel.
input_channel [BatIO]
Create an input that will read from a channel.
input_char [BatPervasives]
Read one character from the given input channel.
input_enum [BatIO]
Create an input that will read from an enum.
input_file [BatStd]
returns the data of a given filename.
input_line [BatPervasives]
Read characters from the given input channel, until a newline character is encountered.
input_of_descr [BatUnix]
Create an input reading from the given descriptor.
input_string [BatInnerIO]
Create an input that will read from a string.
input_string [BatIO]
Create an input that will read from a string.
input_value [BatPervasives]
Read the representation of a structured value, as produced by BatPervasives.output_value, and return the corresponding value.
insert [BatVect.Make]
insert n r u returns a copy of the u vect where r has been inserted between the elements with index n and n + 1 in the original vect.
insert [BatVect]
insert n r u returns a copy of the u vect where r has been inserted between the elements with index n and n + 1 in the original vect.
insert [BatRope]
insert n r u returns a copy of the u rope where r has been inserted between the characters with index n and n + 1 in the original rope.
insert [BatDynArray]
insert darr idx v inserts v into darr at index idx.
int [BatRandom.State]
int [BatRandom]
Random.int bound returns a random integer between 0 (inclusive) and bound (exclusive).
int [BatBigarray]
See Bigarray.char.
int16_signed [BatBigarray]
See Bigarray.char.
int16_unsigned [BatBigarray]
See Bigarray.char.
int32 [BatRandom.State]
int32 [BatRandom]
Random.int32 bound returns a random integer between 0 (inclusive) and bound (exclusive).
int32 [BatBigarray]
See Bigarray.char.
int64 [BatRandom.State]
int64 [BatRandom]
Random.int64 bound returns a random integer between 0 (inclusive) and bound (exclusive).
int64 [BatBigarray]
See Bigarray.char.
int8_signed [BatBigarray]
See Bigarray.char.
int8_unsigned [BatBigarray]
See Bigarray.char.
int_callback [BatOptParse.StdOpt]
int_callback ?metavar f returns an option which takes a single integer argument and calls f with that argument when encountered on the command line.
int_of_big_int [BatBig_int]
Convert a big integer to a small integer (type int).
int_option [BatOptParse.StdOpt]
int_option ?default ?metavar () returns an option which takes a single integer argument.
integer [BatGenlex.Languages.Make]
Parse an integer.
inter [BatSet.S]
Set intersection.
inter [BatISet]
inter [BatBitSet]
inter s t returns the intersection of sets s and t.
interleave [BatList]
interleave ~first ~last sep [a1;a2;a3;...;an] returns first; a1; sep; a2; sep; a3; sep; ...; sep; an
intersect [BatBitSet]
intersect s t sets s to the intersection of the sets s and t.
inv [BatComplex]
Multiplicative inverse (1/z).
is_absolute [BatPathGen.PathType]
is_digit [BatChar]
Determine if a character represents a digit.
is_directory [BatUnix]
is_directory filename returns true if filename refers to a directory (or symlink of a directory
is_empty [BatVect.Make]
Returns whether the vect is empty or not.
is_empty [BatVect]
Returns whether the vect is empty or not.
is_empty [BatSubstring]
isEmpty (s, i, n) true if the substring is empty (that is, n = 0).
is_empty [BatString]
is_empty s returns true if s is the empty string, false otherwise.
is_empty [BatStream]
is_empty stream tests whether stream is empty.
is_empty [BatSet.S]
Test whether a set is empty or not.
is_empty [BatSeq]
is_empty e returns true if e does not contains any element.
is_empty [BatRope]
Returns whether the rope is empty or not.
is_empty [BatRefList]
Return true if a ref list is empty
is_empty [BatQueue.Queue]
Return true if the given queue is empty, false otherwise.
is_empty [BatPSet]
Test whether a set is empty or not.
is_empty [BatPMap]
returns true if the map is empty.
is_empty [BatMultiPMap]
returns true if the map is empty.
is_empty [BatMap.S]
Test whether a map is empty or not.
is_empty [BatList]
is_empty e returns true if e does not contains any element.
is_empty [BatLazyList]
Returns true if the list is empty, false otherwise.
is_empty [BatISet]
is_empty [BatIMap]
is_empty [BatHashtbl.Cap]
Hashtbl.is_empty tbl returns true if there are no bindings in tbl, false otherwise.
is_empty [BatHashtbl.S]
is_empty [BatHashtbl]
Hashtbl.is_empty tbl returns true if there are no bindings in tbl, false otherwise.
is_empty [BatEnum]
is_empty e returns true if e does not contains any element.
is_empty [BatAvlTree]
is_int_big_int [BatBig_int]
Test whether the given big integer is small enough to be representable as a small integer (type int) without loss of precision.
is_integer [BatNum]
is_integer x returns true if x represents an integer value, false otherwise
is_latin1 [BatChar]
Determine if a character is a Latin 1 letter.
is_letter [BatChar]
Determine if a character represents a ASCII letter.
is_lowercase [BatUChar]
Determine if a character is an lowercase character.
is_lowercase [BatChar]
Determine if a character is lowercase ASCII.
is_lowercase_latin1 [BatChar]
Determine if a character is lowercase Latin 1.
is_nan [BatFloat.Safe_float]
is_nan f returns true if f is nan, false otherwise.
is_nan [BatFloat]
is_nan f returns true if f is nan, false otherwise.
is_newline [BatUChar]
Determine if a character is a newline.
is_newline [BatChar]
Determine if a character is a newline.
is_none [BatOption]
is_none None returns true otherwise it returns false.
is_prefix [BatSubstring]
isPrefix s1 s2 is true if s1 is a prefix of s2.
is_relative [BatPathGen.PathType]
is_set [BatOptParse.Opt]
Find out if the option has a value (either by default or from the command line).
is_set [BatBitSet]
is_set s n returns true if nth-bit in the bitset s is set, or false otherwise.
is_some [BatOption]
is_some (Some x) returns true otherwise it returns false.
is_symbol [BatChar]
Determine if a character represents a (OCaml-style) symbol.
is_uppercase [BatUChar]
Determine if a character is an uppercase character.
is_uppercase [BatChar]
Determine if a character is uppercase ASCII.
is_uppercase_latin1 [BatChar]
Determine if a character is uppercase Latin 1.
is_whitespace [BatUChar]
Determine if a character is a whitespace.
is_whitespace [BatChar]
Determine if a character is a whitespace.
isdef [BatGlobal]
Return true if the global value has been set.
iter [BatVect.RANDOMACCESS]
iter [BatVect.Make]
iter f r applies f to all the elements in the r vect, in order.
iter [BatVect]
iter f r applies f to all the elements in the r vect, in order.
iter [BatUTF8]
iter f s applies f to all Unicode characters in s.
iter [BatSubstring]
iter f sus applies f to all characters of sus, from left to right.
iter [BatStream.StreamLabels]
Stream.iter f s scans the whole stream s, applying function f in turn to each stream element encountered.
iter [BatSet.S.Labels]
iter [BatSet.S]
iter f s applies f in turn to all elements of s.
iter [BatSeq]
iter f s applies f to all the elements of the sequence.
iter [BatRope]
iter f r applies f to all the characters in the r rope, in order.
iter [BatRefList]
Apply the given function to all elements of the ref list, in respect with the order of the list
iter [BatQueue.Queue]
iter f q applies f in turn to all elements of q, from the least recently entered to the most recently entered.
iter [BatPervasives]
Imperative loop on an enumeration.
iter [BatPathGen.StringType]
iter [BatPSet]
iter f s applies f in turn to all elements of s.
iter [BatPMap]
iter f m applies f to all bindings in map m.
iter [BatMultiPMap]
iter f m applies f to all bindings in map m.
iter [BatMap.S.Labels]
iter [BatMap.S]
iter f m applies f to all bindings in map m.
iter [BatList.Labels]
iter [BatLazyList.Labels]
iter [BatLazyList]
Eager iteration
iter [BatInnerWeaktbl]
Weaktbl.iter f tbl applies f to all bindings in table tbl.
iter [BatISet]
iter [BatIMap]
iter [BatHashtbl.Cap.Labels]
iter [BatHashtbl.Cap]
Traversing
iter [BatHashtbl.S.Labels]
iter [BatHashtbl.S]
iter [BatHashtbl.Labels]
iter [BatHashtbl]
Hashtbl.iter f tbl applies f to all bindings in table tbl.
iter [BatEnum.Labels]
iter [BatEnum]
iter f e calls the function f with each elements of e in turn.
iter [BatDynArray]
iter f darr calls the function f on every element of darr.
iter [BatDllist]
iter f n Apply f to every element in the list, starting at n.
iter [BatBigarray.Genarray]
iter f a applies function f in turn to all the elements of a.
iter [BatAvlTree]
iter [BatArray.Labels]
iter [BatArray.Cap.Labels]
iter [BatArray.Cap]
Iterators
iter [BatArray]
Array.iter f a applies function f in turn to all the elements of a.
iter2 [BatList.Labels]
iter2 [BatList]
List.iter2 f [a1; ...; an] [b1; ...; bn] calls in turn f a1 b1; ...; f an bn.
iter2 [BatLazyList.Labels]
iter2 [BatLazyList]
iter2 f [a1; ...; an] [b1; ...; bn] calls in turn f a1 b1; ...; f an bn.
iter2 [BatEnum.Labels]
iter2 [BatEnum]
iter2 f e1 e2 calls the function f with the next elements of e and e2 repeatedly until one of the two enumerations ends.
iter2 [BatArray.Labels]
iter2 [BatArray.Cap.Labels]
iter2 [BatArray.Cap]
Operations on two arrays
iter2 [BatArray]
Array.iter2 f [|a1; ...; an|] [|b1; ...; bn|] performs calls f a1 b1; ...; f an bn in that order.
iter2i [BatEnum.Labels]
iter2i [BatEnum]
iter2i [BatArray.Labels]
iter2i [BatArray.Cap.Labels]
iter2i [BatArray.Cap]
Array.iter2i f [|a1; ...; an|] [|b1; ...; bn|] performs calls f 0 a1 b1; ...; f (n - 1) an bn in that order.
iter2i [BatArray]
Array.iter2i f [|a1; ...; an|] [|b1; ...; bn|] performs calls f 0 a1 b1; ...; f (n - 1) an bn in that order.
iter_range [BatISet]
iter_range [BatIMap]
iteri [BatVect.Make]
Operates like iter, but also passes the index of the character to the given function.
iteri [BatVect]
Operates like iter, but also passes the index of the character to the given function.
iteri [BatString]
String.iteri f s is equivalent to f 0 s.[0]; f 1 s.[1]; ...; f len s.[len] where len is length of string s.
iteri [BatRope]
Operates like iter, but also passes the index of the character to the given function.
iteri [BatPathGen.StringType]
iteri [BatList.Labels]
iteri [BatList]
iteri f l will call (f 0 a0);(f 1 a1) ... (f n an) where a0..an are the elements of the list l.
iteri [BatLazyList.Labels]
iteri [BatLazyList]
Eager iteration, with indices
iteri [BatEnum.Labels]
iteri [BatEnum]
iteri [BatDynArray]
iter f darr calls the function f on every element of darr.
iteri [BatBigarray.Genarray]
Same as BatBigarray.Genarray.iter, but the function is applied to the index of the coordinates as the first argument, and the element itself as the second argument.
iteri [BatArray.Labels]
iteri [BatArray.Cap.Labels]
iteri [BatArray.Cap]
Same as Array.iter, but the function is applied to the index of the element as first argument, and the element itself as second argument.
iteri [BatArray]
Same as Array.iter, but the function is applied to the index of the element as first argument, and the element itself as second argument.

J
join [BatUTF8]
as concat
join [BatString]
Same as concat
join [BatRope]
Same as BatRope.concat
join [BatPathGen.PathType]
Create a path from given components.
junk [BatPervasives]
junk e removes the first element from the enumeration, if any.
junk [BatEnum]
junk e removes the first element from the enumeration, if any.

K
kbprintf [BatPrintf]
Same as bprintf, but instead of returning immediately, passes the buffer to its first argument at the end of printing.
kbprintf [BatPrint]
bprintf k buf fmt prints into the buffer buf, then call k with buf as argument.
kbprintf [BatInnerIO.Printf]
Same as bprintf, but instead of returning immediately, passes the buffer to its first argument at the end of printing.
kbprintf2 [BatPrintf]
Same as bprintf2, but instead of returning immediately, passes the buffer to its first argument at the end of printing.
kbprintf2 [BatInnerIO.Printf]
Same as bprintf2, but instead of returning immediately, passes the buffer to its first argument at the end of printing.
keep [BatDynArray]
keep p darr removes in place all the element x of darr such that p x = false
keys [BatMap.S]
Return an enumeration of all the keys of a map.
keys [BatHashtbl.Cap]
Return an enumeration of all the keys of a hashtable.
keys [BatHashtbl.S]
keys [BatHashtbl]
Return an enumeration of all the keys of a hashtable.
keyword [BatGenlex.Languages.Make]
kfprintf [BatPrintf]
Same as fprintf, but instead of returning immediately, passes the output to its first argument at the end of printing.
kfprintf [BatPrint]
kfprintf k oc fmt prints on oc then call k with oc as argument
kfprintf [BatInnerIO.Printf]
Functions with continuations
kind [BatBigarray.Array3]
Return the kind of the given big array.
kind [BatBigarray.Array2]
Return the kind of the given big array.
kind [BatBigarray.Array1]
Return the kind of the given big array.
kind [BatBigarray.Genarray]
Return the kind of the given big array.
kprintf [BatPrintf]
kprintf [BatInnerIO.Printf]
krprintf [BatPrint]
krprintf k fmt creates a rope from the format and other arguments and pass it to k
kscanf [BatScanf]
Same as Scanf.bscanf, but takes an additional function argument ef that is called in case of error: if the scanning process or some conversion fails, the scanning function aborts and calls the error handling function ef with the scanning buffer and the exception that aborted the scanning process.
ksprintf [BatPrintf]
Same as sprintf above, but instead of returning the string, passes it to the first argument.
ksprintf [BatPrint]
ksprintf k fmt creates a string from the format and other arguments and pass it to k
ksprintf [BatInnerIO.Printf]
Same as sprintf above, but instead of returning the string, passes it to the first argument.
ksprintf2 [BatPrintf]
Same as sprintf2 above, but instead of returning the string, passes it to the first argument.
ksprintf2 [BatInnerIO.Printf]
Same as sprintf2 above, but instead of returning the string, passes it to the first argument.
kwd [BatGenlex.Languages.Make]
Accepts any identifier.

L
label [BatReturn]
label f creates a new label x and invokes f x.
label [BatParserCo]
Give a name to a parser, for debugging purposes.
last [BatVect]
These return the first and last values in the vector
last [BatUTF8.Byte]
last [BatSeq.Exceptionless]
last [BatSeq]
Returns the last element of the sequence, or raise Invalid_argument if the sequence is empty.
last [BatRefList]
Returns the last element - O(n) or raises Empty_list if the ref list is empty
last [BatList]
Returns the last element of the list, or raise Empty_list if the list is empty.
last [BatLazyList]
Returns the last element of the list, or raise Empty_list if the list is empty.
last [BatDynArray]
last darr returns the last element of darr.
last_chars [BatStr.Str]
last_chars s n returns the last n characters of s.
latin1 [BatCharParser]
Recognizes one lower- or upper-case Latin1 character, including accentuated characters.
layout [BatBigarray.Array3]
Return the layout of the given big array.
layout [BatBigarray.Array2]
Return the layout of the given big array.
layout [BatBigarray.Array1]
Return the layout of the given big array.
layout [BatBigarray.Genarray]
Return the layout of the given big array.
lchop [BatString]
Returns the same string but without the first character.
lchop [BatRope]
Returns the same rope but without the first character.
ldexp [BatFloat.Safe_float]
ldexp x n returns x *. 2 ** n.
ldexp [BatFloat]
ldexp x n returns x *. 2 ** n.
le_big_int [BatBig_int]
le_num [BatNum]
left [BatString]
left r len returns the string containing the len first characters of r
left [BatRope]
left r len returns the rope containing the len first characters of r
left_branch [BatAvlTree]
length [BatVect.RANDOMACCESS]
length [BatVect.Make]
Returns the length of the vect (O(1)).
length [BatVect]
Returns the length of the vect (O(1)).
length [BatUTF8]
length s returns the number of Unicode characters contained in s
length [BatSeq]
Return the number of elements of the given sequence.
length [BatRope]
Returns the length of the rope (O(1)).
length [BatRefList]
Returns the number of elements - O(n)
length [BatQueue.Queue]
Return the number of elements in a queue.
length [BatPathGen.StringType]
Length - number of indexing units
length [BatLazyList]
Return the length (number of elements) of the given list.
length [BatInnerWeaktbl]
Weaktbl.length tbl returns the number of bindings in tbl.
length [BatHashtbl.Cap]
Base operations
length [BatHashtbl.S]
length [BatHashtbl]
Hashtbl.length tbl returns the number of bindings in tbl.
length [BatDynArray]
Return the number of elements in the array.
length [BatDllist]
Returns the length of the list.
length [BatArray.Cap]
Return the length (number of elements) of the given array.
length [BatArray]
Return the length (number of elements) of the given array.
length0 [BatUTF8]
UTF8 encoding often calls for the encoding of a Unicode character with several bytes.
letter [BatUCharParser]
Recognizes one lower- or upper-case character.
letter [BatPathGen.StringType.Parse]
letter [BatCharParser]
Recognizes one lower- or upper-case ASCII character, including accentuated characters.
level_of_name [BatLogger]
level_of_name str returns the level associated with str.
lift [BatPathGen.StringType]
Convert from UTF-8 string of primitive string type.
lift_char [BatPathGen.StringType]
Convert Latin-1 character to tchar.
line_comment [BatGenlex.Languages.Make]
line_comment_start [BatGenlex.Languages.Definition]
lines_of [BatIO]
Read an enumeration of LF or CRLF terminated strings.
lines_of [BatFile]
line_of name reads the contents of file name as an enumeration of lines.
literal [BatPrint]
literal str create a directive which do not take any argument from a literal string
lock [BatUnix]
A lock used to synchronize internal operations.
lock [BatRMutex]
Lock the given mutex.
lock [BatPervasives]
A lock used to synchronize internal operations.
lock [BatMutex.Mutex]
Lock the given mutex.
lock [BatIO]
A lock used to synchronize internal operations.
lock [BatConcurrent.BaseLock]
lock [BatConcurrent.Lock]
lock_factory [BatIO]
A factory used to create locks.
log [BatLogger]
log logger level event_fun raises a log event if if the specified level is currently enabled for the logger.
log [BatFloat.Safe_float]
Natural logarithm.
log [BatFloat]
Natural logarithm.
log [BatComplex]
Natural logarithm (in base e).
log10 [BatFloat.Safe_float]
Base 10 logarithm.
log10 [BatFloat]
Base 10 logarithm.
log_enable [BatLogger]
log_enable logger level enables a log level for a logger.
log_enabled [BatLogger]
log_enabled logger level returns true if the specified level is currently enabled for the logger.
log_level [BatLogger]
log_level logger returns the currently enabled level for a logger.
log_name [BatLogger]
log_name logger returns the name of the logger.
logand [BatNativeint]
Bitwise logical and.
logand [BatInt64]
Bitwise logical and.
logand [BatInt32]
Bitwise logical and.
lognot [BatNativeint]
Bitwise logical negation
lognot [BatInt64]
Bitwise logical negation
lognot [BatInt32]
Bitwise logical negation
logor [BatNativeint]
Bitwise logical or.
logor [BatInt64]
Bitwise logical or.
logor [BatInt32]
Bitwise logical or.
logxor [BatNativeint]
Bitwise logical exclusive or.
logxor [BatInt64]
Bitwise logical exclusive or.
logxor [BatInt32]
Bitwise logical exclusive or.
look [BatUTF8]
look s i returns the Unicode character of the location i in the string s.
lookahead [BatParserCo]
lookahead p behaves as maybe p but without consuming anything
lookup_tables [BatOo.Oo.Internal]
lowercase [BatUTF8]
Return a copy of the argument, with all uppercase letters translated to lowercase.
lowercase [BatUCharParser]
Recognizes one lower-case character, including accentuated characters.
lowercase [BatUChar]
Convert the given character to its equivalent lowercase character.
lowercase [BatRope]
lowercase s returns a lowercase copy of rope s.
lowercase [BatPervasives]
Return a copy of the argument, with all uppercase letters translated to lowercase, including accented letters of the ISO Latin-1 (8859-1) character set.
lowercase [BatCharParser]
Recognizes one lower-case ASCII character, including accentuated characters.
lowercase_latin1 [BatCharParser]
Recognizes one lower-case Latin-1 character, including accentuated characters.
lt_big_int [BatBig_int]
lt_num [BatNum]

M
make [BatVect.RANDOMACCESS]
make [BatVect.Make]
make i c returns a vect of length i whose elements are all equal to c; it is similar to Array.make
make [BatVect]
make i c returns a vect of length i whose elements are all equal to c; it is similar to Array.make
make [BatUTF8]
As String.make
make [BatSubstring]
make [BatSeq]
make n e returns the sequence of length n where all elements are e
make [BatRope]
make i c returns a rope of length i consisting of c chars; it is similar to String.make
make [BatRandom.State]
Create a new state and initialize it with the given seed.
make [BatRMutex]
Create a new abstract lock based on Reentrant Mutexes.
make [BatOptParse.OptParser]
Creates a new option parser with the given options.
make [BatMutex.Mutex]
Create a new abstract lock based on Mutexes.
make [BatList]
Similar to String.make, make n x returns a list containing n elements x.
make [BatLazyList]
Similar to String.make, make n x returns a list containing n elements x.
make [BatEnum]
This function creates a fully defined enumeration.
make [BatDynArray]
make count returns an array with some memory already allocated so up to count elements can be stored into it without resizing.
make [BatConcurrent.Lock]
make [BatArray.Cap.Labels]
make [BatArray.Cap]
Constructors
make [BatArray]
Array.make n x returns a fresh array of length n, initialized with x.
make_class [BatOo.Oo.Internal]
make_class_store [BatOo.Oo.Internal]
make_compare [BatList]
make_compare c generates the lexicographical order on lists induced by c
make_compare [BatArray.Cap]
Utilities
make_compare [BatArray]
make_compare c generates the lexicographical order on arrays induced by c
make_dbg_formatter [BatLogger]
make_dbg_formatter oc constructs a debug formatter from an output channel.
make_decoding_table [BatBase64]
Create a valid decoding table from an encoding one.
make_log [BatLogger]
make_log name returns a new logger.
make_matrix [BatArray.Labels]
make_matrix [BatArray.Cap.Labels]
make_matrix [BatArray.Cap]
Array.make_matrix dimx dimy e returns a two-dimensional array (an array of arrays) with first dimension dimx and second dimension dimy.
make_matrix [BatArray]
Array.make_matrix dimx dimy e returns a two-dimensional array (an array of arrays) with first dimension dimx and second dimension dimy.
make_self_init [BatRandom.State]
Create a new state and initialize it with a system-dependent low-entropy seed.
make_std_formatter [BatLogger]
make_std_formatter oc constructs a formatter from an output channel.
make_tree [BatAvlTree]
man [Batteries_help]
man "something" opens the help about subject "something".
map [BatVect.RANDOMACCESS]
map [BatVect.Make]
map f v returns a vect isomorphic to v where each element of index i equals f (get v i).
map [BatVect]
map f v returns a vect isomorphic to v where each element of index i equals f (get v i).
map [BatUTF8]
As String.map
map [BatString]
map f s returns a string where all characters c in s have been replaced by f c.
map [BatStream.StreamLabels]
map f stream applies f in turn to elements from stream and return the results as a stream in the same order.
map [BatStream]
map f stream applies f in turn to elements from stream and return the results as a stream in the same order.
map [BatSet.S.Labels]
map [BatSet.S]
map f x creates a new set with elements f a0, f a1...
map [BatSeq]
map f s returns the sequence where elements are elements of s mapped with f.
map [BatRope]
map f s returns a rope where all characters c in s have been replaced by f c.
map [BatRefList]
Apply a function to all elements and return the ref list constructed with the function returned values
map [BatPervasives]
Transformation loop on an enumeration, used to build an enumeration from another enumeration.
map [BatPathGen.PathType]
Map a path through a function that operates on separate components.
map [BatPair]
map a function across both values in a pair
map [BatPSet]
map f x creates a new set with elements f a0, f a1...
map [BatPMap]
map f m returns a map with same domain as m, where the associated value a of all bindings of m has been replaced by the result of the application of f to a.
map [BatOption.Labels]
map [BatOption]
map f (Some x) returns Some (f x) and map f None returns None.
map [BatMultiPMap]
map f m returns a map with same domain as m, where the associated value a of all bindings of m has been replaced by the result of the application of f to a.
map [BatMap.S.Labels]
map [BatMap.S]
map f m returns a map with same domain as m, where the associated value a of all bindings of m has been replaced by the result of the application of f to a.
map [BatList.Labels]
map [BatList]
map f [a1; ...; an] applies function f to a1, ..., an, and builds the list [f a1; ...; f an] with the results returned by f.
map [BatLazyList.Labels]
map [BatLazyList]
Lazy map
map [BatInterfaces.Mappable]
map f e applies f to every element of e and returns the corresponding data structure
map [BatIMap]
map [BatHashtbl.Cap]
map f x creates a new hashtable with the same keys as x, but with the function f applied to all the values
map [BatHashtbl.S.Labels]
map [BatHashtbl.S]
map [BatHashtbl.Labels]
map [BatHashtbl]
map f x creates a new hashtable with the same keys as x, but with the function f applied to all the values
map [BatEnum.Labels]
map [BatEnum]
map f e returns an enumeration over (f a1, f a2, ... , f aN) where a1...N are the elements of e.
map [BatDynArray]
map f darr applies the function f to every element of darr and creates a dynamic array from the results - similar to List.map or Array.map.
map [BatDllist]
Allocate a new list, with entirely new nodes, whose values are the transforms of the values of the original list.
map [BatBigarray.Array3]
Array3.map f a applies function f to all the elements of a, and builds a Bigarray.Array3.t with the results returned by f.
map [BatBigarray.Array2]
Array2.map f a applies function f to all the elements of a, and builds a Bigarray.Array2.t with the results returned by f.
map [BatBigarray.Array1]
Array1.map f a applies function f to all the elements of a, and builds a Bigarray.Array1.t with the results returned by f.
map [BatBigarray.Genarray]
map f a applies function f to all the elements of a, and builds a Bigarray.t with the results returned by f.
map [BatArray.Labels]
map [BatArray.Cap.Labels]
map [BatArray.Cap]
Array.map f a applies function f to all the elements of a, and builds an array with the results returned by f: [| f a.(0); f a.(1); ...; f a.(Array.length a - 1) |].
map [BatArray]
Array.map f a applies function f to all the elements of a, and builds an array with the results returned by f: [| f a.(0); f a.(1); ...; f a.(Array.length a - 1) |].
map2 [BatStream.StreamLabels]
map2 f streama streamb applies f in turn to elements of corresponding positions from streama and streamb.
map2 [BatStream]
map2 f streama streamb applies f in turn to elements of corresponding positions from streama and streamb.
map2 [BatList.Labels]
map2 [BatList]
List.map2 f [a1; ...; an] [b1; ...; bn] is [f a1 b1; ...; f an bn].
map2 [BatLazyList.Labels]
map2 [BatLazyList]
Operations on two lists
map2 [BatArray]
As Array.map but on two arrays.
map_default [BatOption.Labels]
map_default [BatOption]
map_default f x (Some v) returns f v and map_default f x None returns x.
map_ext [BatPathGen.PathType]
map_ext fu path returns path but with the name with extension given by fu (BatPathGen.PathType.ext path).
map_file [BatBigarray.Array3]
Memory mapping of a file as a three-dimensional big array.
map_file [BatBigarray.Array2]
Memory mapping of a file as a two-dimensional big array.
map_file [BatBigarray.Array1]
Memory mapping of a file as a one-dimensional big array.
map_file [BatBigarray.Genarray]
Memory mapping of a file as a big array.
map_list [BatRefList]
Apply a function to all elements and return the list constructed with the function returned values
map_name [BatPathGen.PathType]
map_name fu path returns path with the name replaced by fu (BatPathGen.PathType.name path).
map_to_set [BatIMap]
mapi [BatVect.Make]
Same as map, but the function is applied to the index of the element as first argument, and the element itself as second argument.
mapi [BatVect]
Same as BatVect.map, but the function is applied to the index of the element as first argument, and the element itself as second argument.
mapi [BatPMap]
Same as map, but the function receives as arguments both the key and the associated value for each binding of the map.
mapi [BatMultiPMap]
Same as map, but the function receives as arguments both the key and the associated value for each binding of the map.
mapi [BatMap.S.Labels]
mapi [BatMap.S]
Same as Map.S.map, but the function receives as arguments both the key and the associated value for each binding of the map.
mapi [BatList.Labels]
mapi [BatList]
mapi f l will build the list containing (f 0 a0);(f 1 a1) ... (f n an) where a0..an are the elements of the list l.
mapi [BatLazyList.Labels]
mapi [BatLazyList]
Lazy map, with indices
mapi [BatIMap]
mapi [BatEnum.Labels]
mapi [BatEnum]
mapi is similar to map except that f is passed one extra argument which is the index of the element in the enumeration, starting from 0.
mapi [BatDynArray]
mapi f darr applies the function f to every element of darr and creates a dynamic array from the results - similar to List.mapi or Array.mapi.
mapi [BatBigarray.Array1]
Same as Bigarray.Array1.map, but the function is applied to the index of the element as the first argument, and the element itself as the second argument.
mapi [BatBigarray.Genarray]
Same as BatBigarray.Genarray.map, but the function is applied to the index of the coordinates as the first argument, and the element itself as the second argument.
mapi [BatArray.Labels]
mapi [BatArray.Cap.Labels]
mapi [BatArray.Cap]
Same as Array.map, but the function is applied to the index of the element as first argument, and the element itself as second argument.
mapi [BatArray]
Same as Array.map, but the function is applied to the index of the element as first argument, and the element itself as second argument.
mapij [BatBigarray.Array2]
Same as Bigarray.Array2.map, but the function is applied to the index of the element as the first two arguments, and the element itself as the third argument.
mapijk [BatBigarray.Array3]
Same as Bigarray.Array3.map, but the function is applied to the index of the element as the first three arguments, and the element itself as the fourth argument.
match_beginning [BatStr.Str]
match_beginning() returns the position of the first character of the substring that was matched by BatStr.Str.string_match, BatStr.Str.search_forward or BatStr.Str.search_backward.
match_end [BatStr.Str]
match_end() returns the position of the character following the last character of the substring that was matched by string_match, search_forward or search_backward.
matched_group [BatStr.Str]
matched_group n s returns the substring of s that was matched by the nth group \(...\) of the regular expression during the latest BatStr.Str.string_match, BatStr.Str.search_forward or BatStr.Str.search_backward.
matched_string [BatStr.Str]
matched_string s returns the substring of s that was matched by the latest BatStr.Str.string_match, BatStr.Str.search_forward or BatStr.Str.search_backward.
max [BatSeq.Exceptionless]
max [BatSeq]
max s returns the largest value in s as judged by Pervasives.compare
max [BatList]
max l returns the largest value in l as judged by Pervasives.compare
max [BatArray]
max a returns the largest value in a as judged by Pervasives.compare
max_array_length [Batteries_config]
The maximal length of a normal array on this system.
max_big_int [BatBig_int]
Return the greater of its two arguments.
max_binding [BatPMap]
returns the binding with the largest key
max_elt [BatSet.S.Exceptionless]
max_elt [BatSet.S]
Same as Set.S.min_elt, but returns the largest element of the given set.
max_elt [BatPSet]
returns the binding with the largest key.
max_elt [BatISet]
max_int [BatNativeint]
The greatest representable native integer, either 231 - 1 on a 32-bit platform, or 263 - 1 on a 64-bit platform.
max_int [BatInt64]
The greatest representable 64-bit integer, 263 - 1.
max_int [BatInt32]
The greatest representable 32-bit integer, 231 - 1.
max_length [BatVect.Make]
Maximum length of the vect.
max_length [BatVect]
Maximum length of the vect.
max_length [BatRope]
Maximum length of the rope (number of UTF-8 characters).
max_num [BatNumber.Bounded]
max_num [BatNum]
max_num [BatNativeint]
max_num [BatInt32]
max_num [BatInt.Safe_int]
The smallest representable integer, -230 or 262.
max_num [BatInt]
The smallest representable integer, -230 or 262.
max_num [BatFloat.Safe_float]
max_num [BatFloat]
max_num [BatBool]
max_string_length [Batteries_config]
Maximum length of a string.
may [BatOption.Labels]
may [BatOption]
may f (Some x) calls f x and may f None does nothing.
maybe [BatParserCo]
Accept an optional argument.
maybe_printer [BatOption]
mem [BatVect]
mem m a is true if and only if m is equal to an element of a.
mem [BatSet.S]
mem x s tests whether x belongs to the set s.
mem [BatSeq]
mem a l is true if and only if a is equal to an element of l.
mem [BatPSet]
mem x s tests whether x belongs to the set s.
mem [BatPMap]
mem x m returns true if m contains a binding for x, and false otherwise.
mem [BatMultiPMap]
mem x m returns true if m contains at least a binding for x, and false otherwise.
mem [BatMap.S]
mem x m returns true if m contains a binding for x, and false otherwise.
mem [BatLazyList]
Finding
mem [BatInnerWeaktbl]
Weaktbl.mem tbl x checks if x is bound in tbl.
mem [BatISet]
mem [BatIMap]
mem [BatHashtbl.Cap]
Hashtbl.mem tbl x checks if x is bound in tbl.
mem [BatHashtbl.S]
mem [BatHashtbl]
Hashtbl.mem tbl x checks if x is bound in tbl.
mem [BatArray.Cap]
mem m a is true if and only if m is equal to an element of a.
mem [BatArray]
mem m a is true if and only if m is equal to an element of a.
mem_assoc [BatLazyList]
As BatLazyList.assoc but simply returns true if a binding exists, false otherwise.
mem_assq [BatLazyList]
As BatLazyList.mem_assoc but with physical equality.
memq [BatVect]
Same as Array.mem but uses physical equality instead of structural equality to compare array elements.
memq [BatLazyList]
As mem, but with physical equality
memq [BatArray.Cap]
Same as Array.mem but uses physical equality instead of structural equality to compare array elements.
memq [BatArray]
Same as Array.mem but uses physical equality instead of structural equality to compare array elements.
merge [BatStream.StreamLabels]
merge test (streama, streamb) merge the elements from streama and streamb into a single stream.
merge [BatStream]
merge test (streama, streamb) merge the elements from streama and streamb into a single stream.
merge [BatList.Labels]
merge [BatEnum]
merge test (a, b) merge the elements from a and b into a single enumeration.
min [BatSeq.Exceptionless]
min [BatSeq]
min s returns the smallest value in s as judged by Pervasives.compare
min [BatList]
min l returns the smallest value in l as judged by Pervasives.compare
min [BatArray]
min a returns the smallest value in a as judged by Pervasives.compare
min_big_int [BatBig_int]
Return the smaller of its two arguments.
min_binding [BatPMap]
returns the binding with the smallest key
min_elt [BatSet.S.Exceptionless]
min_elt [BatSet.S]
Return the smallest element of the given set (with respect to the Ord.compare ordering).
min_elt [BatPSet]
returns the binding with the smallest key.
min_elt [BatISet]
min_int [BatNativeint]
The greatest representable native integer, either -231 on a 32-bit platform, or -263 on a 64-bit platform.
min_int [BatInt64]
The smallest representable 64-bit integer, -263.
min_int [BatInt32]
The smallest representable 32-bit integer, -231.
min_num [BatNumber.Bounded]
min_num [BatNum]
min_num [BatNativeint]
min_num [BatInt32]
min_num [BatInt.Safe_int]
The greatest representable integer, which is either 230-1 or 262-1.
min_num [BatInt]
The greatest representable integer, which is either 230-1 or 262-1.
min_num [BatFloat.Safe_float]
min_num [BatFloat]
min_num [BatBool]
minus_one [BatNativeint]
The native integer -1.
minus_one [BatInt64]
The 64-bit integer -1.
minus_one [BatInt32]
The 32-bit integer -1.
minus_one [BatInt.Safe_int]
The integer -1.
minus_one [BatInt]
The integer -1.
modf [BatFloat.Safe_float]
modf f returns the pair of the fractional and integral part of f.
modf [BatFloat]
modf f returns the pair of the fractional and integral part of f.
modify [BatVect]
modify v n f is equivalent to set v n (f (get v n)), but more efficient.
modify [BatPMap]
modify k f m replaces the previous binding for k with f applied to that value.
modulo [BatNumber.Numeric]
modulo [BatNum]
modulo [BatNativeint]
modulo [BatInt32]
modulo [BatInt.Safe_int]
modulo a b computes the remainder of the integer division of a by b.
modulo [BatInt]
modulo a b computes the remainder of the integer division of a by b.
modulo [BatFloat.Safe_float]
modulo [BatFloat]
modulo [BatComplex]
modulo [BatBool]
modulo [BatBig_int]
move [BatUTF8.Byte]
move [BatUTF8]
move s i n returns n-th Unicode character after i if n >= 0, n-th Unicode character before i if n < 0.
mul [BatNumber.Numeric]
mul [BatNum]
mul [BatNativeint]
Multiplication.
mul [BatInt64]
Multiplication.
mul [BatInt32]
Multiplication.
mul [BatInt.Safe_int]
Multiplication.
mul [BatInt]
Multiplication.
mul [BatFloat.Safe_float]
mul [BatFloat]
mul [BatComplex]
Multiplication
mul [BatBool]
mul [BatBig_int]
multiline_comment [BatGenlex.Languages.Make]
must [BatParserCo]
Prevent backtracking.

N
n_cartesian_product [BatList]
Given n lists, return the n-way cartesian product of these lists.
name [BatPathGen.PathType]
Returns name of the object the pathname points to, i.e.
name [BatGlobal]
Retrieve the name of a global.
name_core [BatPathGen.PathType]
Returns part of the name to the left of rightmost dot.
name_of_encoding [BatCharEncodings]
Return the name of the encoding.
name_of_input [BatScanf.Scanning]
Scanning.file_name_of_input ib returns the name of the character source for the scanning buffer ib.
name_of_level [BatLogger]
name_of_level level returns the name of the specified level.
nan [BatFloat.Safe_float]
A special floating-point value denoting the result of an undefined operation such as 0.0 /. 0.0.
nan [BatFloat]
A special floating-point value denoting the result of an undefined operation such as 0.0 /. 0.0.
narrow [BatOo.Oo.Internal]
nat_of_num [BatNum]
Coercions between numerical types
nativeint [BatRandom.State]
nativeint [BatRandom]
Random.nativeint bound returns a random integer between 0 (inclusive) and bound (exclusive).
nativeint [BatBigarray]
See Bigarray.char.
neg [BatNumber.Numeric]
neg [BatNum]
neg [BatNativeint]
Unary negation.
neg [BatInt64]
Unary negation.
neg [BatInt32]
Unary negation.
neg [BatInt.Safe_int]
Unary negation.
neg [BatInt]
Unary negation.
neg [BatFloat.Safe_float]
neg [BatFloat]
neg [BatComplex]
Unary negation.
neg [BatBool]
neg [BatBig_int]
neg_infinity [BatFloat.Safe_float]
Negative infinity.
neg_infinity [BatFloat]
Negative infinity.
nested_comments [BatGenlex.Languages.Definition]
new_method [BatOo.Oo.Internal]
new_methods_variables [BatOo.Oo.Internal]
new_variable [BatOo.Oo.Internal]
newline [BatUCharParser]
Recognizes a newline
newline [BatCharParser]
Recognizes a newline
next [BatUTF8.Byte]
next [BatUTF8]
next s i returns the position of the head of the Unicode character located immediately after i.
next [BatStream]
Return the first element of the stream and remove it from the stream.
next [BatLazyList]
Common functions
next [BatDllist]
Given a node, get the next element in the list after the node.
nil [BatSeq]
nil = fun () -> Nil
nil [BatLazyList]
Access
nolock [BatConcurrent]
A lock which does nothing.
none_of [BatUCharParser]
Accept any value not in a list As ParserCo.none_of, just with improved error message.
none_of [BatParserCo]
Accept any value not in a list Faster and more convenient than combining satisfy and either.
none_of [BatCharParser]
Accept any value not in a list As ParserCo.none_of, just with improved error message.
norm [BatComplex]
Norm: given x + i.y, returns sqrt(x^2 + y^2).
norm2 [BatComplex]
Norm squared: given x + i.y, returns x^2 + y^2.
normalize [BatPathGen.PathType]
Consumes single dots and applies double dots where possible, e.g.:
not [BatBool]
The boolean negation.
not_char [BatUCharParser]
Accept any value not a given char As none_of.
not_char [BatCharParser]
Accept any value not a given char As none_of.
npop [BatRefList]
Removes and returns the n first elements or raises Empty_list if the ref list does not contain enough elements
nread [BatInnerIO]
nread i n reads a string of size up to n from an input.
nread [BatIO]
nread i n reads a string of size up to n from an input.
nsplit [BatString]
nsplit s sep splits the string s into a list of strings which are separated by sep.
nsplit [BatRope]
nsplit s sep splits the rope s into a list of ropes which are separated by sep.
nth [BatList]
Obsolete.
nth [BatLazyList]
Obsolete.
nth_dim [BatBigarray.Genarray]
Genarray.nth_dim a n returns the n-th dimension of the big array a.
null_formatter [BatLogger]
null_formatter is a formatter that does not output any events, but simply discards them.
num_digits_big_int [BatBig_int]
Return the number of machine words used to store the given big integer.
num_dims [BatBigarray.Genarray]
Return the number of dimensions of the given big array.
num_of_big_int [BatNum]
num_of_nat [BatNum]
num_of_ratio [BatNum]
number [BatGenlex.Languages.Make]
Parse either an integer or a floating-point number.
numeric_compare [BatString]
Compare two strings, sorting "abc32def" before "abc210abc".
nwrite [BatInnerIO]
Write a string to an output.
nwrite [BatIO]
Write a string to an output.

O
of_array [BatVect]
of_array s returns a vect corresponding to the array s.
of_array [BatLazyList]
Eager conversion from array
of_array [BatDynArray]
of_array arr returns an array with the elements of arr in it in order.
of_array [BatBigarray.Array3]
Build a three-dimensional big array initialized from the given array of arrays of arrays.
of_array [BatBigarray.Array2]
Build a two-dimensional big array initialized from the given array of arrays.
of_array [BatBigarray.Array1]
Build a one-dimensional big array initialized from the given array.
of_array [BatArray.Cap]
Adopt a regular array as a capability array, allowing to decrease capabilities if necessary.
of_backwards [BatVect.RANDOMACCESS]
of_backwards [BatVect]
Build a vector from an enumeration, from last to first.
of_backwards [BatUTF8]
As String.of_backwards
of_backwards [BatString]
Build a string from an enumeration, starting with last character, ending with first.
of_backwards [BatRope]
Build a rope from an enumeration, starting with last character, ending with first.
of_backwards [BatRefList]
Creates a ref list from an enumeration, going from last to first
of_backwards [BatList]
Build a list from an enumeration.
of_backwards [BatArray.Cap]
Build an array from an enumeration, from end to start.
of_backwards [BatArray]
Build an array from an enumeration, going into reverse order.
of_bulk_enum [BatRope]
Creates a rope from an enumeration of UTF-8 encoded strings.
of_byte [BatInt32]
of_char [BatUTF8]
As String.of_char
of_char [BatString]
Returns a string containing one given character.
of_char [BatRope]
of_char c returns a rope containing exactly Latin-1 character c.
of_char_idx [BatUTF8.Byte]
of_char_idx s n returns the position of the n-th Unicode character.
of_container [BatVect.Make]
of_array s returns a vect corresponding to the container s.
of_digit [BatUChar]
Return the character representing a given digit.
of_digit [BatChar]
Return the character representing a given digit.
of_enum [BatVect.RANDOMACCESS]
of_enum [BatVect]
Build a vector from an enumeration.
of_enum [BatUTF8]
As String.of_enum
of_enum [BatString]
Creates a string from a character enumeration.
of_enum [BatStream]
Convert a stream to an enumeration.
of_enum [BatStack]
of_enum e returns a new stack containing all the elements of e.
of_enum [BatSet.S]
of_enum [BatRope]
Creates a rope from a character enumeration.
of_enum [BatRefList]
Creates a ref list from an enumeration
of_enum [BatQueue.Queue]
of_enum e returns a new queue containing all the elements of e.
of_enum [BatParserCo.Source]
of_enum [BatPair]
builds a pair out of the first two values of an enum.
of_enum [BatPSet]
of_enum [BatPMap]
creates a map from an enumeration, using the specified function for key comparison or compare by default.
of_enum [BatOption]
of_enum e consumes the first element of e, if it exists, and returns Some e.
of_enum [BatMultiPMap]
creates a map from an enumeration, using the specified function for key comparison or compare by default.
of_enum [BatMap.S]
Create a map from a (key, value) enumeration.
of_enum [BatList]
Build a list from an enumeration.
of_enum [BatLazyList]
Lazy conversion from enum.
of_enum [BatHashtbl.Cap]
Create a hashtable from a (key,value) enumeration.
of_enum [BatHashtbl.S]
of_enum [BatHashtbl]
Create a hashtable from a (key,value) enumeration.
of_enum [BatEnum.Enumerable]
Build a data structure from an enumeration
of_enum [BatEnum]
identity : added for consistency with the other data structures
of_enum [BatDynArray]
of_enum e returns an array that holds, in order, the elements of e.
of_enum [BatDllist]
Create a dllist from an enum.
of_enum [BatBuffer]
Creates a buffer from a character enumeration.
of_enum [BatArray.Cap]
Build an array from an enumeration.
of_enum [BatArray]
Build an array from an enumeration.
of_float [BatString]
Returns the string representation of an float.
of_float [BatRope]
Returns the rope representation of a float.
of_float [BatNumber.Numeric]
of_float [BatNum]
of_float [BatNativeint]
Convert the given floating-point number to a native integer, discarding the fractional part (truncate towards 0).
of_float [BatInt64]
Convert the given floating-point number to a 64-bit integer, discarding the fractional part (truncate towards 0).
of_float [BatInt32]
Convert the given floating-point number to a 32-bit integer, discarding the fractional part (truncate towards 0).
of_float [BatInt.Safe_int]
Convert the given floating-point number to integer integer, discarding the fractional part (truncate towards 0).
of_float [BatInt]
Convert the given floating-point number to integer integer, discarding the fractional part (truncate towards 0).
of_float [BatFloat.Safe_float]
of_float [BatFloat]
of_float [BatBool]
of_fun [BatStream]
Stream.from f returns a stream built from the function f.
of_input [BatSubstring]
of_input [BatStream]
Convert an input to a stream.
of_int [BatString]
Returns the string representation of an int.
of_int [BatRope]
Returns the rope representation of an int.
of_int [BatNumber.Numeric]
of_int [BatNum]
of_int [BatNativeint]
Convert the given integer (type int) to a native integer (type nativeint).
of_int [BatInt64]
Convert the given integer (type int) to a 64-bit integer (type int64).
of_int [BatInt32]
Convert the given integer (type int) to a 32-bit integer (type int32).
of_int [BatInt.Safe_int]
of_int [BatInt]
of_int [BatFloat.Safe_float]
of_int [BatFloat]
of_int [BatComplex]
of_int [BatBool]
of_int [BatBig_int]
of_int32 [BatNativeint]
Convert the given 32-bit integer (type int32) to a native integer.
of_int32 [BatInt64]
Convert the given 32-bit integer (type int32) to a 64-bit integer (type int64).
of_int_unsafe [BatUTF8.Byte]
of_latin1 [BatRope]
Constructs a unicode rope from a latin-1 string.
of_list [BatVect]
of_list [BatString]
Converts a list of characters to a string.
of_list [BatRefList]
Creates a ref list from a list - O(1)
of_list [BatLazyList]
Lazy conversion from lists
of_list [BatGenlex]
Create a lexer from a list of keywords
of_list [BatDynArray]
of_list lst returns a dynamic array with the elements of lst in it in order.
of_list [BatDllist]
Converts from a normal list to a Dllist and returns the first node.
of_list [BatArray.Cap]
Array.of_list l returns a fresh array containing the elements of l.
of_list [BatArray]
Array.of_list l returns a fresh array containing the elements of l.
of_nativeint [BatInt64]
Convert the given native integer (type nativeint) to a 64-bit integer (type int64).
of_object [BatEnum]
of_object e returns a representation of an object as an enumeration
of_option [BatResult]
Convert an option to a result
of_stream [BatLazyList]
Lazy conversion from stream.
of_string [BatUnit]
Convert the given string to a unit.
of_string [BatUTF8]
Adopt a string.
of_string [BatSubstring]
of_string [BatRope]
of_string s returns a rope corresponding to the UTF-8 encoded string s.
of_string [BatPathGen.PathType]
Parse path in a given string.
of_string [BatNumber.Numeric]
of_string [BatNum]
of_string [BatNativeint]
Convert the given string to a native integer.
of_string [BatInt64]
Convert the given string to a 64-bit integer.
of_string [BatInt32]
Convert the given string to a 32-bit integer.
of_string [BatInt.Safe_int]
Convert the given string to an integer The string is read in decimal (by default) or in hexadecimal, octal or binary if the string begins with 0x, 0o or 0b respectively.
of_string [BatInt]
Convert the given string to an integer The string is read in decimal (by default) or in hexadecimal, octal or binary if the string begins with 0x, 0o or 0b respectively.
of_string [BatFloat.Safe_float]
of_string [BatFloat]
of_string [BatComplex]
of_string [BatBool]
Convert the given string to a boolean.
of_string [BatBig_int]
of_table [BatHashtbl.Cap]
Adopt a regular hashtable as a capability hashtble, allowing to decrease capabilities if necessary.
of_uchar [BatRope]
of_uchar c returns a rope containing exactly character c.
of_ustring [BatRope]
of_string s returns a rope corresponding to the string s.
ok [BatStd]
f x |> ok unwraps the Ok result of f x and returns it, or throws the exception contained if Bad is returned.
on_close_out [BatInnerIO]
Register a function to be triggered just before an output is closed.
on_output [BatStream]
Convert an output to a stream.
one [BatNumber.Numeric]
one [BatNum]
one [BatNativeint]
The native integer 1.
one [BatInt64]
The 64-bit integer 1.
one [BatInt32]
The 32-bit integer 1.
one [BatInt.Safe_int]
The integer 1.
one [BatInt]
The integer 1.
one [BatFloat.Safe_float]
Floating number one.
one [BatFloat]
Floating number one.
one [BatComplex]
The complex number 1.
one [BatBool]
one [BatBig_int]
one_of [BatParserCo]
Accept one of several values.
one_plus [BatParserCo]
Accept a (non-empty) list of expressions
op_letter [BatGenlex.Languages.Definition]
op_start [BatGenlex.Languages.Definition]
open_connection [BatUnix]
Connect to a server at the given address.
open_in [BatPervasives]
Open the named file for reading.
open_in [BatFile]
open_in file_name opens the file named file_name for reading.
open_in_bin [BatPervasives]
Same as Pervasives.open_in, but the file is opened in binary mode, so that no translation takes place during reads.
open_in_gen [BatPervasives]
open_in mode perm filename opens the named file for reading, as described above.
open_out [BatPervasives]
Open the named file for writing, and return a new output channel on that file.
open_out [BatFile]
open_out file_name opens the file named file_name for writing.
open_out_bin [BatPervasives]
Same as BatPervasives.open_out, but the file is opened in binary mode, so that no translation takes place during writes.
open_out_gen [BatPervasives]
open_out_gen mode perm filename opens the named file for writing, as described above.
open_process [BatUnix]
Same as Unix.open_process_out, but redirects both the standard input and standard output of the command to pipes connected to the two returned input/output.
open_process_full [BatUnix]
Similar to Unix.open_process, but the second argument specifies the environment passed to the command.
open_process_in [BatUnix]
High-level pipe and process management.
open_process_out [BatUnix]
Same as Unix.open_process_in, but redirect the standard input of the command to a pipe.
open_temporary_out [BatFile]
open_temporary_out () opens a new temporary file for writing.
operations [BatNumber.Numeric]
operations [BatNum]
operations [BatNativeint]
operations [BatInt.Safe_int]
operations [BatInt]
operations [BatFloat.Safe_float]
operations [BatFloat]
operations [BatComplex]
operations [BatBool]
operations [BatBig_int]
opt [BatOptParse.Opt]
Get the value of an option as an optional value.
opt [BatGlobal]
Return None if the global is undefined, else Some v where v is the current global value contents.
other_exec [BatFile]
Give the permission to execute the file to the rest of the world.
other_read [BatFile]
Give the permission to read the file to the rest of the world.
other_write [BatFile]
Give the permission to modify the file to the rest of the world.
out_channel_of_descr [BatUnix]
out_of_range [BatUTF8.Byte]
out_of_range [BatUTF8]
out_of_range s i tests whether i is a position inside of s.
output [BatPervasives]
output oc buf pos len writes len characters from string buf, starting at offset pos, to the given output channel oc.
output [BatMarshal]
output out v writes the representation of v on chan.
output [BatInnerIO]
output o s p l writes up to l characters from string s, starting at offset p.
output [BatIO]
output o s p l writes up to l characters from string s, starting at offset p.
output [BatDigest]
Write a digest on the given output.
output_binary_int [BatPervasives]
Write one integer in binary format (4 bytes, big-endian) on the given output channel.
output_bits [BatIO]
Write bits to an output
output_buffer [BatInnerIO]
Create an output that will append its results at the end of a buffer in an efficient way.
output_buffer [BatIO]
Create an output that will append its results at the end of a buffer in an efficient way.
output_buffer [BatBuffer]
output_buffer oc b writes the current contents of buffer b on the output channel oc.
output_byte [BatPervasives]
Write one 8-bit integer (as the single character with that code) on the given output channel.
output_channel [BatInnerIO]
Create an output that will write into a channel.
output_channel [BatIO]
Create an output that will write into a channel.
output_char [BatPervasives]
Write the character on the given output channel.
output_enum [BatIO]
Create an output that will write into an enum.
output_file [BatStd]
creates a filename, write text into it and close it.
output_of_descr [BatUnix]
Create an output writing on the given descriptor.
output_rope [BatPervasives]
Write the rope on the given output channel.
output_string [BatPervasives]
Write the string on the given output channel.
output_string [BatInnerIO]
Create an output that will write into a string in an efficient way.
output_string [BatIO]
Create an output that will write into a string in an efficient way.
output_value [BatPervasives]
Write the representation of a structured value of any type to a channel.

P
p [BatPathGen.PathType]
pack [BatInt32]
pack str off i writes the little endian bit representation of i into string str at offset off
pack_big [BatInt32]
pack_big str off i writes the big endian bit representation of i into string str at offset off
params [BatOo.Oo.Internal]
parent [BatPathGen.PathType]
Returns parent path, i.e.
parse [BatUCharParser]
Apply a parser to a Unicode Rope.
parse [BatOptParse.OptParser]
Parse arguments as if the arguments args.(first), args.(first+1), ..., args.(last) had been given on the command line.
parse [BatCharParser]
Apply a parser to a string.
parse_argv [BatOptParse.OptParser]
Parse all the arguments in Sys.argv.
partition [BatVect.Make]
partition p a returns a pair of arrays (a1, a2), where a1 is the array of all the elements of a that satisfy the predicate p, and a2 is the array of all the elements of a that do not satisfy p.
partition [BatVect]
partition p a returns a pair of arrays (a1, a2), where a1 is the array of all the elements of a that satisfy the predicate p, and a2 is the array of all the elements of a that do not satisfy p.
partition [BatSet.S.Labels]
partition [BatSet.S]
partition p s returns a pair of sets (s1, s2), where s1 is the set of all the elements of s that satisfy the predicate p, and s2 is the set of all the elements of s that do not satisfy p.
partition [BatPSet]
returns two disjoint subsets, those that satisfy the given predicate and those that don't
partition [BatPMap]
Divides a map into two maps based on a test function
partition [BatList.Labels]
partition [BatList]
partition p l returns a pair of lists (l1, l2), where l1 is the list of all the elements of l that satisfy the predicate p, and l2 is the list of all the elements of l that do not satisfy p.
partition [BatISet]
partition [BatArray.Cap]
partition p a returns a pair of arrays (a1, a2), where a1 is the array of all the elements of a that satisfy the predicate p, and a2 is the array of all the elements of a that do not satisfy p.
partition [BatArray]
partition p a returns a pair of arrays (a1, a2), where a1 is the array of all the elements of a that satisfy the predicate p, and a2 is the array of all the elements of a that do not satisfy p.
pass [BatPrintexc]
Printexc.pass fn x applies fn to x and returns the result.
peek [BatQueue.Queue]
peek q returns the first element in queue q, without removing it from the queue, or raises Empty if the queue is empty.
peek [BatPervasives]
peek e returns None if e is empty or Some x where x is the next element of e.
peek [BatLazyList]
peek l returns the first element of l, if it exists.
peek [BatEnum]
peek e returns None if e is empty or Some x where x is the next element of e.
perm [BatFile]
Join permissions
pi [BatFloat.Safe_float]
The constant pi (3.14159...)
pi [BatFloat]
The constant pi (3.14159...)
pipe [BatInnerIO]
Create a pipe between an input and an ouput.
pipe [BatIO]
Create a pipe between an input and an ouput.
polar [BatComplex]
polar norm arg returns the complex having norm norm and argument arg.
pop [BatVect]
Return the last element of a vector and its first n-1 elements.
pop [BatRefList]
Removes and returns the first element or raises Empty_list if the ref list is empty
pop [BatQueue.Queue]
pop is a synonym for take.
pop [BatPSet]
returns one element of the set and the set without that element.
pop [BatPMap]
pop m returns a binding from m and m without that binding.
pos_in [BatIO]
Create an input that provide a count function of the number of bytes read from it.
pos_out [BatIO]
Create an output that provide a count function of the number of bytes written through it.
post [BatRef]
Perform an operation on a reference and return the previous value of that reference.
post_decr [BatRef]
Decrement an integer, return the old value.
post_incr [BatRef]
Increment an integer, return the old value.
post_map [BatParserCo]
Maps
pow [BatNumber.Numeric]
pow [BatNum]
pow [BatNativeint]
pow [BatInt32]
pow [BatInt.Safe_int]
pow a b computes ab
pow [BatInt]
pow a b computes ab
pow [BatFloat.Safe_float]
pow [BatFloat]
pow [BatComplex]
Power function.
pow [BatBool]
pow [BatBig_int]
power_big_int_positive_big_int [BatBig_int]
Exponentiation functions.
power_big_int_positive_int [BatBig_int]
power_int_positive_big_int [BatBig_int]
power_int_positive_int [BatBig_int]
pp_set_formatter_out_channel [BatFormat]
pp_set_formatter_output [BatFormat]
Deprecated
pre [BatRef]
Perform an operation on a reference and return the new value of that reference.
pre_decr [BatRef]
Increment an integer, return the new value.
pre_incr [BatRef]
Increment an integer, return the new value.
pred [BatNumber.Discrete]
pred [BatNum]
pred [BatNativeint]
Predecessor.
pred [BatInt64]
Predecessor.
pred [BatInt32]
Predecessor.
pred [BatInt.Safe_int]
Predecessor.
pred [BatInt]
Predecessor.
pred [BatFloat.Safe_float]
Substract 1. from a floating number.
pred [BatFloat]
Substract 1. from a floating number.
pred [BatComplex]
Remove BatComplex.one from this number.
pred [BatBool]
pred [BatBig_int]
prefix_action [BatEnum]
prefix_action f e will behave as e but guarantees that f () will be invoked exactly once before the current first element of e is read.
prepend [BatVect.Make]
prepend c r returns a new vect with the c character at the beginning in amortized O(1) time.
prepend [BatVect]
prepend c r returns a new vect with the c character at the beginning in amortized O(1) time.
prepend [BatDllist]
prepend n a Creates a new node containing data a and inserts it into the list before node n.
prepend_char [BatRope]
prepend_char c r returns a new rope with the c character at the beginning in amortized O(1) time.
prerr_all [BatPervasives]
Print the contents of an input to the error output.
prerr_bool [BatStd]
Print a boolean to stderr.
prerr_bool [BatPervasives]
Print a boolean to stderr.
prerr_guess [BatPervasives]
Attempt to print the representation of a runtime value on the error output.
prev [BatUTF8.Byte]
prev [BatUTF8]
prev s i returns the position of the head of the Unicode character located immediately before i.
prev [BatDllist]
Given a node, get the previous element in the list before the node.
print [BatVect.Make]
Printing
print [BatVect]
print [BatUnit]
Printing
print [BatUTF8]
Printing
print [BatUChar]
Printing
print [BatString]
Print a string.
print [BatStd]
print the representation of a runtime value on stdout.
print [BatStack]
print [BatSet.S]
print [BatSeq]
Print the contents of a sequence
print [BatRope]
print [BatRef]
print [BatQueue.Queue]
print [BatPrintexc]
Print an exception.
print [BatPervasives]
Print and consume the contents of an enumeration.
print [BatPair]
Prints a pair using given printing functions
print [BatPSet]
print [BatPMap]
print [BatOption]
print [BatNum]
Printing
print [BatNativeint]
print [BatMultiPMap]
print [BatMap.S]
print [BatList]
Print the contents of a list
print [BatLazyList]
print [BatInt.Safe_int]
print [BatInt]
print [BatHashtbl.Cap]
print [BatHashtbl.S]
print [BatHashtbl]
print [BatFloat.Safe_float]
Printing
print [BatFloat]
Printing
print [BatEnum]
Print and consume the contents of an enumeration.
print [BatDynArray]
print [BatDllist]
print [BatComplex]
Printing
print [BatChar]
print [BatBuffer]
print [BatBool]
Printing
print [BatBitSet]
print [BatBig_int]
print [BatArray.Cap]
Print the contents of an array
print [BatArray]
Print the contents of an array
print_all [BatPervasives]
Print the contents of an input to the standard output.
print_bool [BatStd]
Print a boolean to stdout.
print_bool [BatPervasives]
Print a boolean on standard output.
print_guess [BatPervasives]
Attempt to print the representation of a runtime value on the standard output.
print_quoted [BatString]
Print a string, with quotes.
print_rope [Batteries_print]
Pretty-print a Rope.t
print_stat [BatGc]
Print the current values of the memory management counters (in human-readable form) into the channel argument.
print_string_cap_ro [Batteries_print]
Pretty-print a read-only String.Cap.t (prefixes output with "ro")
print_string_cap_rw [Batteries_print]
Pretty-print a read-write String.Cap.t (prefixes output with "rw")
print_tuple0 [BatValue_printer]
print_tuple1 [BatValue_printer]
print_tuple10 [BatValue_printer]
print_tuple2 [BatValue_printer]
print_tuple3 [BatValue_printer]
print_tuple4 [BatValue_printer]
print_tuple5 [BatValue_printer]
print_tuple6 [BatValue_printer]
print_tuple7 [BatValue_printer]
print_tuple8 [BatValue_printer]
print_tuple9 [BatValue_printer]
print_uchar [Batteries_print]
Pretty-print a UChar.t
print_ustring [Batteries_print]
Pretty-print a UTF8.t
printf [BatPrintf]
The usual printf function, prints to the standard output stdout, i.e.
printf [BatPrint]
printf fmt args formats the arguments in args as specified by fmt and prints the result on the standard output BatIO.stdout, i.e.
printf [BatInnerIO.Printf]
The usual printf function, prints to the standard output BatInnerIO.stdout, i.e.
printf [BatIO]
A fprintf-style unparser.
println [BatString]
Print a string, end the line.
progress_in [BatIO]
progress_in inp f create an input that calls f () whenever some content is succesfully read from it.
progress_out [BatIO]
progress_out out f create an output that calls f () whenever some content is succesfully written to it.
promote [BatDllist]
promote n Swaps n with next n.
protect [BatRef]
Assign a reference temporarily.
public_method_label [BatOo.Oo.Internal]
push [BatRefList]
Adds an element at the head - O(1)
push [BatQueue.Queue]
push is a synonym for add.
push [BatPervasives]
push e x will add x at the beginning of e.
push [BatEnum]
push e x will add x at the beginning of e.
put [BatBitSet]
put s v n sets the nth-bit in the bitset s to v.

Q
quo [BatNum]
Additional operations
quomod_big_int [BatBig_int]
Euclidean division of two big integers.
quote [BatString]
Add quotes around a string and escape any quote appearing in that string.
quote [BatStr.Str]
Str.quote s returns a regexp string that matches exactly s and nothing else.

R
range [BatParserCo]
Accept any element from a given range.
range [BatLazyList]
Compute lazily a range of integers a ..
range [BatEnum]
Utilities
range [BatChar]
range_iter [BatRope]
rangeiter f m n r applies f to all the characters whose indices k satisfy m <= k < m + n.
range_iteri [BatRope]
As range_iter, but passes base + index of the character in the subrope defined by next to arguments.
rangeiter [BatVect.Make]
rangeiter f m n r applies f to all the elements whose indices k satisfy m <= k < m + n.
rangeiter [BatVect]
rangeiter f m n r applies f to all the elements whose indices k satisfy m <= k < m + n.
ranges [BatISet]
ratio_of_num [BatNum]
rchop [BatString]
Returns the same string but without the last character.
rchop [BatRope]
Returns the same rope but without the last character.
rcontains_from [BatUTF8]
rcontains_from [BatRope]
rcontains_from s stop c tests if character c appears in the subrope of s starting from the beginning of s to index stop.
read [BatInnerIO]
Read a single char from an input or raise No_more_input if no input available.
read [BatIO]
Read a single char from an input or raise No_more_input if no input is available.
read_all [BatInnerIO]
read all the contents of the input until No_more_input is raised.
read_all [BatIO]
read all the contents of the input until No_more_input is raised.
read_bits [BatIO]
Read up to 31 bits, raise Bits_error if n < 0 or n > 31
read_byte [BatInnerIO]
Read an unsigned 8-bit integer.
read_byte [BatIO]
Read an unsigned 8-bit integer.
read_double [BatInnerIO]
Read an IEEE double precision floating point value.
read_double [BatIO.BigEndian]
Read an IEEE double precision floating point value.
read_double [BatIO]
Read an IEEE double precision floating point value.
read_float [BatInnerIO]
Read an IEEE single precision floating point value.
read_float [BatIO.BigEndian]
Read an IEEE single precision floating point value.
read_float [BatIO]
Read an IEEE single precision floating point value.
read_i16 [BatInnerIO]
Read a signed 16-bit word.
read_i16 [BatIO.BigEndian]
Read a signed 16-bit word.
read_i16 [BatIO]
Read a signed 16-bit word.
read_i32 [BatInnerIO]
Read a signed 32-bit integer.
read_i32 [BatIO.BigEndian]
Read a signed 32-bit integer.
read_i32 [BatIO]
Read a signed 32-bit integer.
read_i64 [BatInnerIO]
Read a signed 64-bit integer as an OCaml int64.
read_i64 [BatIO.BigEndian]
Read a signed 64-bit integer as an OCaml int64.
read_i64 [BatIO]
Read a signed 64-bit integer as an OCaml int64.
read_line [BatInnerIO]
Read a LF or CRLF terminated string.
read_line [BatIO]
Read a LF or CRLF terminated string.
read_only [BatHashtbl.Cap]
Drop to read-only permissions.
read_only [BatArray.Cap]
Drop to read-only permissions.
read_real_i32 [BatInnerIO]
Read a signed 32-bit integer as an OCaml int32.
read_real_i32 [BatIO.BigEndian]
Read a signed 32-bit integer as an OCaml int32.
read_real_i32 [BatIO]
Read a signed 32-bit integer as an OCaml int32.
read_rope [BatIO]
Read up to n uchars from a UTF-8 encoded input
read_signed_byte [BatInnerIO]
Read an signed 8-bit integer.
read_signed_byte [BatIO]
Read an signed 8-bit integer.
read_string [BatInnerIO]
Read a null-terminated string.
read_string [BatIO]
Read a null-terminated string.
read_uall [BatIO]
Read the whole contents of a UTF-8 encoded input
read_uchar [BatIO]
Read one UChar from a UTF-8 encoded input
read_ui16 [BatInnerIO]
Read an unsigned 16-bit word.
read_ui16 [BatIO.BigEndian]
Read an unsigned 16-bit word.
read_ui16 [BatIO]
Read an unsigned 16-bit word.
read_uline [BatIO]
Read a line of UTF-8
real_i32s_of [BatIO.BigEndian]
Read an enumeration of signed 32-bit integers as OCaml int32s.
real_i32s_of [BatIO]
Read an enumeration of signed 32-bit integers as OCaml int32s.
really_input [BatPervasives]
really_input ic buf pos len reads len characters from channel ic, storing them in string buf, starting at character number pos.
really_input [BatInnerIO]
really_input i s p l reads exactly l characters from the given input, storing them in the string s, starting at position p.
really_input [BatIO]
really_input i s p l reads exactly l characters from the given input, storing them in the string s, starting at position p.
really_nread [BatInnerIO]
really_nread i n reads a string of exactly n characters from the input.
really_nread [BatIO]
really_nread i n reads a string of exactly n characters from the input.
really_output [BatInnerIO]
really_output o s p l writes exactly l characters from string s onto the the output, starting with the character at offset p.
really_output [BatIO]
really_output o s p l writes exactly l characters from string s onto the the output, starting with the character at offset p.
reduce [BatVect]
as BatVect.fold_left, but no initial value - just applies reducing function to elements from left to right.
reduce [BatSeq.Exceptionless]
reduce [BatSeq]
reduce f (cons e s) is fold_left f e s.
reduce [BatPervasives]
Transformation loop on an enumeration, used to build a single value from an enumeration.
reduce [BatList]
List.reduce f h::t is fold_left f h t.
reduce [BatEnum]
A simplified version of fold, which uses the first element of the enumeration as a default value.
reduce [BatArray]
Array.reduce f a is fold_left f a.(0) a.(1 .. n-1).
ref [BatRef]
Return a fresh reference containing the given value.
regexp [BatStr.Str]
Compile a regular expression.
regexp_case_fold [BatStr.Str]
Same as regexp, but the compiled expression will match text in a case-insensitive way: uppercase and lowercase letters will be considered equivalent.
regexp_string [BatStr.Str]
Str.regexp_string s returns a regular expression that matches exactly s and nothing else.
regexp_string_case_fold [BatStr.Str]
Str.regexp_string_case_fold is similar to BatStr.Str.regexp_string, but the regexp matches in a case-insensitive way.
register_formatter [BatLogger]
register_formatter name formatter registers a named log formatter.
relative_to_any [BatPathGen.PathType]
relative_to_any base sub returns relative path rel such that normalize (base/:rel) = normalize sub, i.e.
relative_to_parent [BatPathGen.PathType]
relative_to_parent parent sub returns relative path rel such that (normalize parent)/:rel = normalize sub.
rem [BatNativeint]
Integer remainder.
rem [BatInt64]
Integer remainder.
rem [BatInt32]
Integer remainder.
rem [BatInt.Safe_int]
Integer remainder.
rem [BatInt]
Integer remainder.
remove [BatVect.Make]
remove m n r returns the vect resulting from deleting the elements with indexes ranging from m to m + n - 1 (included) from the original vect r.
remove [BatVect]
remove m n r returns the vect resulting from deleting the elements with indexes ranging from m to m + n - 1 (included) from the original vect r.
remove [BatSet.S]
remove x s returns a set containing all elements of s, except x.
remove [BatRope]
remove m n r returns the rope resulting from deleting the characters with indexes ranging from m to m + n - 1 (included) from the original rope r.
remove [BatRefList]
Remove an element from the ref list raise Not_found if the element is not found
remove [BatPSet]
remove x s returns a set containing all elements of s, except x.
remove [BatPMap]
remove x m returns a map containing the same bindings as m, except for x which is unbound in the returned map.
remove [BatMultiPMap]
remove k d m returns a map containing the same bindings as m, except for k which is not bound to d anymore in the returned map.
remove [BatMap.S]
remove x m returns a map containing the same bindings as m, except for x which is unbound in the returned map.
remove [BatList]
remove l x returns the list l without the first element x found or returns l if no element is equal to x.
remove [BatLazyList]
remove l x returns the list l without the first element x found or returns l if no element is equal to x.
remove [BatInnerWeaktbl]
Weaktbl.remove tbl x removes the current binding of x in tbl, restoring the previous binding if it exists.
remove [BatISet]
remove [BatIMap]
remove [BatHashtbl.Cap]
Hashtbl.remove tbl x removes the current binding of x in tbl, restoring the previous binding if it exists.
remove [BatHashtbl.S]
remove [BatHashtbl]
Hashtbl.remove tbl x removes the current binding of x in tbl, restoring the previous binding if it exists.
remove [BatDllist]
Remove node from the list no matter where it is.
remove_all [BatRefList]
Remove all elements equal to the specified element from the ref list
remove_all [BatMultiPMap]
remove_all x m returns a map containing the same bindings as m, except for x which is unbound in the returned map.
remove_all [BatList]
remove_all l x is similar to remove but removes all elements that are equal to x and not only the first one.
remove_all [BatLazyList]
remove_all l x is similar to remove but removes all elements that are equal to x and not only the first one.
remove_all [BatHashtbl.Cap]
Remove all bindings for the given key
remove_all [BatHashtbl.S]
remove_all [BatHashtbl]
Remove all bindings for the given key
remove_all_such [BatLazyList.Labels]
remove_all_such [BatLazyList]
remove_all l x is similar to remove but removes all elements that are equal to x and not only the first one.
remove_assoc [BatList]
remove_assoc a l returns the list of pairs l without the first pair with key a, if any.
remove_assq [BatList]
Same as List.remove_assoc, but uses physical equality instead of structural equality to compare keys.
remove_at [BatRefList.Index]
Remove the element at the specified index raise Invalid_index if the index is outside 0 ; length-1
remove_if [BatRefList]
Remove the first element matching the specified predicate raise Not_found if no element has been removed
remove_if [BatList.Labels]
remove_if [BatList]
remove_if cmp l is similar to remove, but with cmp used instead of ( = ).
remove_if [BatLazyList.Labels]
remove_if [BatLazyList]
remove_if cmp l is similar to remove, but with cmp used instead of ( = ).
remove_range [BatISet]
remove_range [BatIMap]
repeat [BatString]
repeat s n returns s ^ s ^ ... ^ s
repeat [BatEnum]
repeat ~times:n x creates a enum sequence filled with n times of x.
replace [BatString]
replace ~str ~sub ~by returns a tuple constisting of a boolean and a string where the first occurrence of the string sub within str has been replaced by the string by.
replace [BatRope]
replace ~str ~sub ~by returns a tuple constisting of a boolean and a rope where the first occurrence of the rope sub within str has been replaced by the rope by.
replace [BatInnerWeaktbl]
Weaktbl.replace tbl x y replaces the current binding of x in tbl by a binding of x to y.
replace [BatHashtbl.Cap.Labels]
replace [BatHashtbl.Cap]
Hashtbl.replace tbl x y replaces the current binding of x in tbl by a binding of x to y.
replace [BatHashtbl.S.Labels]
replace [BatHashtbl.S]
replace [BatHashtbl.Labels]
replace [BatHashtbl]
Hashtbl.replace tbl x y replaces the current binding of x in tbl by a binding of x to y.
replace_chars [BatString]
replace_chars f s returns a string where all chars c of s have been replaced by the string returned by f c.
replace_chars [BatRope]
replace_chars f s returns a rope where all chars c of s have been replaced by the rope returned by f c.
replace_first [BatStr.Str]
Same as BatStr.Str.global_replace, except that only the first substring matching the regular expression is replaced.
replace_matched [BatStr.Str]
replace_matched repl s returns the replacement text repl in which \1, \2, etc.
reserved_names [BatGenlex.Languages.Definition]
reset [BatUTF8.Buf]
Empty the buffer and de-allocate the internal storage.
reshape [BatBigarray]
reshape b [|d1;...;dN|] converts the big array b to a N-dimensional array of dimensions d1...
reshape_1 [BatBigarray]
Specialized version of Bigarray.reshape for reshaping to one-dimensional arrays.
reshape_2 [BatBigarray]
Specialized version of Bigarray.reshape for reshaping to two-dimensional arrays.
reshape_3 [BatBigarray]
Specialized version of Bigarray.reshape for reshaping to three-dimensional arrays.
return [BatReturn]
Return to a label.
return [BatParserCo]
A parser which always succeds
return [BatOption.Monad]
return x puts a value in the Option monad, that is, returns Some x.
return [BatMonad.S]
Return a value, that is, put a value in the monad.
return [BatEnum.Monad]
This function puts a single value in the BatEnum monad, that is to say it creates an enumeration containing a single element.
rev [BatRefList]
Reverses the ref list - O(n)
rev [BatLazyList]
Eager list reversal.
rev [BatDllist]
List reversal.
rev [BatArray.Cap]
Array transformations
rev [BatArray]
Array reversal.
rev_append [BatLazyList]
Eager reverse-and-append
rev_drop [BatDllist]
Remove node from the list no matter where it is.
rev_enum [BatDllist]
Create a reverse enum of the list.
rev_in_place [BatArray.Cap]
In-place array reversal.
rev_in_place [BatArray]
In-place array reversal.
rev_map [BatList.Labels]
rev_map2 [BatList.Labels]
rfind [BatString]
rfind s x returns the starting index of the last occurrence of string x within string s.
rfind [BatRope]
rfind s x returns the starting index of the last occurrence of rope x within rope s.
rfind [BatRefList]
Find the first element in the reversed ref list matching the specified predicate raise Not_found if no element is found
rfind [BatList.Labels.LExceptionless]
rfind [BatList.Labels]
rfind [BatList.Exceptionless]
rfind p l returns Some x where x is the last element of l such that p x returns true or None if such element as not been found.
rfind [BatList]
rfind p l returns the last element x of l such as p x returns true or raises Not_found if such element as not been found.
rfind [BatLazyList.Labels.Exceptionless]
rfind [BatLazyList.Labels]
rfind [BatLazyList.Exceptionless]
rfind p l returns Some x where x is the last element of l such that p x returns true or None if such element as not been found.
rfind [BatLazyList]
rfind p l returns the last element x of l such as p x returns true or raises Not_found if such element as not been found.
rfind_exn [BatLazyList.Labels]
rfind_exn [BatLazyList]
find_exn p e l returns the last element of l such as p x returns true or raises e if such an element has not been found.
rfind_from [BatString]
rfind_from s ofs x behaves as rfind s x but starts searching at offset ofs.
rfind_from [BatRope]
rfind_from s ofs x behaves as rfind s x but starts searching at offset ofs.
rfindi [BatLazyList.Labels.Exceptionless]
rfindi [BatLazyList.Labels]
rfindi [BatLazyList.Exceptionless]
findi p e l returns Some (i, ai) where ai and i are respectively the last element of l and its index, such that p i ai is true, or None if no such element has been found.
rfindi [BatLazyList]
findi p e l returns the last element ai of l along with its index i such that p i ai is true, or raises Not_found if no such element has been found.
right [BatString]
left r len returns the string containing the len last characters of r
right [BatRope]
left r len returns the rope containing the len last characters of r
right_branch [BatAvlTree]
rindex [BatUTF8]
As String.rindex
rindex [BatRope]
Rope.rindex s c returns the position of the rightmost occurrence of character c in rope s.
rindex [BatPathGen.StringType]
rindex_from [BatRope]
Same as BatRope.rindex, but start searching at the character position given as second argument.
rindex_of [BatList]
rindex_of e l returns the index of the last occurrence of e in l, or None if there is no occurrence of e in l
rindex_of [BatLazyList]
index_of e l returns the index of the last occurrence of e in l, or None if there is no occurrence of e in l
rindex_ofq [BatList]
rindex_ofq e l behaves as rindex_of e l except it uses physical equality
rindex_ofq [BatLazyList]
rindex_ofq e l behaves as rindex_of e l except it uses physical equality
root [BatPathGen.PathType]
Root of the filesystem ([""]).
root [BatAvlTree]
rope [BatUCharParser]
Recognize exactly one string
round [BatNum]
rprintf [BatPrint]
rprintf fmt returns the result as a rope
rsplit [BatString]
rsplit s sep splits the string s between the last occurrence of sep.
rsplit [BatRope]
rsplit s sep splits the rope s between the last occurrence of sep.
run [BatParserCo]
run p s executes parser p on source s.
run_initializers [BatOo.Oo.Internal]
run_initializers_opt [BatOo.Oo.Internal]

S
s [BatPathGen.PathType]
sat [BatParserCo]
Others
satisfy [BatParserCo]
satisfy p accepts one value p x such that p x = true
scan [BatStream.StreamLabels]
scan is similar to scanl but without the init value: scan f [<'e1;'e2;..>] = [<'e1;'(f e1 e2);..>].
scan [BatStream]
scan is similar to scanl but without the init value: scan f [<'e1;'e2;..>] = [<'e1;'(f e1 e2);..>].
scan [BatParserCo]
Use a parser to extract list of tokens, but return that list of tokens instead of whatever the original parser returned.
scan [BatEnum]
scan is similar to scanl but without the init value: if e contains x1, x2, x3 ..., scan f e is the enumeration containing x1, f x1 x2, f (f x1 x2) x3...
scanf [BatScanf]
Same as Scanf.bscanf, but reads from the predefined scanning buffer Scanf.Scanning.stdib that is connected to stdin.
scanl [BatStream.StreamLabels]
scanl f init stream returns a stream of successive reduced values from the left: scanl f init [<'e1;'e2;..>] = [<'init; '((f init e1) as e1'); '(f e1' e2); ..>]
scanl [BatStream]
scanl f init stream returns a stream of successive reduced values from the left: scanl f init [<'e1;'e2;..>] = [<'init; '((f init e1) as e1'); '(f e1' e2); ..>]
scanl [BatPervasives]
Functional loop on an enumeration, used to build an enumeration from both an enumeration and an initial value.
scanl [BatEnum]
A variant of fold producing an enumeration of its intermediate values.
script [BatUChar]
search [BatStr.Str]
search r s searches for all the substrings of s matching regular expression r.
search_backward [BatStr.Str]
search_backward r s last searches the string s for a substring matching the regular expression r.
search_forward [BatStr.Str]
search_forward r s start searches the string s for a substring matching the regular expression r.
second [BatStd]
Projection of a pair to its second element.
second [BatPervasives]
Apply a function to the second element of a pair.
self_init [BatRandom]
Initialize the generator with a more-or-less random seed chosen in a system-dependent way.
send [BatOo.Oo.Internal]
sendcache [BatOo.Oo.Internal]
sendself [BatOo.Oo.Internal]
seq [BatLazyList]
seq init step cond creates a sequence of data, which starts from init, extends by step, until the condition cond fails.
seq [BatEnum.Labels]
seq [BatEnum]
seq init step cond creates a sequence of data, which starts from init, extends by step, until the condition cond fails.
sequence [BatEnum.WithMonad]
sequence e evaluates each monadic elements (of type 'a m contained in the enumeration e to get a monadic enumeration of 'a elements, of type 'a m BatEnum.t.
set [BatVect.RANDOMACCESS]
set [BatVect.Make]
set r n c returns a copy of the r vect where the (n+1)th element (see also get) has been set to c.
set [BatVect]
set v n c returns a copy of the v vect where the (n+1)th element (see also get) has been set to c.
set [BatRope]
set r n c returns a copy of rope r where the (n+1)th character has been set to c.
set [BatRefList.Index]
Change the element at the specified index raise Invalid_index if the index is outside 0 ; length-1
set [BatRef]
As :=
set [BatOptParse.Opt]
Set the value of an option.
set [BatGlobal]
Set the global value contents.
set [BatDynArray]
set darr idx v sets the element of darr at index idx to value v.
set [BatDllist]
Given a node, set the data associated with that node.
set [BatBitSet]
set s n sets the nth-bit in the bitset s to true.
set [BatBigarray.Array3]
Array3.set a x y v, or alternatively a.{x,y,z} <- v, stores the value v at coordinates (x, y, z) in a.
set [BatBigarray.Array2]
Array2.set a x y v, or alternatively a.{x,y} <- v, stores the value v at coordinates (x, y) in a.
set [BatBigarray.Array1]
Array1.set a x v, also written a.{x} <- v, stores the value v at index x in a.
set [BatBigarray.Genarray]
Assign an element of a generic big array.
set [BatArray.Cap]
Array.set a n x modifies array a in place, replacing element number n with x.
set [BatArray]
Array.set a n x modifies array a in place, replacing element number n with x.
set_browser [Batteries_config]
set_browser f replaces the default browser with a function f.
set_formatter_out_channel [BatFormat]
Redirect the pretty-printer output to the given channel.
set_formatter_output [BatFormat]
set_full_state [BatParserCo.Source]
set_method [BatOo.Oo.Internal]
set_methods [BatOo.Oo.Internal]
set_permissions [BatFile]
Set the permissions on a file.
set_resizer [BatDynArray]
Change the resizer for this array.
set_state [BatRandom]
Set the state of the generator used by the basic functions.
set_to_map [BatIMap]
shift [BatVect]
Return the first element of a vector and its last n-1 elements.
shift_left [BatNativeint]
Nativeint.shift_left x y shifts x to the left by y bits.
shift_left [BatInt64]
Int64.shift_left x y shifts x to the left by y bits.
shift_left [BatInt32]
Int32.shift_left x y shifts x to the left by y bits.
shift_right [BatNativeint]
Nativeint.shift_right x y shifts x to the right by y bits.
shift_right [BatInt64]
Int64.shift_right x y shifts x to the right by y bits.
shift_right [BatInt32]
Int32.shift_right x y shifts x to the right by y bits.
shift_right_logical [BatNativeint]
Nativeint.shift_right_logical x y shifts x to the right by y bits.
shift_right_logical [BatInt64]
Int64.shift_right_logical x y shifts x to the right by y bits.
shift_right_logical [BatInt32]
Int32.shift_right_logical x y shifts x to the right by y bits.
should [BatParserCo]
Prevent backtracking.
shuffle [BatRandom]
shuffle e returns a new array, containing the same set of elements as e, but in a random order.
shutdown_connection [BatUnix]
``Shut down'' a connection established with Unix.open_connection; that is, transmit an end-of-file condition to the server reading on the other side of the connection.
sign [BatNum]
Return -1, 0 or 1 according to the sign of the argument.
sign_big_int [BatBig_int]
Return 0 if the given big integer is zero, 1 if it is positive, and -1 if it is negative.
signed_bytes_of [BatIO]
Read an enumeration of signed 8-bit integers.
sin [BatFloat.Safe_float]
sin [BatFloat]
singleton [BatVect.Make]
Returns a vect of length 1 holding only the given element.
singleton [BatVect]
Returns a Vect of length 1 holding only the given element.
singleton [BatSet.S]
singleton x returns the one-element set containing only x.
singleton [BatISet]
singleton [BatEnum]
Create an enumeration consisting in exactly one element.
singleton_tree [BatAvlTree]
sinh [BatFloat.Safe_float]
sinh [BatFloat]
size [BatSubstring]
size (s, i, n) returns the size of the substring, that is, n.
size [BatNativeint]
The size in bits of a native integer.
size_of [BatFile]
size_of name returns the size of file name in bytes.
size_of_big [BatFile]
size_of_big name returns the size of file name in bytes, as a 64-bit integer.
skip [BatEnum]
skip n e removes the first n element from the enumeration, if any, then returns e.
skip [BatDllist]
skip n i Return the node that is i nodes after node n in the list.
slice [BatSubstring]
slice (sus, i', NONE) returns the substring (s, i+i', n-i'), where sus = (s, i, n).
slice [BatString]
slice ?first ?last s returns a "slice" of the string which corresponds to the characters s.[first], s.[first+1], ..., s[last-1].
slice [BatRope]
slice ?first ?last s returns a "slice" of the rope which corresponds to the characters s.[first], s.[first+1], ..., s[last-1].
slice_left [BatBigarray.Array2]
Extract a row (one-dimensional slice) of the given two-dimensional big array.
slice_left [BatBigarray.Genarray]
Extract a sub-array of lower dimension from the given big array by fixing one or several of the first (left-most) coordinates.
slice_left_1 [BatBigarray.Array3]
Extract a one-dimensional slice of the given three-dimensional big array by fixing the first two coordinates.
slice_left_2 [BatBigarray.Array3]
Extract a two-dimensional slice of the given three-dimensional big array by fixing the first coordinate.
slice_right [BatBigarray.Array2]
Extract a column (one-dimensional slice) of the given two-dimensional big array.
slice_right [BatBigarray.Genarray]
Extract a sub-array of lower dimension from the given big array by fixing one or several of the last (right-most) coordinates.
slice_right_1 [BatBigarray.Array3]
Extract a one-dimensional slice of the given three-dimensional big array by fixing the last two coordinates.
slice_right_2 [BatBigarray.Array3]
Extract a two-dimensional slice of the given three-dimensional big array by fixing the last coordinate.
sort [BatRefList]
Sort elements using the specified comparator or compare as default comparator
sort [BatList]
Sort the list using optional comparator (by default compare).
sort [BatLazyList]
Sort the list using optional comparator (by default compare).
sort [BatArray.Labels]
sort [BatArray.Cap.Labels]
sort [BatArray.Cap]
Sort an array in increasing order according to a comparison function.
sort [BatArray]
Sort an array in increasing order according to a comparison function.
sort_unique [BatList]
sort_unique cmp l returns the list l sorted and without any duplicate element.
source [BatPathGen.StringType.Parse]
source_map [BatParserCo]
source_of_enum [BatUCharParser]
Create a source from an enumeration of unicode characters.
source_of_enum [BatCharParser]
Create a source from a latin-1 character.
source_of_rope [BatUCharParser]
Create a source from a Unicode Rope.
source_of_string [BatCharParser]
Create a source from a latin-1 character string.
span [BatSubstring]
span (sus1, sus2) returns a substring spanning from the start of sus1 to the end of sus2, provided this is well-defined: sus1 and sus2 must have the same underlying string, and the start of sus1 must not be to the right of the end of sus2; otherwise raises Span.
span [BatEnum]
span test e produces two enumerations (hd, tl), such that hd is the same as take_while test e and tl is the same as drop_while test e.
splice [BatString]
String.splice s off len rep cuts out the section of s indicated by off and len and replaces it by rep
splice [BatRope]
splice s off len rep returns the rope in which the section of s indicated by off and len has been cut and replaced by rep.
splice [BatDllist]
splice n1 n2 Connects n1 and n2 so that next n1 == n2 && prev n2 == n1.
split [BatString]
split s sep splits the string s between the first occurrence of sep.
split [BatStream]
split is the opposite of comb
split [BatStr.Str]
split r s splits s into substrings, taking as delimiters the substrings that match r, and returns the list of substrings.
split [BatSet.S]
split x s returns a triple (l, present, r), where l is the set of elements of s that are strictly less than x; r is the set of elements of s that are strictly greater than x; present is false if s contains no element equal to x, or true if s contains an element equal to x.
split [BatSeq]
split s = (map fst s, map snd s)
split [BatRope]
split s sep splits the rope s between the first occurrence of sep.
split [BatPathGen.PathType]
Dissect the path to its components (parent path, core part of name and possibly an extension).
split [BatList]
Transform a list of pairs into a pair of lists: split [(a1,b1); ...; (an,bn)] is ([a1; ...; an], [b1; ...; bn]).
split_at [BatSubstring]
splitAt (sus, k) returns the pair (sus1, sus2) of substrings, where sus1 contains the first k characters of sus, and sus2 contains the rest.
split_at [BatList.Labels.LExceptionless]
split_at [BatList.Exceptionless]
Whenever n is inside of l size bounds, split_at n l returns Ok(l1,l2), where l1 contains the first n elements of l and l2 contains the others.
split_at [BatList]
split_at n l returns two lists l1 and l2, l1 containing the first n elements of l and l2 the others.
split_at [BatLazyList.Labels.Exceptionless]
split_at [BatLazyList.Exceptionless]
Whenever n is inside of l size bounds, split_at n l returns `Ok (l1,l2), where l1 contains the first n elements of l and l2 contains the others.
split_at [BatLazyList]
split_at n l returns two lists l1 and l2, l1 containing the first n elements of l and l2 the others.
split_delim [BatStr.Str]
Same as BatStr.Str.split but occurrences of the delimiter at the beginning and at the end of the string are recognized and returned as empty strings in the result.
split_leftmost [BatAvlTree]
split_nth [BatList]
Obsolete.
split_nth [BatLazyList]
Obsolete.
split_on_char [BatSubstring]
split_on_char c ss returns substrings of input ss as divided by c
split_on_comma [BatSubstring]
split_on_dot [BatSubstring]
split_on_pipe [BatSubstring]
split_on_slash [BatSubstring]
split_rightmost [BatAvlTree]
splitl [BatSubstring]
splitl p sus splits sus into a pair (sus1, sus2) of substrings where sus1 is the longest prefix (left substring) all of whose characters satisfy p, and sus2 is the rest.
splitr [BatSubstring]
splitr p sus splits sus into a pair (sus1, sus2) of substrings where sus2 is the longest suffix (right substring) all of whose characters satisfy p, and sus1 is the rest.
sprint [BatSeq]
Using a string printer, print a sequence to a string (as sprintf vs.
sprint [BatList]
Using a string printer, print a list to a string (as sprintf vs.
sprint [BatArray.Cap]
Using a string printer, print an array to a string (as sprintf vs.
sprint [BatArray]
Using a string printer, print an array to a string (as sprintf vs.
sprintf [BatPrintf]
A function which doesn't print its result but returns it as a string.
sprintf [BatPrint]
A function which doesn't print its result but returns it as a string.
sprintf [BatInnerIO.Printf]
A function which doesn't print its result but returns it as a string.
sprintf2 [BatPrintf]
A function which doesn't print its result but returns it as a string.
sprintf2 [BatInnerIO.Printf]
A function which doesn't print its result but returns it as a string.
sqrt [BatComplex]
Square root.
sqrt_big_int [BatBig_int]
sqrt_big_int a returns the integer square root of a, that is, the largest big integer r such that r * r <= a.
square [BatNum]
square_big_int [BatBig_int]
Return the square of the given big integer
sscanf [BatScanf]
Same as Scanf.bscanf, but reads from the given string.
sscanf_format [BatScanf]
Same as Scanf.bscanf_format, but reads from the given string.
stable_sort [BatList.Labels]
stable_sort [BatLazyList]
stable_sort [BatArray.Labels]
stable_sort [BatArray.Cap.Labels]
stable_sort [BatArray.Cap]
Same as Array.sort, but the sorting algorithm is stable (i.e.
stable_sort [BatArray]
Same as Array.sort, but the sorting algorithm is stable (i.e.
start [BatGenlex.Languages.Make]
Medium-level API
starts_with [BatString]
starts_with s x returns true if s is starting with x, false otherwise.
starts_with [BatRope]
starts_with s x returns true if s is starting with x, false otherwise.
state [BatParserCo]
Succeed and return the state of the parser
stats [BatOo.Oo.Internal]
std_formatter [BatFormat]
The standard formatter used by the formatting functions above.
stderr [BatPervasives]
Standard error output, as per Unix/Windows conventions.
stderr [BatInnerIO]
Standard error output, as per Unix/Windows conventions.
stderr [BatIO]
Standard error output, as per Unix/Windows conventions.
stderr_formatter [BatLogger]
stderr_formatter is a standard formatter that outputs log events to stderr using the same format as make_std_formatter.
stdib [BatScanf.Scanning]
The scanning buffer reading from stdin.
stdin [BatPervasives]
Standard input, as per Unix/Windows conventions (by default, keyboard).
stdin [BatInnerIO]
Standard input, as per Unix/Windows conventions (by default, keyboard).
stdin [BatIO]
Standard input, as per Unix/Windows conventions (by default, keyboard).
stdnull [BatPervasives]
An output which discards everything written to it.
stdnull [BatInnerIO]
An output which discards everything written to it.
stdnull [BatIO]
An output which discards everything written to it.
stdout [BatPervasives]
Standard output, as per Unix/Windows conventions (by default, console).
stdout [BatInnerIO]
Standard output, as per Unix/Windows conventions (by default, console).
stdout [BatIO]
Standard output, as per Unix/Windows conventions (by default, console).
step_resizer [BatDynArray]
The stepwise resizer- another example of a resizer function, this time of a parameterized resizer.
store_const [BatOptParse.StdOpt]
store_const ?default const returns a flag option which stores the constant value const when the option is encountered on the command line.
store_false [BatOptParse.StdOpt]
store_false () returns an option which is set to false when it is encountered on the command line.
store_true [BatOptParse.StdOpt]
store_true () returns an option which is set to true when it is encountered on the command line.
str_callback [BatOptParse.StdOpt]
See OptParse.StdOpt.int_callback.
str_decode [BatBase64]
Decode a string encoded into Base64, raise Invalid_char if a character in the input string is not a valid one.
str_encode [BatBase64]
Encode a string into Base64.
str_option [BatOptParse.StdOpt]
See OptParse.StdOpt.int_option.
string [BatUCharParser]
Recognize exactly one string
string [BatGenlex.Languages.Make]
As CharParser.string, but case-insensitive if specified by case_sensitive.
string [BatCharParser]
Recognize exactly one string
string_after [BatStr.Str]
string_after s n returns the substring of all characters of s that follow position n (including the character at position n).
string_before [BatStr.Str]
string_before s n returns the substring of all characters of s that precede position n (excluding the character at position n).
string_literal [BatGenlex.Languages.Make]
Accepts a string, i.e.
string_match [BatStr.Str]
string_match r s start tests whether a substring of s that starts at position start matches the regular expression r.
string_of [BatUnit]
Convert the given unit to a string.
string_of_big_int [BatBig_int]
Return the string representation of the given big integer, in decimal (base 10).
string_of_char [BatStd]
creates a string from a char.
string_of_char [BatPervasives]
creates a string from a char.
string_partial_match [BatStr.Str]
Similar to BatStr.Str.string_match, but also returns true if the argument string is a prefix of a string that matches.
strings_of [BatIO]
Read an enumeration of null-terminated strings.
strip [BatString]
Returns the string without the chars if they are at the beginning or at the end of the string.
strip [BatRope]
Returns the rope without the chars if they are at the beginning or at the end of the rope.
sub [BatVect.RANDOMACCESS]
sub [BatVect.Make]
sub m n r returns a sub-vect of r containing all the elements whose indexes range from m to m + n - 1 (included).
sub [BatVect]
sub m n r returns a sub-vect of r containing all the elements whose indexes range from m to m + n - 1 (included).
sub [BatUTF8]
As String.sub
sub [BatRope]
sub r m n returns a sub-rope of r containing all characters whose indexes range from m to m + n - 1 (included).
sub [BatPathGen.StringType]
As String.sub, but indexed in specific way.
sub [BatNumber.Numeric]
sub [BatNum]
sub [BatNativeint]
Subtraction.
sub [BatInt64]
Subtraction.
sub [BatInt32]
Subtraction.
sub [BatInt.Safe_int]
Substraction.
sub [BatInt]
Subtraction.
sub [BatFloat.Safe_float]
sub [BatFloat]
sub [BatDynArray]
sub darr start len returns an array holding the subset of len elements from darr starting with the element at index idx.
sub [BatComplex]
Subtraction
sub [BatBool]
sub [BatBigarray.Array1]
Extract a sub-array of the given one-dimensional big array.
sub [BatBig_int]
sub [BatArray.Labels]
sub [BatArray.Cap.Labels]
sub [BatArray.Cap]
Array.sub a start len returns a fresh array of length len, containing the elements number start to start + len - 1 of array a.
sub [BatArray]
Array.sub a start len returns a fresh array of length len, containing the elements number start to start + len - 1 of array a.
sub_left [BatBigarray.Array3]
Extract a three-dimensional sub-array of the given three-dimensional big array by restricting the first dimension.
sub_left [BatBigarray.Array2]
Extract a two-dimensional sub-array of the given two-dimensional big array by restricting the first dimension.
sub_left [BatBigarray.Genarray]
Extract a sub-array of the given big array by restricting the first (left-most) dimension.
sub_right [BatBigarray.Array3]
Extract a three-dimensional sub-array of the given three-dimensional big array by restricting the second dimension.
sub_right [BatBigarray.Array2]
Extract a two-dimensional sub-array of the given two-dimensional big array by restricting the second dimension.
sub_right [BatBigarray.Genarray]
Extract a sub-array of the given big array by restricting the last (right-most) dimension.
subset [BatSet.S]
subset s1 s2 tests whether the set s1 is a subset of the set s2.
subset [BatISet]
substitute_first [BatStr.Str]
Same as BatStr.Str.global_substitute, except that only the first substring matching the regular expression is replaced.
substring [BatSubstring]
substring s o l returns a substring with base-string s, offset o and length l.
succ [BatNumber.Discrete]
succ [BatNum]
succ [BatNativeint]
Successor.
succ [BatInt64]
Successor.
succ [BatInt32]
Successor.
succ [BatInt.Safe_int]
Successor.
succ [BatInt]
Successor.
succ [BatFloat.Safe_float]
Add 1. to a floating number.
succ [BatFloat]
Add 1. to a floating number.
succ [BatComplex]
Add BatComplex.one to this number.
succ [BatBool]
succ [BatBig_int]
suffix_action [BatEnum]
suffix_action f e will behave as e but guarantees that f () will be invoked after the contents of e are exhausted.
sum [BatList]
sum l returns the sum of the elements of l
swap [BatRef]
swap a b puts !b in a and !a in b
switch [BatStream.StreamLabels]
switch ~f:test stream split stream into two streams, where the first stream have all the elements satisfying test, the second stream is opposite.
switch [BatStream]
switch test stream split stream into two streams, where the first stream have all the elements satisfying test, the second stream is opposite.
switch [BatEnum.Labels]
switch [BatEnum]
switch test enum splits enum into two enums, where the first enum have all the elements satisfying test, the second enum is opposite.
sym_diff [BatBitSet]
sym_diff s t returns the symmetrical difference of s and t.
sync [BatConcurrent]
Specialized version of synchronized.
synchronize [BatRMutex]
Protect a function.
synchronize [BatMutex.Mutex]
Protect a function.
synchronize [BatConcurrent.Lock]
synchronize [BatConcurrent]
synchronize locker f returns a function f' which behaves as f but whose executions are protected by one lock obtained from locker.
synchronize_in [BatIO]
synchronize_in inp produces a new BatIO.input which reads from input in a thread-safe way.
synchronize_out [BatIO]
synchronize_out out produces a new BatIO.output which writes to output in a thread-safe way.

T
t_printer [BatUTF8]
t_printer [BatUChar]
t_printer [BatString]
t_printer [BatSeq]
t_printer [BatRope]
t_printer [BatOption]
t_printer [BatNativeint]
t_printer [BatList]
t_printer [BatInt]
t_printer [BatFloat.Safe_float]
t_printer [BatFloat]
t_printer [BatEnum]
t_printer [BatDynArray]
t_printer [BatBool]
t_printer [BatArray]
tab_out [BatIO]
Create an output shifted to the right by a number of white spaces (or tab, if given).
tail [BatString]
tail r pos returns the string containing all but the pos first characters of r
tail [BatRope]
tail r pos returns the rope containing all but the pos first characters of r
take [BatStream]
take n stream returns the prefix of stream of length n, or stream itself if n is greater than the length of stream
take [BatSeq]
take n s returns up to the n first elements from sequence s, if available.
take [BatQueue.Queue]
take q removes and returns the first element in queue q, or raises Empty if the queue is empty.
take [BatList]
take n l returns up to the n first elements from list l, if available.
take [BatLazyList]
take n l returns up to the n first elements from list l, if available.
take [BatEnum]
take n e returns the prefix of e of length n, or e itself if n is greater than the length of e
take_while [BatStream.StreamLabels]
take_while test stream returns the longest (possibly empty) prefix of stream of elements that satisfy test.
take_while [BatStream]
take_while test stream returns the longest (possibly empty) prefix of stream of elements that satisfy test.
take_while [BatSeq]
take_while f s returns the first elements of sequence s which satisfy the predicate f.
take_while [BatList.Labels]
take_while [BatList]
takewhile f xs returns the first elements of list xs which satisfy the predicate f.
take_while [BatLazyList.Labels]
take_while [BatLazyList]
take_while f xs returns the first elements of list xs which satisfy the predicate f.
take_while [BatEnum.Labels]
take_while [BatEnum]
take_while f e produces a new enumeration in which only remain the first few elements x of e such that f x
takel [BatSubstring]
takel p sus returns the longest prefix (left substring) of sus all of whose characters satisfy predicate p.
taker [BatSubstring]
taker p sus returns the longest suffix (right substring) of sus all of whose characters satisfy predicate p.
takewhile [BatList]
obsolete, as BatList.take_while
tan [BatFloat.Safe_float]
tan [BatFloat]
tanh [BatFloat.Safe_float]
The usual hyperbolic trigonometric functions.
tanh [BatFloat]
The usual hyperbolic trigonometric functions.
times [BatParserCo]
times n p accepts a list of n expressions accepted by p
titled_formatter [BatOptParse.Formatter]
Creates a titled formatter which is quite similar to the indented formatter.
tl [BatSeq.Exceptionless]
tl [BatSeq]
Returns the sequence without its first elements or raise Invalid_argument if the sequence is empty.
tl [BatRefList]
Returns a ref list containing the same elements but without the first one or raises Empty_list if the ref list is empty
tl [BatLazyList]
Return the given list without its first element.
to_array [BatVect]
to_array r returns an array corresponding to the vect r.
to_array [BatLazyList]
Eager conversion to array.
to_array [BatDynArray]
to_array darr returns the elements of darr in order as an array.
to_array [BatBigarray.Array3]
Build a three-dimensional array initialized from the given big array.
to_array [BatBigarray.Array2]
Build a two-dimensional array initialized from the given big array.
to_array [BatBigarray.Array1]
Build a one-dimensional array initialized from the given big array.
to_array [BatArray.Cap]
Return a capability array as an array.
to_byte [BatInt32]
to_channel [BatMarshal]
to_char [BatUChar]
to_char u returns the Latin-1 representation of u.
to_container [BatVect.Make]
to_container r returns a container corresponding to the vect r.
to_enum_filter [BatGenlex]
Apply the lexer to an enum.
to_float [BatString]
Returns the float represented by the given string or raises Invalid_string if the string does not represent a float.
to_float [BatRope]
Returns the float represented by the given rope or raises Invalid_rope if the rope does not represent a float.
to_float [BatNumber.Numeric]
to_float [BatNum]
to_float [BatNativeint]
Convert the given native integer to a floating-point number.
to_float [BatInt64]
Convert the given 64-bit integer to a floating-point number.
to_float [BatInt32]
Convert the given 32-bit integer to a floating-point number.
to_float [BatInt.Safe_int]
Convert the given integer to a floating-point number.
to_float [BatInt]
Convert the given integer to a floating-point number.
to_float [BatFloat.Safe_float]
to_float [BatFloat]
to_float [BatBool]
to_input_channel [BatIO]
Create a channel that will read from an input.
to_int [BatUTF8.Byte]
to_int [BatUChar]
Alias of uint_code
to_int [BatString]
Returns the integer represented by the given string or raises Invalid_string if the string does not represent an integer.
to_int [BatRope]
Returns the integer represented by the given rope or raises Invalid_rope if the rope does not represent an integer.
to_int [BatNumber.Discrete]
to_int [BatNumber.Numeric]
to_int [BatNum]
to_int [BatNativeint]
Convert the given native integer (type nativeint) to an integer (type int).
to_int [BatInt64]
Convert the given 64-bit integer (type int64) to an integer (type int).
to_int [BatInt32]
Convert the given 32-bit integer (type int32) to an integer (type int).
to_int [BatInt.Safe_int]
to_int [BatInt]
to_int [BatFloat.Safe_float]
to_int [BatFloat]
to_int [BatComplex]
to_int [BatBool]
to_int [BatBig_int]
to_int32 [BatNativeint]
Convert the given native integer to a 32-bit integer (type int32).
to_int32 [BatInt64]
Convert the given 64-bit integer (type int64) to a 32-bit integer (type int32).
to_lazy_list_filter [BatGenlex]
Apply the lexer to a lazy list.
to_list [BatVect.Make]
Returns a list with the elements contained in the vect.
to_list [BatVect]
Returns a list with the elements contained in the vect.
to_list [BatString]
Converts a string to the list of its characters.
to_list [BatRefList]
Returns the current elements as a list - O(1)
to_list [BatLazyList]
Eager conversion to string.
to_list [BatDynArray]
to_list darr returns the elements of darr in order as a list.
to_list [BatDllist]
Converts a dllist to a normal list.
to_list [BatArray.Cap]
Array.to_list a returns the list of all the elements of a.
to_list [BatArray]
Array.to_list a returns the list of all the elements of a.
to_nativeint [BatInt64]
Convert the given 64-bit integer (type int64) to a native integer.
to_object [BatEnum]
to_object e returns a representation of e as an object.
to_option [BatResult]
Convert a result to an option
to_stream [BatLazyList]
Lazy conversion to stream.
to_stream_filter [BatGenlex]
Apply the lexer to a stream.
to_string [BatUTF8]
Return an UTF-8 encoded string representing this Unicode string.
to_string [BatSubstring]
string sus is the string si..i+n-1 represented by sus = (s, i, n).
to_string [BatRope]
to_string t returns a UTF-8 encoded string representing t
to_string [BatPathGen.StringType]
Convert to primitive string with UTF-8 content.
to_string [BatPathGen.PathType]
Convert to type primitive string with UTF-8 content.
to_string [BatNumber.Numeric]
to_string [BatNum]
Convert a number to a string, using fractional notation.
to_string [BatNativeint]
Return the string representation of its argument, in decimal.
to_string [BatInt64]
Return the string representation of its argument, in decimal.
to_string [BatInt32]
Return the string representation of its argument, in signed decimal.
to_string [BatInt.Safe_int]
Return the string representation of its argument, in signed decimal.
to_string [BatInt]
Return the string representation of its argument, in signed decimal.
to_string [BatIO]
to_string [BatFloat.Safe_float]
to_string [BatFloat]
to_string [BatComplex]
to_string [BatBool]
to_string [BatBig_int]
to_table [BatHashtbl.Cap]
Return a capability hashtable as a regular hashtable.
to_ustring [BatRope]
to_ustring r returns the string corresponding to the rope r.
to_ustring [BatPathGen.PathType]
Convert to the chosen ustring type.
toggle [BatBitSet]
toggle s n changes the nth-bit value in the bitset s.
tokens [BatSubstring]
tokens p sus returns the list of tokens in sus, from left to right, where a token is a non-empty maximal substring of sus not containing any delimiter, and a delimiter is a character satisfying p.
top [BatQueue.Queue]
top is a synonym for peek.
transcode_in [BatCharEncodings]
Transcoders
transcode_out [BatCharEncodings]
Convert the contents of an output between encodings.
transfer [BatQueue.Queue]
transfer q1 q2 adds all of q1's elements at the end of the queue q2, then clears q1.
transform [BatRefList]
transform all elements in the ref list using a function.
translate [BatSubstring]
translate f sus applies f to every character of sus, from left to right, and returns the concatenation of the results.
trim [BatSubstring]
removes whitespace from left and right ends of input
trim [BatString]
Returns the same string but without the leading and trailing whitespaces.
trim [BatRope]
Transformations
triml [BatSubstring]
triml k sus returns sus less its leftmost k characters; or the empty string at the end of sus if it has less than k characters.
trimr [BatSubstring]
trimr k sus returns sus less its rightmost k characters; or the empty string at the beginning of sus if it has less than k characters.
try_lock [BatRMutex]
Same as RMutex.lock, but does not suspend the calling thread if the mutex is already locked: just return false immediately in that case.
try_lock [BatMutex.Mutex]
Same as BatMutex.Mutex.lock, but does not suspend the calling thread if the mutex is already locked: just return false immediately in that case.
try_lock [BatConcurrent.BaseLock]
try_lock [BatConcurrent.Lock]

U
uchars_of [BatIO]
offer the characters of an UTF-8 encoded input as an enumeration
ui16s_of [BatIO.BigEndian]
Read an enumeration of unsigned 16-bit words.
ui16s_of [BatIO]
Read an enumeration of unsigned 16-bit words.
ulines_of [BatIO]
offer the lines of a UTF-8 encoded input as an enumeration
uncapitalize [BatRope]
Return a copy of the argument, with the first character set to lowercase.
uncombine [BatLazyList]
Divide a list of pairs into a pair of lists.
uncombine [BatEnum]
uncombine is the opposite of combine
uncurry [BatStd]
Turn a function that takes its arguments one at a time into a function that takes a pair as argument.
uncurry [BatPervasives]
Convert a function which accepts a two arguments into a function which accepts a pair of arguments.
undef [BatGlobal]
Reset the global value contents to undefined.
undefined [BatPervasives]
The undefined function.
unfold [BatLazyList]
unfold data next creates a (possibly infinite) lazy list from the successive results of applying next to data, then to the result, etc.
unfold [BatEnum.Labels]
unfold [BatEnum]
More powerful version of seq, with the ability of hiding data.
union [BatSet.S]
Set union.
union [BatISet]
union [BatIMap]
union [BatBitSet]
union s t return the union of sets s and t.
uniq [BatEnum]
uniq e returns a duplicate of e with repeated values omitted.
unique [BatStd]
returns an unique identifier every time it is called.
unique [BatPervasives]
Returns an unique identifier every time it is called.
unique [BatList]
unique cmp l returns the list l without any duplicate element.
unique [BatLazyList]
Dropping elements
unite [BatBitSet]
unite s t sets s to the union of the sets s and t.
unix_perm [BatFile]
Create a permission from a Unix-style octal integer.
unlock [BatRMutex]
Unlock the given mutex.
unlock [BatMutex.Mutex]
Unlock the given mutex.
unlock [BatConcurrent.BaseLock]
unlock [BatConcurrent.Lock]
unpack [BatInt32]
unpack str off reads 4 bytes from string str starting at offset off as a little-endian int32
unpack_big [BatInt32]
unpack str off reads 4 bytes from string str starting at offset off as a big-endian int32
unregister_formatter [BatLogger]
unregister_formatter name unregisters a named log formatter.
unsafe_get [BatVect.RANDOMACCESS]
unsafe_get [BatDynArray]
unsafe_get [BatBigarray.Array3]
Like Bigarray.Array3.get, but bounds checking is not always performed.
unsafe_get [BatBigarray.Array2]
Like Bigarray.Array2.get, but bounds checking is not always performed.
unsafe_get [BatBigarray.Array1]
Like Bigarray.Array1.get, but bounds checking is not always performed.
unsafe_set [BatVect.RANDOMACCESS]
unsafe_set [BatDynArray]
unsafe_set [BatBigarray.Array3]
Like Bigarray.Array3.set, but bounds checking is not always performed.
unsafe_set [BatBigarray.Array2]
Like Bigarray.Array2.set, but bounds checking is not always performed.
unsafe_set [BatBigarray.Array1]
Like Bigarray.Array1.set, but bounds checking is not always performed.
unset [BatBitSet]
unset s n sets the nth-bit in the bitset s to false.
until [BatISet]
until [BatIMap]
uppercase [BatUTF8]
Return a copy of the argument, with all lowercase letters translated to uppercase.
uppercase [BatUCharParser]
Recognizes one upper-case ASCII character, including accentuated characters.
uppercase [BatUChar]
Convert the given character to its equivalent uppercase character.
uppercase [BatRope]
uppercase s returns a uppercase copy of rope s.
uppercase [BatPervasives]
Return a copy of the argument, with all lowercase letters translated to uppercase, including accented letters of the ISO Latin-1 (8859-1) character set.
uppercase [BatCharParser]
Recognizes one upper-case ASCII character, including accentuated characters.
uppercase_latin1 [BatCharParser]
Recognizes one upper-case Latin-1 character, including accentuated characters.
usage [BatOptParse.OptParser]
Display the usage message to the channel chn (default is Pervasives.stdout) and return.
user_exec [BatFile]
Give the current user permission to execute the file.
user_read [BatFile]
Give the current user permission to read the file.
user_write [BatFile]
Give the current user permission to write the file
ustring [BatUCharParser]
Recognize exactly one string

V
validate [BatUTF8]
validate s succeeds if s is valid UTF-8, otherwise raises Malformed_code.
value_option [BatOptParse.Opt]
Make an option which takes a single argument.
values [BatMap.S]
Return an enumeration of al the values of a map.
values [BatHashtbl.Cap]
Return an enumeration of all the values of a hashtable.
values [BatHashtbl.S]
values [BatHashtbl]
Return an enumeration of all the values of a hashtable.
version [Batteries_config]
The version of OCaml Batteries Included, as a human-readable freeform string.
version_option [BatOptParse.StdOpt]
version_option f returns the standard version option which displays the string returned by f () (and nothing else) on standard output and exits.

W
while_do [BatEnum]
while_do cont f e is a loop on e using f as body and cont as condition for continuing.
whitespace [BatUCharParser]
Recognizes white-space
whitespace [BatCharParser]
Recognizes white-space
whitespaces [BatGenlex.Languages.Make]
widen [BatOo.Oo.Internal]
with_file_in [BatFile]
with_file_in file_name f opens the file named file_name for reading, invokes f to process the contents of that file then, once f has returned or triggered an exception, closes the file before proceeding.
with_file_out [BatFile]
with_file_out file_name f opens the file named file_name for writing, invokes f to write onto that file then, once f has returned or triggered an exception, closes the file before proceeding.
with_label [BatReturn]
as label
with_log [BatLogger]
with_log logger level event_fun ?result body logs an event before and after calling body ().
with_temporary_out [BatFile]
with_temporary_out f opens a new temporary file for writing, invokes f with to write onto that file then, once f has returned or triggered an exception, closes the file before proceeding.
word_size [Batteries_config]
Size of one word on the machine currently executing the Caml program, in bits: 32 or 64.
would_at_fail [BatLazyList]
would_at_fail l n returns true if l contains strictly less than n elements, false otherwise
wrap [BatStd]
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 Bad exception.
wrap [BatOptParse.Formatter]
wrap text width reflows the given text paragraph into lines of width at most width (lines may exceed this if the are single words that exceed this limit).
wrap_in [BatInnerIO]
Fully create an input reading from other inputs by giving all the needed functions.
wrap_in [BatIO]
Fully create an input reading from other inputs by giving all the needed functions.
wrap_out [BatInnerIO]
Fully create an output that writes to one or more underlying outputs.
wrap_out [BatIO]
Fully create an output that writes to one or more underlying outputs.
write [BatInnerIO]
Write a single char to an output.
write [BatIO]
Write a single char to an output.
write_bits [BatIO]
Write up to 31 bits represented as a value, raise Bits_error if nbits < 0 or nbits > 31 or the value representation excess nbits.
write_bitss [BatIO]
Write an enumeration of bits
write_buf [BatInnerIO]
Write the contents of a buffer to an output.
write_buf [BatIO]
Write the contents of a buffer to an output.
write_byte [BatInnerIO]
Write an unsigned 8-bit byte.
write_byte [BatIO]
Write an unsigned 8-bit byte.
write_bytes [BatIO.BigEndian]
Write an enumeration of unsigned 8-bit bytes.
write_bytes [BatIO]
Write an enumeration of unsigned 8-bit bytes.
write_chars [BatIO]
Write an enumeration of chars.
write_chunks [BatIO]
Write an enumeration of strings, without appending null characters.
write_double [BatInnerIO]
Write an IEEE double precision floating point value.
write_double [BatIO.BigEndian]
Write an IEEE double precision floating point value.
write_double [BatIO]
Write an IEEE double precision floating point value.
write_doubles [BatIO.BigEndian]
Write an enumeration of IEEE double precision floating point value.
write_doubles [BatIO]
Write an enumeration of IEEE double precision floating point value.
write_float [BatInnerIO]
Write an IEEE single precision floating point value.
write_float [BatIO.BigEndian]
Write an IEEE single precision floating point value.
write_float [BatIO]
Write an IEEE single precision floating point value.
write_i16 [BatInnerIO]
Write a signed 16-bit word.
write_i16 [BatIO.BigEndian]
Write a signed 16-bit word.
write_i16 [BatIO]
Write a signed 16-bit word.
write_i16s [BatIO.BigEndian]
Write an enumeration of signed 16-bit words.
write_i16s [BatIO]
Write an enumeration of signed 16-bit words.
write_i32 [BatInnerIO]
Write a signed 32-bit integer.
write_i32 [BatIO.BigEndian]
Write a signed 32-bit integer.
write_i32 [BatIO]
Write a signed 32-bit integer.
write_i32s [BatIO.BigEndian]
Write an enumeration of signed 32-bit integers.
write_i32s [BatIO]
Write an enumeration of signed 32-bit integers.
write_i64 [BatInnerIO]
Write an OCaml int64.
write_i64 [BatIO.BigEndian]
Write an OCaml int64.
write_i64 [BatIO]
Write an OCaml int64.
write_i64s [BatIO.BigEndian]
Write an enumeration of OCaml int64s.
write_i64s [BatIO]
Write an enumeration of OCaml int64s.
write_line [BatInnerIO]
Write a line and append a LF (it might be converted to CRLF on some systems depending on the underlying BatIO).
write_line [BatIO]
Write a line and append a line end.
write_lines [BatIO]
Write an enumeration of lines, appending a LF (it might be converted to CRLF on some systems depending on the underlying BatIO).
write_lines [BatFile]
write_lines name lines writes strings given by lines to file name with newline character appended to each line.
write_only [BatHashtbl.Cap]
Drop to write-only permissions.
write_only [BatArray.Cap]
Drop to write-only permissions.
write_real_i32 [BatInnerIO]
Write an OCaml int32.
write_real_i32 [BatIO.BigEndian]
Write an OCaml int32.
write_real_i32 [BatIO]
Write an OCaml int32.
write_real_i32s [BatIO.BigEndian]
Write an enumeration of OCaml int32s.
write_real_i32s [BatIO]
Write an enumeration of OCaml int32s.
write_rope [BatIO]
Write a character rope onto a UTF-8 encoded output.
write_ropes [BatIO]
Write an enumeration of ropes onto a UTF-8 encoded output, without appending a line-end.
write_string [BatInnerIO]
Write a string and append an null character.
write_string [BatIO]
Write a string and append an null character.
write_strings [BatIO]
Write an enumeration of strings, appending null characters.
write_uchar [BatIO]
Write one uchar to a UTF-8 encoded output.
write_uchars [BatIO]
Write an enumeration of characters onto a UTF-8 encoded output.
write_ui16 [BatInnerIO]
Write an unsigned 16-bit word.
write_ui16 [BatIO.BigEndian]
Write an unsigned 16-bit word.
write_ui16 [BatIO]
Write an unsigned 16-bit word.
write_ui16s [BatIO.BigEndian]
Write an enumeration of unsigned 16-bit words.
write_ui16s [BatIO]
Write an enumeration of unsigned 16-bit words.
write_uline [BatIO]
Write one line onto a UTF-8 encoded output.
write_ulines [BatIO]
Write an enumeration of lines onto a UTF-8 encoded output.

X
xprint [BatInt]
prints as hex string

Z
zero [BatNumber.Numeric]
zero [BatNum]
Usual operations
zero [BatNativeint]
The native integer 0.
zero [BatInt64]
The 64-bit integer 0.
zero [BatInt32]
The 32-bit integer 0.
zero [BatInt.Safe_int]
The integer 0.
zero [BatInt]
The integer 0.
zero [BatFloat.Safe_float]
Floating number zero.
zero [BatFloat]
Floating number zero.
zero [BatComplex]
The complex number 0.
zero [BatBool]
zero [BatBig_int]
zero_plus [BatParserCo]
Repetitions