Index of values


( * ) [BatNum]
( * ) [BatNativeint]
( * ) [BatInt64]
( * ) [BatInt.Safe_int]
Multiplication.
( * ) [BatInt]
Multiplication.
( * ) [BatFloat.Safe_float]
( * ) [BatFloat]
( * ) [BatComplex]
( * ) [BatBounded.NumericSig]
( * ) [BatBool]
( * ) [BatNumber.Infix]
( * ) [BatBig_int]
( ** ) [BatNum]
( ** ) [BatNativeint]
( ** ) [BatInt64]
( ** ) [BatInt.Safe_int]
a ** b computes ab
( ** ) [BatInt]
a ** b computes ab
( ** ) [BatFloat.Safe_float]
( ** ) [BatFloat]
( ** ) [BatComplex]
( ** ) [BatBool]
( ** ) [BatNumber.Infix]
( ** ) [BatBig_int]
( **/ ) [BatNum.Infix]
( **/ ) [BatNum.TaggedInfix]
( **/ ) [BatNum]
( */ ) [BatNum.Infix]
( */ ) [BatNum.TaggedInfix]
( */ ) [BatNum]
( *: ) [BatBounded.NumericSig]
( *= ) [BatNumber.RefOps]
( ~* ) [BatParserCo.Infix]
( ~* ) [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.
(%) [BatPervasives]
Function composition: the mathematical o operator.
(%) [BatInnerPervasives]
(%>) [BatPervasives]
Piping function composition.
(%>) [BatInnerPervasives]
(&&) [BatBool]
The boolean ``and''.
(+) [BatNum]
(+) [BatNativeint]
(+) [BatInt64]
(+) [BatInt.Safe_int]
Addition.
(+) [BatInt]
Addition.
(+) [BatFloat.Safe_float]
(+) [BatFloat]
(+) [BatComplex]
(+) [BatBounded.NumericSig]
(+) [BatBool]
(+) [BatNumber.Infix]
(+) [BatBig_int]
(+/) [BatNum.Infix]
(+/) [BatNum.TaggedInfix]
(+/) [BatNum]
(+:) [BatBounded.NumericSig]
(+=) [BatNumber.RefOps]
(-) [BatNum]
(-) [BatNativeint]
(-) [BatInt64]
(-) [BatInt.Safe_int]
Substraction.
(-) [BatInt]
Subtraction.
(-) [BatFloat.Safe_float]
(-) [BatFloat]
(-) [BatComplex]
(-) [BatBounded.NumericSig]
(-) [BatBool]
(-) [BatNumber.Infix]
(-) [BatBig_int]
(--) [BatSeq.Infix]
(--) [BatPervasives]
Enumerate numbers.
(--) [BatNumber.Discrete]
(--) [BatNativeint]
Enumerate an interval.
(--) [BatInt64]
Enumerate an interval.
(--) [BatInt32]
Enumerate an interval.
(--) [BatInt]
Enumerate an interval.
(--) [BatFloat]
(--) [BatEnum.Infix]
As range, without the label.
(--) [BatEnum]
(--) [BatComplex]
(--) [BatChar.Infix]
(--) [BatChar]
Produce the enumeration of a segment of characters.
(--) [BatBool]
(--) [BatNumber.Infix]
(--) [BatBig_int]
(---) [BatSeq.Infix]
(---) [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.
(---) [BatFloat]
(---) [BatEnum.Infix]
As --, but accepts enumerations in reverse order.
(---) [BatEnum]
(---) [BatComplex]
(---) [BatBool]
(---) [BatNumber.Infix]
(---) [BatBig_int]
(--.) [BatSeq.Infix]
(--.) [BatPervasives]
(a, step) --. b) creates a float enumeration from a to b with an increment of step between elements.
(--.) [BatEnum.Infix]
(a, step) --. b) creates a float enumeration from a to b with an increment of step between elements.
(--.) [BatEnum]
(-->) [BatMultiPMap.Infix]
map-->key returns the current binding of key in map.
(-->) [BatMultiMap.Infix]
map-->key returns the current binding of key in map.
(-->) [BatMap.PMap.Infix]
map-->key returns the current binding of key in map, or raises Not_found.
(-->) [BatMap.PMap]
Map find and insert from Infix
(-->) [BatMap.Infix]
map-->key returns the current binding of key in map, or raises Not_found.
(-->) [BatMap.S.Infix]
map-->key returns the current binding of key in map, or raises Not_found.
(-->) [BatMap]
Map find and insert from Infix
(-->) [BatIMap.Infix]
map-->key returns the current binding of key in map, or
(-->) [BatHashtbl.S.Infix]
tbl-->x returns the current binding of x in tbl, or raises Not_found if no such binding exists.
(-->) [BatHashtbl.Infix]
tbl-->x returns the current binding of x in tbl, or raises Not_found if no such binding exists.
(--^) [BatSeq.Infix]
(--^) [BatPervasives]
Enumerate numbers, without the right endpoint
(--^) [BatEnum.Infix]
As (--) but without the right endpoint
(--^) [BatEnum]
(--~) [BatSeq.Infix]
(--~) [BatPervasives]
As ( -- ), but for characters.
(--~) [BatEnum.Infix]
As ( -- ), but for characters.
(--~) [BatEnum]
(-/) [BatNum.Infix]
(-/) [BatNum.TaggedInfix]
(-/) [BatNum]
(-:) [BatBounded.NumericSig]
(-=) [BatNumber.RefOps]
(/) [BatNum]
(/) [BatNativeint]
(/) [BatInt64]
(/) [BatInt.Safe_int]
Integer division.
(/) [BatInt]
Integer division.
(/) [BatFloat.Safe_float]
(/) [BatFloat]
(/) [BatComplex]
(/) [BatBounded.NumericSig]
(/) [BatBool]
(/) [BatNumber.Infix]
(/) [BatBig_int]
(//) [BatSeq.Infix]
(//) [BatPervasives]
Filtering (pronounce this operator name "such that").
(//) [BatNum.Infix]
(//) [BatNum.TaggedInfix]
(//) [BatNum]
(//) [BatEnum.Infix]
Filtering (pronounce this operator name "such that").
(//) [BatEnum]
(//@) [BatSeq.Infix]
(//@) [BatPervasives]
(//@) [BatPathGen.PathType.Infix]
(//@) [BatPathGen.PathType.Operators]
basepath//@relpath catenates two paths.
(//@) [BatEnum.Infix]
(//@) [BatEnum]
(/:) [BatPathGen.PathType.Infix]
(/:) [BatPathGen.PathType.Operators]
path/:name is a path of name located in a directory path.
(/:) [BatBounded.NumericSig]
(/=) [BatNumber.RefOps]
(/@) [BatSeq.Infix]
(/@) [BatPervasives]
(/@) [BatEnum.Infix]
(/@) [BatEnum]
(:=) [BatRef]
r := a stores the value of a in reference r.
(<) [BatInt.Safe_int]
Comparaison: a < b is true if and only if a is strictly smaller than b.
(<) [BatInt]
(<) [BatNumber.Compare]
(<--) [BatMultiPMap.Infix]
map<--(key, value) returns a map containing the same bindings as map, plus a binding of key to value.
(<--) [BatMultiMap.Infix]
map<--(key, value) returns a map containing the same bindings as map, plus a binding of key to value.
(<--) [BatMap.PMap.Infix]
map<--(key, value) returns a map containing the same bindings as map, plus a binding of key to value.
(<--) [BatMap.PMap]
(<--) [BatMap.Infix]
map<--(key, value) returns a map containing the same bindings as map, plus a binding of key to value.
(<--) [BatMap.S.Infix]
map<--(key, value) returns a map containing the same bindings as map, plus a binding of key to value.
(<--) [BatMap]
(<--) [BatIMap.Infix]
map<--(key, value) returns a map containing the same bindings as map, plus a binding of key to value.
(<--) [BatHashtbl.S.Infix]
tbl<--(x, y) adds a binding of x to y in table tbl.
(<--) [BatHashtbl.Infix]
tbl<--(x, y) adds a binding of x to y in table tbl.
(</) [BatNum.Infix]
(</) [BatNum.TaggedInfix]
(</) [BatNum]
(<=) [BatInt.Safe_int]
Comparaison: a <= b is true if and only if a is smaller or equalto b.
(<=) [BatInt]
(<=) [BatNumber.Compare]
(<=/) [BatNum.Infix]
(<=/) [BatNum.TaggedInfix]
(<=/) [BatNum]
(<>) [BatInt.Safe_int]
Comparaison: a <> b is true if and only if a and b have different values.
(<>) [BatInt]
(<>) [BatNumber.Compare]
(<>/) [BatNum.Infix]
(<>/) [BatNum.TaggedInfix]
(<>/) [BatNum]
(<|>) [BatParserCo.Infix]
(<|>) [BatParserCo]
Accept one of two parsers
(=) [BatInt.Safe_int]
Comparaison: a = b if and only if a and b have the same value.
(=) [BatInt]
(=) [BatNumber.Compare]
(=/) [BatNum.Infix]
(=/) [BatNum.TaggedInfix]
(=/) [BatNum]
(=~) [BatFloat.Infix]
Approximate comparison of two floats, as approx_equal.
(>) [BatInt.Safe_int]
Comparaison: a > b is true if and only if a is strictly greater than b.
(>) [BatInt]
(>) [BatNumber.Compare]
(>/) [BatNum.Infix]
(>/) [BatNum.TaggedInfix]
(>/) [BatNum]
(>::) [BatParserCo.Infix]
(>::) [BatParserCo]
As cons
(>=) [BatInt.Safe_int]
Comparaison: a >= b is true if and only if a is greater or equal to b.
(>=) [BatInt]
(>=) [BatNumber.Compare]
(>=/) [BatNum.Infix]
(>=/) [BatNum.TaggedInfix]
(>=/) [BatNum]
(>>=) [BatResult.Infix]
(>>=) [BatResult.Monad]
as bind
(>>=) [BatParserCo.Infix]
(>>=) [BatParserCo]
As bind
(>>>) [BatParserCo.Infix]
(>>>) [BatParserCo]
As bind, but ignoring the result
(@) [BatPervasives]
List concatenation.
(@) [BatList.Infix]
(@) [BatList]
Tail recursive List.append.
(@/) [BatSeq.Infix]
(@/) [BatPervasives]
Mapping operators.
(@/) [BatEnum.Infix]
Mapping operators.
(@/) [BatEnum]
(@//) [BatSeq.Infix]
(@//) [BatPervasives]
Map combined with filter.
(@//) [BatEnum.Infix]
Map combined with filter.
(@//) [BatEnum]
(@@) [BatPervasives]
(@@) [BatInnerPervasives]
(^:^) [BatLazyList.Infix]
(^:^) [BatLazyList]
As cons: x^:^l is the lazy list with head x and tail l
(^@^) [BatLazyList.Infix]
(^@^) [BatLazyList]
As lazy append
(^^) [BatParserCo.Infix]
(^^) [BatParserCo]
p ^^ n is the same thing as times n p
(^^^) [BatText]
(|>) [BatteriesPrint]
(|>) [BatPervasives]
The "pipe": function application.
(|>) [BatInnerPervasives]
(|?) [BatPervasives]
Like BatOption.default, with the arguments reversed.
(|?) [BatOption.Infix]
Like BatOption.default, with the arguments reversed.
(|?) [BatOption]
Like BatOption.default, with the arguments reversed.
(|?) [BatInnerPervasives]
(||) [BatBool]
The boolean ``or''.
(~+) [BatParserCo.Infix]
(~+) [BatParserCo]
As one_plus
(~?) [BatParserCo.Infix]
(~?) [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, except when the argument is min_num.
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]
abs_big_int [BatBig_int]
Absolute value.
abs_num [BatNum]
accept [BatUnix]
Accept connections on the given socket.
access [BatUnix]
Check that the process has the given permissions over the named file.
acos [BatFloat.Safe_float]
acos [BatFloat]
add [BatSet.PSet]
add x s returns a set containing all elements of s, plus x.
add [BatSet.S]
add x s returns a set containing all elements of s, plus x.
add [BatSet]
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]
add x q adds the element x at the end of the queue q.
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 [BatMultiMap]
add x y m returns a map containing the same bindings as m, plus a binding of x to y.
add [BatMap.PMap]
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 [BatMap]
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 the given int to the set, returning a new set
add [BatIMap]
add x y t adds a binding from x to y in t, returning a new map.
add [BatHeap.H]
add [BatHeap]
add x h is the same as insert h x.
add [BatHashtbl.Cap.Labels]
add [BatHashtbl.Cap]
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 [BatBitSet]
add n s returns a copy of s with bit n true.
add [BatBig_int]
add_big_int [BatBig_int]
Addition.
add_buffer [BatUTF8.Buf]
add_buffer b1 b2 adds the contents of b2 to b1.
add_buffer [BatBuffer]
add_buffer b1 b2 appends the current contents of buffer b2 at the end of buffer b1.
add_carry [BatMap.PMap]
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_carry [BatMap]
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_char [BatBuffer]
add_char b c appends the character c at the end of the buffer b.
add_group [BatOptParse.OptParser]
Add a group to the option parser.
add_initializer [BatOo.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_num [BatNum]
add_range [BatISet]
add_range lo hi t adds the range of integers lo, hi (including both endpoints) to the given set, returning a new set
add_range [BatIMap]
add lo hi y t adds bindings to y for all values in the range lo,hi, returning a new map
add_sort [BatRefList]
Adds an element in a sorted list, using the given comparator.
add_string [BatUTF8.Buf]
Add the UTF-8 string to the buffer.
add_string [BatBuffer]
add_string b s appends the string s at the end of the buffer b.
add_substitute [BatBuffer]
add_substitute b f s appends the string pattern s at the end of the buffer b with substitution.
add_substring [BatBuffer]
add_substring b s ofs len takes len characters from offset ofs in string s and appends them at the end of the buffer b.
advance [BatCharParser]
Advance by one char.
after [BatISet]
after x t returns the portion of t in the range x+1, max_int
after [BatIMap]
Return the sub-map of bindings in the range x+1,max_int
alarm [BatUnix]
Schedule a SIGALRM signal after the given number of seconds.
all [BatSubstring]
all s is the substring (s, 0, size s).
allocated_bytes [BatGc]
Return the total number of bytes allocated since the program was started.
and_big_int [BatBig_int]
Bitwise logical ``and''.
any [BatParserCo]
Accept any singleton value.
any_option [BatOptParse.StdOpt]
any_option ?default ?metavar coerce returns an option which takes a single argument from the command line and calls coerce to coerce it to the proper type.
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 [BatText]
append r u concatenates the r and u ropes.
append [BatSeq]
append s1 s2 returns the sequence which first returns all elements of s1 then all elements of s2.
append [BatPathGen.PathType]
Alternative name for BatPathGen.PathType.Operators.(/:)
append [BatList]
Catenate two lists.
append [BatLazyList]
Lazy append
append [BatFingerTree.S]
append is equivalent to List.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 [BatDeque]
append dq1 dq2 represents the concatenateion of dq1 and dq2.
append [BatArray.Cap]
append [BatArray]
Array.append v1 v2 returns a fresh array containing the concatenation of the arrays v1 and v2.
append_char [BatText]
append_char c r returns a new rope with the c character at the end in amortized O(1) time.
append_list [BatDeque]
append_list dq l is equivalent to append dq (of_list l), but more efficient.
apply [BatOption]
apply None x returns x and apply (Some f) x returns f x
approx [BatNum]
approx n return the integer closest to n
approx_equal [BatFloat]
Test whether two floats are approximately equal (i.e.
approx_num_exp [BatNum]
Approximate a number by a decimal.
approx_num_fix [BatNum]
See Num.approx_num_exp.
arg [BatComplex]
Argument.
arg_max [BatEnum]
arg_min f xs returns the x in xs for which f x is minimum.
arg_min [BatEnum]
args [BatPervasives]
An enumeration of the arguments passed to this program through the command line.
argv [BatSys]
The command line arguments given to the process.
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.
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 b in the list of pairs l.
assoc [BatList]
assoc a l returns 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 b 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 [BatList]
Same as List.assoc, but uses physical equality instead of structural equality to compare keys.
assq [BatLazyList.Labels.Exceptionless]
assq [BatLazyList.Exceptionless]
As BatLazyList.Exceptionless.assoc but with physical equality
assq [BatLazyList]
As BatLazyList.assoc but with physical equality
assq_inv [BatList]
Same as List.assoc_inv, but uses physical equality instead of structural equality to compare keys.
at [BatVect.Make]
as get
at [BatVect]
as get
at [BatSeq.Exceptionless]
at [BatSeq]
at l n returns the element at index n (starting from 0) in 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
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 element at index n (starting from 0) in the list l.
at [BatDeque]
at ~backwards dq k returns the kth element of dq, from the front if backwards is false, and from the rear if backwards is true.
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
backtrace_status [BatPrintexc]
Printexc.backtrace_status() returns true if exception backtraces are currently recorded, false if not.
backwards [BatVect.RANDOMACCESS]
backwards [BatVect.Make]
Returns an enumeration of the elements of a vector, from last to first.
backwards [BatVect]
Returns an enumeration of the elements of a vector, from last to first.
backwards [BatString.Cap]
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 [BatSet]
Return an enumeration of all elements of the given set.
backwards [BatRefList]
Returns an enumeration of current elements in the ref list, going from last to first
backwards [BatMap.PMap]
creates an enumeration for this map, enumerating key,value pairs with the keys in decreasing order.
backwards [BatMap.S]
Return an enumeration of (key, value) pairs of a map.
backwards [BatMap]
creates an enumeration for this map, enumerating key,value pairs with the keys in decreasing order.
backwards [BatList]
Returns an enumeration of the elements of a list.
backwards [BatFingerTree.S]
backwards t builds an enumeration of the elements of t going from right to left.
backwards [BatDllist]
backwards t is similar to rev_enum t except that the enumeration starts at the node before the current one:
backwards [BatArray.Cap]
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 [BatText]
balance r returns a balanced copy of the r rope.
base [BatSubstring]
base sus is the concrete triple (s, i, n), where psus = (s, i, n).
base_of_t [BatBounded.BoundedType]
base_of_t x converts a value of type BatBounded.BoundedType.t back to a BatBounded.BoundedType.base_t if possible.
base_of_t_exn [BatBounded.BoundedType]
base_of_t_exn x converts a value of type BatBounded.BoundedType.t back to a BatBounded.BoundedType.base_t.
before [BatISet]
before x t returns the portion of t in the range min_int, x-1
before [BatIMap]
Return the sub-map of bindings in the range min_int, x-1
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_endian [BatSys]
Whether the machine currently executing the OCaml program is big-endian.
big_int_base_default_symbols [BatBig_int]
Default vector of symbols used by to_string_in_base and its fixed-base derivatives to_string_in_binary, to_string_in_octal and to_string_in_hexa to represent digits.
big_int_of_int [BatBig_int]
Convert a small integer to a big integer.
big_int_of_int32 [BatBig_int]
Convert a 32-bit integer to a big integer.
big_int_of_int64 [BatBig_int]
Convert a 64-bit integer to a big integer.
big_int_of_nativeint [BatBig_int]
Convert a native 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.
bin_comp [BatOrd]
bin_eq [BatOrd]
bin_ord [BatOrd]
binary lifting of the comparison function, using lexicographic order: bin_ord ord1 v1 v1' ord2 v2 v2' is ord2 v2 v2' if ord1 v1 v1' = Eq, and ord1 v1 v1' otherwhise.
bind [BatUnix]
Bind a socket to an address.
bind [BatResult.Monad]
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 (Some x) f returns f x and bind None f returns None.
bind [BatInterfaces.Monad]
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.
bindings [BatMap.PMap]
Return the list of all bindings of the given map.
bindings [BatMap.S]
Return the list of all bindings of the given map.
bindings [BatMap]
Return the list of all bindings of the given map.
bits [BatRandom.Incubator.Private_state_enums.State]
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 [BatText]
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 [BatString.Cap]
blit [BatString]
String.blit src srcoff dst dstoff len copies len characters from string src, starting at character number srcoff, to string 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 src srcoff dst dstoff len copies len characters from the current contents of the buffer src, starting at offset srcoff to string dst, starting at character 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.Cap.Labels]
blit [BatArray.Cap]
blit [BatArray.Labels]
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.Incubator.Private_state_enums.State]
bool [BatRandom.State]
bool [BatRandom]
Random.bool () returns true or false with probability 0.5 each.
bounded [BatBounded.BoundedType]
bounded ~bounds x returns a bounded BatBounded.BoundedType.t value derived from x.
bounding_of_ord [BatBounded]
bounding_of_ord ~default_low ~default_high conv ord will returning a bounding function using ord for value comparison and default_low and default_high for values which fall outside of the requested range.
bounding_of_ord_chain [BatBounded]
bounding_oF_ord_chain ?low ?high ord is like BatBounded.bounding_of_ord except that functions are used to handle out of range values rather than single default values.
bounds [BatBounded.BoundedType]
bounds defines the (min, max) bounds for the bounded range
bounds [BatBounded.S]
bounds defines the (min, max) bounds for the bounded range
bprintf [BatPrintf]
As BatPrintf.fprintf, but with buffers instead of outputs.
bprintf [BatFormat]
A deprecated and error prone function.
bprintf2 [BatPrintf]
As BatPrintf.printf but writes to a buffer instead of printing to the output.
break [BatEnum]
Negated span.
browse [BatteriesConfig]
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.
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.
capacity [BatBitSet]
Internals
capitalize [BatString.Cap]
capitalize [BatString]
Return a copy of the argument, with the first character set to uppercase.
cardinal [BatSet.PSet]
Return the number of elements of a set.
cardinal [BatSet.S]
Return the number of elements of a set.
cardinal [BatSet]
Return the number of elements of a set.
cardinal [BatMap.PMap]
Return the number of bindings of a map.
cardinal [BatMap.S]
Return the number of bindings of a map.
cardinal [BatMap]
Return the number of bindings of a map.
cardinal [BatISet]
Returns the number of elements in the set
cartesian_product [BatList]
Different from List.combine, this returns every pair of elements formed out of the two lists.
case_char [BatCharParser]
As char, but case-insensitive
case_sensitive [BatGenlex.Languages.Definition]
true if the language is case-sensitive, false otherwise.
case_string [BatCharParser]
As case_string, 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.
catch [BatPrintexc]
Printexc.catch fn x is similar to Printexc.print, but aborts the program with exit code 2 after printing the uncaught exception.
catch2 [BatResult]
As catch but two paramaters.
catch3 [BatResult]
As catch but three paramaters.
catch_break [BatSys]
catch_break governs whether interactive interrupt (ctrl-C) terminates the program or raises Break.
ceil [BatNum]
ceil [BatFloat.Safe_float]
ceil [BatFloat]
ceiling_num [BatNum]
channel [BatDigest]
If len is nonnegative, Digest.channel ic len reads len characters from channel ic and returns their digest, or
char [BatRandom.Incubator.Private_state_enums.State]
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 OCaml type float.
char_dynarray [BatteriesPrint]
char_enum [BatteriesPrint]
char_literal [BatGenlex.Languages.Make]
Accepts a character literal, i.e.
char_of [BatUChar]
char_of u returns the Latin-1 representation of u.
char_pset [BatteriesPrint]
chars_of [BatText]
offer the characters of an UTF-8 encoded input as an enumeration
chars_of [BatIO]
Read an enumeration of Latin-1 characters.
chdir [BatUnix]
Change the process working directory.
chdir [BatSys]
Change the current working directory of the process.
chmod [BatUnix]
Change the permissions of the named file.
chmod [BatFile]
choice [BatRandom]
choice e returns a randomly-chosen element of e.
choose [BatSet.PSet]
returns an arbitrary (but deterministic) element of the given set.
choose [BatSet.S.Exceptionless]
choose [BatSet.S]
Return one element of the given set, or raise Not_found if the set is empty.
choose [BatSet]
returns an arbitrary (but deterministic) element of the given set.
choose [BatMap.PMap]
Return one binding of the given map, or raise Not_found if the map is empty.
choose [BatMap.S]
Return one binding of the given map, or raise Not_found if the map is empty.
choose [BatMap]
Return one binding of the given map, or raise Not_found if the map is empty.
choose [BatISet]
Returns some element in the set
chown [BatUnix]
Change the owner uid and owner gid of the named file.
chr [BatUChar]
chr n returns the Unicode character with the code number n.
chr [BatChar]
Return the character with the given ASCII code.
chroot [BatUnix]
Change the process root directory.
chunks_of [BatIO]
Read an input as an enumeration of strings of given 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 [BatStack]
Discard all elements from a stack.
clear [BatRefList]
Removes all elements
clear [BatQueue]
Discard all elements from a queue.
clear [BatInnerWeaktbl]
Empty a hash table.
clear [BatHashtbl.Cap]
clear [BatHashtbl.S]
clear [BatHashtbl]
Empty a hash table.
clear [BatHashcons.Table]
clear tab removes all entries from the table tab.
clear [BatDynArray]
remove all elements from the array and resize it to 0.
clear [BatBuffer]
Empty the buffer.
clear_close_on_exec [BatUnix]
Clear the ``close-on-exec'' flag on the given descriptor.
clear_nonblock [BatUnix]
Clear the ``non-blocking'' flag on the given descriptor.
clone [BatEnum]
clone e creates a new enumeration that is copy of e.
close [BatUnix]
Close a file descriptor.
close_all [BatInnerIO]
Close all outputs.
close_box [BatFormat]
Closes the most recently opened pretty-printing box.
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.
close_tag [BatFormat]
close_tag () closes the most recently opened tag t.
close_tbox [BatFormat]
Closes the most recently opened tabulation box.
closedir [BatUnix]
Close a directory descriptor.
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.
code [BatUChar]
code u returns the Unicode code number of u.
code [BatChar]
Return the ASCII code of the argument.
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 [a0; a1; ...; an] [b0; b1; ...; bn] is [(a0,b0); (a1,b1); ...; (an,bn)].
combine [BatLazyList]
Transform a pair of lists into a list of pairs: combine [^ a0; a1; ... ^] [^ b0; b1; ... ^] is [^ (a0, b0); (a1, b1); ... ^].
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 [BatSys]
Execute the given shell command and return its exit code.
comment [BatGenlex.Languages.Make]
comment_delimiters [BatGenlex.Languages.Definition]
comp [BatTuple.Tuple5]
comp [BatTuple.Tuple4]
comp [BatTuple.Tuple3]
comp [BatTuple.Tuple2]
comp [BatOrd]
Returns an legacy comparison from a variant ordering
comp0 [BatOrd]
comp_by [BatOrd.Incubator]
compact [BatGc]
Perform a full major collection and compact the heap.
compact [BatDynArray]
compact darr ensures that the space allocated by the array is minimal.
compare [BatVect]
compare [BatUnit]
Compare two units.
compare [BatUTF8]
Code point comparison by the lexicographic order.
compare [BatUChar]
compare u1 u2 returns, a value > 0 if u1 has a larger Unicode code number than u2, 0 if u1 and u2 are the same Unicode character, a value < 0 if u1 has a smaller Unicode code number than u2.
compare [BatTuple.Tuple5]
compare [BatTuple.Tuple4]
compare [BatTuple.Tuple3]
compare [BatTuple.Tuple2]
compare [BatText]
The comparison function for ropes, with the same specification as Pervasives.compare.
compare [BatSubstring]
compare sus1 sus2 performs lexicographic comparison, using the standard ordering Char.compare on the characters.p Equivalent to, but more efficient than, String.compare (to_string sus1) (to_string sus2).
compare [BatString.Cap]
compare [BatString]
The comparison function for strings, with the same specification as Pervasives.compare.
compare [BatStack]
compare [BatSet.PSet]
Total ordering between sets.
compare [BatSet.S]
Total ordering between sets.
compare [BatSet]
Total ordering between sets.
compare [BatRef]
Given a comparison function, produce a comparison function for refs of that type.
compare [BatQueue]
compare [BatPathGen.StringType]
Usual comparison function.
compare [BatOption]
Compare two options, possibly using custom comparators for the value.
compare [BatNumber.Numeric]
compare [BatNum]
compare [BatNativeint]
The comparison function for native integers, with the same specification as Pervasives.compare.
compare [BatMap.PMap]
compare [BatMap.S.Labels]
compare [BatMap.S]
Total ordering between maps.
compare [BatMap]
compare [BatLog.Level_sig]
compare [BatList]
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 two sets.
compare [BatHashcons]
Comparison on the tags
compare [BatFloat.Safe_float]
compare [BatFloat]
compare [BatFingerTree.S]
compare cmp t1 t2 compares the two sequences lexicographically.
compare [BatEnum.Labels]
compare [BatEnum]
compare cmp a b compares enumerations a and b by lexicographical order using comparison cmp.
compare [BatDigest]
The comparison function for 16-character digest, with the same specification as Pervasives.compare and the implementation shared with String.compare.
compare [BatComplex]
compare [BatOrd.Comp]
compare [BatChar]
The comparison function for characters, with the same specification as Pervasives.compare.
compare [BatBool]
compare [BatBitSet]
compare s1 s2 compares two bitsets using a lexicographic ordering.
compare [BatBig_int]
compare [BatArray.Cap]
compare [BatArray]
compare c generates the lexicographical order on arrays induced by c.
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_num [BatNum]
compare_subset [BatSet.S]
Partial ordering between sets as generated by subset
compl [BatISet]
Create the complement of the given set - i.e.
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 [BatText]
concat sep sl concatenates the list of ropes sl, inserting the separator rope sep between each.
concat [BatSubstring]
concat suss returns a string consisting of the concatenation of the substrings.
concat [BatString.Cap]
concat [BatString]
String.concat sep sl concatenates the list of strings sl, inserting the separator string sep between each.
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 [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]
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.
connect [BatUnix]
Connect a socket to an address.
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.
cons [BatFingerTree.S]
cons t elt adds elt to the left of t.
cons [BatDeque]
cons x dq adds x to the front of dq.
conservative_exponential_resizer [BatDynArray]
conservative_exponential_resizer is an example resizer function which uses the oldlength parameter.
const [BatPervasives]
Ignore its second argument.
const [BatInnerPervasives]
contains [BatText]
contains s c tests if character c appears in the rope s.
contains [BatString.Cap]
contains [BatString]
String.contains s c tests if character c appears in the string s.
contains_from [BatText]
contains_from s start c tests if character c appears in the subrope of s starting from start to the end of s.
contains_from [BatString.Cap]
contains_from [BatString]
String.contains_from s start c tests if character c appears in s after position start.
contents [BatUTF8.Buf]
contents buf returns the contents of the buffer.
contents [BatBuffer]
Return a copy of the current contents of the buffer.
copy [BatVect.RANDOMACCESS]
copy [BatString.Cap]
copy [BatString]
Return a copy of the given string.
copy [BatStack]
Return a copy of the given stack.
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.Incubator.Private_state_enums.State]
Return a copy of the given state.
copy [BatRandom.State]
Return a copy of the given state.
copy [BatQueue]
Return a copy of the given queue.
copy [BatOo.Internal]
copy [BatOo]
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]
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]
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)
copysign [BatFloat]
copysign x y returns a copy of x with the same sign as y.
cos [BatFloat.Safe_float]
cos [BatFloat]
cosh [BatFloat.Safe_float]
cosh [BatFloat]
count [BatStream]
Return the current count of the stream elements, i.e.
count [BatHashcons.Table]
count tab returns a count of how many live objects are in tab.
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.
counters [BatGc]
Return (minor_words, promoted_words, major_words).
create [BatUTF8.Buf]
create n creates the buffer with the initial size n-bytes.
create [BatSubstring]
create [BatString.Cap]
create [BatString]
String.create n returns a fresh string of length n.
create [BatStack]
Return a new stack, initially empty.
create [BatSet.PSet]
Creates a new empty set, using the provided function for key comparison.
create [BatRMutex]
Return a new mutex.
create [BatQueue]
Return a new queue, initially empty.
create [BatMultiPMap]
creates a new empty map, using the provided function for key comparison.
create [BatMap.PMap]
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]
create [BatHashtbl.S]
create [BatHashtbl]
Hashtbl.create n creates a new, empty hash table, with initial size n.
create [BatHashcons.Table]
create n creates a table with at least n cells.
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 [BatBuffer]
create n returns a fresh buffer, initially empty.
create [BatBitSet]
Create an empty bitset with at least an initial capacity (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.Cap.Labels]
create [BatArray.Cap]
create [BatArray.Labels]
create [BatArray]
create_alarm [BatGc]
create_alarm f will arrange for f to be called at the end of each major GC cycle, starting with the current cycle or the next one.
create_full [BatBitSet]
Create a full bitset with at least initial capacity (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.Cap.Labels]
create_matrix [BatArray.Cap]
create_matrix [BatArray.Labels]
create_matrix [BatArray]
create_object [BatOo.Internal]
create_object_and_run_initializers [BatOo.Internal]
create_object_opt [BatOo.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_process [BatUnix]
create_process prog args new_stdin new_stdout new_stderr forks a new process that executes the program in file prog, with arguments args.
create_process_env [BatUnix]
create_process_env prog args env new_stdin new_stdout new_stderr works as Unix.create_process, except that the extra argument env specifies the environment passed to the program.
create_table [BatOo.Internal]
current_browse [BatteriesConfig]
curry [BatTuple.Tuple5]
curry [BatTuple.Tuple4]
curry [BatTuple.Tuple3]
curry [BatTuple.Tuple2]
curry [BatPervasives]
Convert a function which accepts a pair of arguments into a function which accepts two arguments.
curry [BatInnerPervasives]
cycle [BatEnum]
cycle is similar to repeat, except that the content to fill is a subenum rather than a single element.

D
data_size [BatMarshal]
See Marshal.header_size.
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_stable_sort, but uses fast_sort internally.
decorate_stable_sort [BatArray]
decorate_stable_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_num [BatNum]
decr_option [BatOptParse.StdOpt]
Exactly identical to count_option ~dest:dest ~increment:(-1) ().
default [BatResult]
default d r evaluates to d if r is Bad else x when r is Ok x
default [BatOption]
default x (Some v) returns v and default x None returns x.
default_browse [BatteriesConfig]
The default function to open a www browser.
default_buffer_size [BatInnerIO]
The default size of buffers.
default_buffer_size [BatIO]
The default size for internal buffers.
default_level [BatLog.Level_sig]
a comparison function between levels, to know whether logging at a particular level should be printed
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.
del_min [BatHeap.H]
del_min [BatHeap]
Delete the minimal element of the heap.
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_alarm [BatGc]
delete_alarm a will stop the calls to the function associated to a.
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]
Return the descriptor corresponding to an input channel.
descr_of_input [BatUnix]
Return the descriptor corresponding to an input.
descr_of_out_channel [BatUnix]
Return the descriptor corresponding to an output channel.
descr_of_output [BatUnix]
Return the descriptor corresponding to an output.
destructive_set [BatVect.Make]
destructive_set n e v sets the element of index n in the v vect to e.
destructive_set [BatVect]
destructive_set n e v sets the element of index n in the v vect to e.
diff [BatSet.PSet]
diff s t returns the set of all elements in s but not in t.
diff [BatSet.S]
Set difference.
diff [BatSet]
diff s t returns the set of all elements in s but not in t.
diff [BatMap.PMap]
diff m1 m2 removes all bindings of keys found in m2 from m1, using the comparison function of m1.
diff [BatMap]
diff m1 m2 removes all bindings of keys found in m2 from m1, using the comparison function of m1.
diff [BatISet]
Compute the difference between two sets.
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 [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.
disjoint [BatSet.PSet]
disjoint s1 s2 tests whether the sets s1 and s2 contain no shared elements.
disjoint [BatSet.S]
disjoint s1 s2 tests whether the sets s1 and s2 contain no shared elements.
disjoint [BatSet]
disjoint s1 s2 tests whether the sets s1 and s2 contain no shared elements.
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]
div_big_int [BatBig_int]
Euclidean quotient of two big integers.
div_num [BatNum]
documentation_root [BatteriesConfig]
domain [BatIMap]
domain t returns the set of ints that are bound in t
domain_of_sockaddr [BatUnix]
Return the socket domain adequate for the given socket address.
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 [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]
drop_while p xs returns the suffix remaining after takeWhile p xs.
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.Internal]
dummy_pos [BatLexing]
A value of type position, guaranteed to be different from any valid position.
dummy_table [BatOo.Internal]
dump [BatPervasives]
Attempt to convert a value to a string.
dup [BatUnix]
Return a new file descriptor referencing the same file as the given descriptor.
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.
dup2 [BatUnix]
dup2 fd1 fd2 duplicates fd1 to fd2, closing fd2 if already opened.

E
e [BatFloat]
Euler? ...
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.PSet]
Return the list of all elements of the given set.
elements [BatSet.S]
Return the list of all elements of the given set.
elements [BatSet]
Return the list of all elements of the given set.
elements [BatISet]
Returns a list of all elements in the set
elems [BatHeap.H]
elems [BatHeap]
empty [BatVect.RANDOMACCESS]
empty [BatVect.Make]
The empty vect.
empty [BatVect]
The empty vect.
empty [BatText]
The empty rope.
empty [BatSubstring]
empty [BatStream]
Return () if the stream is empty, else raise Stream.Failure.
empty [BatSet.PSet]
The empty set, using compare as comparison function
empty [BatSet.S]
The empty set.
empty [BatSet]
The empty set, using compare as comparison function
empty [BatRefList]
Returns a new empty ref list
empty [BatMultiPMap]
The empty map, using compare as key comparison function.
empty [BatMultiMap]
The empty map, using compare as key comparison function.
empty [BatMap.PMap]
The empty map, using compare as key comparison function.
empty [BatMap.S]
The empty map.
empty [BatMap]
The empty map, using compare as key comparison function.
empty [BatISet]
The empty set
empty [BatIMap]
The empty map.
empty [BatHeap.H]
empty [BatHeap]
The empty heap.
empty [BatGlobal]
Returns an new named empty global.
empty [BatFingerTree.S]
empty is the sequence with no elements.
empty [BatEnum]
The empty enumeration : contains no element
empty [BatDynArray]
Return true if the number of elements in the array is 0.
empty [BatDeque]
The empty deque.
empty [BatBitSet]
Create an empty bitset of capacity 0, the bitset will automatically expand when needed.
empty [BatAvlTree]
encode [BatBase64]
Generic base64 encoding over an output.
end_of_input [BatScanf.Scanning]
Scanning.end_of_input ib tests the end-of-input condition of the given scanning buffer.
ends_with [BatText]
ends_with s x returns true if the rope s is ending with x, false otherwise.
ends_with [BatString.Cap]
ends_with [BatString]
ends_with s x returns true if the string s is ending with x, false otherwise.
enum [BatVect.RANDOMACCESS]
enum [BatVect.Make]
Returns an enumeration of the elements of the vector.
enum [BatVect]
Returns an enumeration of the elements of the vector.
enum [BatTuple.Tuple5]
enum [BatTuple.Tuple4]
enum [BatTuple.Tuple3]
enum [BatTuple.Tuple2]
enum [BatString.Cap]
Conversions
enum [BatString]
Returns an enumeration of the characters of a string.
enum [BatStream]
Convert a stream to an enumeration.
enum [BatStack]
enum s returns an enumeration of the elements of stack s, from the most recently entered to the least recently entered.
enum [BatSet.PSet]
Return an enumeration of all elements of the given set.
enum [BatSet.S]
Return an enumeration of all elements of the given set.
enum [BatSet]
Return an enumeration of all elements of the given set.
enum [BatSeq]
enum s returns the enumeration of all element of s.
enum [BatRefList]
Returns an enumeration of current elements in the ref list
enum [BatQueue]
enum q returns a destructive enumeration of the elements of queue q, from the least recently entered to the most recently entered.
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 [BatMultiMap]
creates an enumeration for this map.
enum [BatMap.PMap]
creates an enumeration for this map, enumerating key,value pairs with the keys in increasing order.
enum [BatMap.S]
Return an enumeration of (key, value) pairs of a map.
enum [BatMap]
creates an enumeration for this map, enumerating key,value pairs with the keys in increasing order.
enum [BatList]
Returns an enumeration of the elements of a list.
enum [BatLazyList]
Lazy conversion to enumeration
enum [BatISet]
Enumerates all contiguous ranges in the set
enum [BatIMap]
enum t returns an enumeration of the bindings in t
enum [BatHeap.H]
enum [BatHeap]
Enumerate the elements of the heap in heap order.
enum [BatHashtbl.Cap]
enum [BatHashtbl.S]
enum [BatHashtbl]
Return an enumeration of (key,value) pairs of a hashtable.
enum [BatFingerTree.S]
enum t builds an enumeration of the elements of t going from left to right.
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 [BatDeque]
enum dq is an enumeration of the elements of dq from the front to the rear.
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]
enum [BatArray]
Returns an enumeration of the elements of an array.
enum_bits [BatRandom.Incubator.Private_state_enums.State]
A copy of the input state is made to start these generators; the input state is not modified.
enum_bits [BatRandom.Incubator.Private_state_enums]
These enumerations are built on a copy of the global RNG state.
enum_bits [BatRandom.State]
enum_bits [BatRandom]
enum_bool [BatRandom.Incubator.Private_state_enums.State]
enum_bool [BatRandom.Incubator.Private_state_enums]
enum_bool [BatRandom.State]
enum_bool [BatRandom]
enum_char [BatRandom.Incubator.Private_state_enums.State]
enum_char [BatRandom.Incubator.Private_state_enums]
enum_char [BatRandom.State]
enum_char [BatRandom]
enum_destruct [BatStack]
enum s returns a destructive enumeration of the elements of stack s, from the most recently entered to the least recently entered.
enum_float [BatRandom.Incubator.Private_state_enums.State]
enum_float [BatRandom.Incubator.Private_state_enums]
enum_float [BatRandom.State]
enum_float [BatRandom]
enum_int [BatRandom.Incubator.Private_state_enums.State]
enum_int [BatRandom.Incubator.Private_state_enums]
enum_int [BatRandom.State]
enum_int [BatRandom]
enum_int32 [BatRandom.Incubator.Private_state_enums.State]
enum_int32 [BatRandom.Incubator.Private_state_enums]
enum_int32 [BatRandom.State]
enum_int32 [BatRandom]
enum_int64 [BatRandom.Incubator.Private_state_enums.State]
enum_int64 [BatRandom.Incubator.Private_state_enums]
enum_int64 [BatRandom.State]
enum_int64 [BatRandom]
enum_nativeint [BatRandom.Incubator.Private_state_enums.State]
enum_nativeint [BatRandom.Incubator.Private_state_enums]
enum_nativeint [BatRandom.State]
enum_nativeint [BatRandom]
enum_print [BatteriesPrint]
enum_print_limit [BatteriesPrint]
environment [BatUnix]
Return the process environment, as an array of strings with the format ``variable=value''.
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 [BatFormat]
Same as fprintf above, but output on err_formatter.
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 [BatUChar]
Equality by code point comparison
eq [BatTuple.Tuple5]
eq [BatTuple.Tuple4]
eq [BatTuple.Tuple3]
eq [BatTuple.Tuple2]
eq [BatRef]
eq [BatOrd]
Derives an equality function from an ordering function.
eq [BatOption]
Test for equality between option types, possibly using a custom equality predicate.
eq [BatList]
eq [BatOrd.Eq]
eq [BatArray.Incubator.Eq]
eq_big_int [BatBig_int]
eq_by [BatOrd.Incubator]
eq_comp [BatOrd]
eq_comp0 [BatOrd]
eq_num [BatNum]
eq_ord [BatOrd]
eq_ord0 [BatOrd]
equal [BatVect]
equal [BatUref]
equal ur1 ur2 returns true iff ur1 and ur2 are equal urefs, either because they are physically the same or because they have been BatUref.united.
equal [BatUnit]
Always returns true.
equal [BatString]
String equality
equal [BatStack]
equal [BatSet.PSet]
equal s1 s2 tests whether the sets s1 and s2 are equal, that is, contain equal elements.
equal [BatSet.S]
equal s1 s2 tests whether the sets s1 and s2 are equal, that is, contain equal elements.
equal [BatSet]
equal s1 s2 tests whether the sets s1 and s2 are equal, that is, contain equal elements.
equal [BatQueue]
equal [BatNumber.Numeric]
equal [BatNum]
equal [BatNativeint]
Equality function for 64-bit integers, useful for HashedType.
equal [BatMap.PMap]
Construct a comparison or equality function for maps based on a value comparison or equality function.
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 [BatMap]
Construct a comparison or equality function for maps based on a value comparison or equality function.
equal [BatInt64]
Equality function for 64-bit integers, useful for HashedType.
equal [BatInt32]
Equality function for 32-bit integers, useful for HashedType.
equal [BatInt.Safe_int]
Equality function for integers, useful for HashedType.
equal [BatInt]
Equality function for integers, useful for HashedType.
equal [BatInnerIO.Output]
equal [BatInnerIO.Input]
equal [BatISet]
Test whether two sets are equal.
equal [BatHashtbl.HashedType]
The equality predicate used to compare keys.
equal [BatFloat]
equal [BatFingerTree.S]
equal eq t1 t2 returns true when the two sequences contain the the same elements.
equal [BatEnum]
equal eq a b returns true when a and b contain the same sequence of elements.
equal [BatComplex]
equal [BatChar]
equal [BatBool]
equal [BatBitSet]
equal s1 s2 returns true if, and only if, all bits values in s1 are the same as in s2.
equal [BatBig_int]
equal [BatArray.Cap]
equal [BatArray]
Hoist a equality test for elements to arrays.
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.
error_message [BatUnix]
Return a string describing the given error code.
escaped [BatString.Cap]
escaped [BatString]
Return a copy of the argument, with special characters represented by escape sequences, following the lexical conventions of OCaml.
escaped [BatChar]
Return a string representing the given character, with special characters escaped following the lexical conventions of OCaml.
establish_server [BatUnix]
Establish a server on the given address.
eternity [BatLazyList]
An infinite list of nothing
exactly [BatParserCo]
Accept exactly one singleton.
exe [BatPervasives]
The name of the current executable.
executable_name [BatSys]
The name of the file containing the executable currently running.
execv [BatUnix]
execv prog args execute the program in file prog, with the arguments args, and the current process environment.
execve [BatUnix]
Same as Unix.execv, except that the third argument provides the environment to the program executed.
execvp [BatUnix]
Same as Unix.execv, except that the program is searched in the path.
execvpe [BatUnix]
Same as Unix.execve, except that the program is searched in the path.
exists [BatVect.Make]
exists p [a0; a1; ...; an] checks if at least one element of the vect satisfies the predicate p.
exists [BatVect]
exists p [a0; a1; ...; an] checks if at least one element of the vect satisfies the predicate p.
exists [BatText]
exists str sub returns true if sub is a subrope of str or false otherwise.
exists [BatString.Cap]
exists [BatString]
exists str sub returns true if sub is a substring of str or false otherwise.
exists [BatSet.PSet]
exists p s checks if at least one element of the set satisfies the predicate p.
exists [BatSet.S.Labels]
exists [BatSet.S]
exists p s checks if at least one element of the set satisfies the predicate p.
exists [BatSet]
exists p s checks if at least one element of the set satisfies the predicate p.
exists [BatSeq]
exists p (cons a0 (cons a1 ...)) checks if at least one element of the sequence satisfies the predicate p.
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 [BatMap.PMap]
Tests whether some key value pair satisfies some predicate function
exists [BatMap.S]
exists p m checks if at least one binding of the map satisfy the predicate p.
exists [BatMap]
Tests whether some key value pair satisfies some predicate function
exists [BatList.Labels]
exists [BatList]
exists p [a1; ...; an] checks if at least one element of the list satisfies the predicate p.
exists [BatLazyList.Labels]
exists [BatLazyList]
Eager existential.
exists [BatISet]
Test whether some element of a set satisfies a predicate
exists [BatEnum.Labels]
exists [BatEnum]
exists f e returns true if there is some x in e such that f x
exists [BatDllist]
Test whether there exists an element of the given list for which the predicate returns true.
exists [BatArray.Cap.Labels]
exists [BatArray.Cap]
exists [BatArray.Labels]
exists [BatArray]
exists p [|a0; 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.
exp [BatFloat.Safe_float]
Exponential.
exp [BatFloat]
Exponential.
exp [BatComplex]
Exponentiation.
explode [BatText]
explode s returns the list of characters in the rope s.
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.Cap]
explode [BatString]
explode s returns the list of characters in the string 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 [BatMap.PMap]
extract k m removes the current binding of k from m, returning the value k was bound to and the updated m.
extract [BatMap.S]
extract k m removes the current binding of k from m, returning the value k was bound to and the updated m.
extract [BatMap]
extract k m removes the current binding of k from m, returning the value k was bound to and the updated m.
extract [BatBounded.S]
extract x will return x as a value of type BatBounded.S.u.
extract_big_int [BatBig_int]
extract_big_int bi ofs n returns a nonnegative number corresponding to bits ofs to ofs + n - 1 of the binary representation of bi.

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 [BatList]
Same as List.sort or List.stable_sort, whichever is faster on typical input.
fast_sort [BatArray.Cap.Labels]
fast_sort [BatArray.Cap]
fast_sort [BatArray.Labels]
fast_sort [BatArray]
Same as Array.sort or Array.stable_sort, whichever is faster on typical input.
fatal [BatParserCo]
fatal [BatLog.Make]
fatal s logs the message s and then calls exit 1.
fatal [BatLog]
fatal s logs the message s and then calls exit 1.
fatalf [BatLog.Make]
fatalf allows a format string (as Printf.printf)and the arguments to that format string to build the logging message.
fatalf [BatLog]
fatalf allows a format string (as Printf.printf)and the arguments to that format string to build the logging message.
fchmod [BatUnix]
Change the permissions of an opened file.
fchown [BatUnix]
Change the owner uid and owner gid of an opened file.
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.
fifth [BatTuple.Tuple5]
file [BatDigest]
Return the digest of the file whose name is given.
file_exists [BatSys]
Test if a file with the given name exists.
files_of [BatSys]
As BatSys.readdir but the results are presented as an enumeration of names.
fill [BatText]
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 [BatString.Cap]
fill [BatString]
String.fill s start len c modifies string s in place, replacing len characters by c, starting at start.
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.Cap.Labels]
fill [BatArray.Cap]
fill [BatArray.Labels]
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 [BatText]
filter f s returns a copy of rope s in which only characters c such that f c = true remain.
filter [BatString.Cap]
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 [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.PSet]
filter p s returns the set of all elements in s that satisfy predicate p.
filter [BatSet.S.Labels]
filter [BatSet.S]
filter p s returns the set of all elements in s that satisfy predicate p.
filter [BatSet]
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 [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 [BatOption]
filter f None returns None, filter f (Some x) returns Some x if f x is true, and None otherwise.
filter [BatMap.PMap]
filter f m returns a map where only the (key, value) pairs key, a of m such that f key a = true remain.
filter [BatMap.S.Labels]
filter [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.
filter [BatMap]
filter f m returns a map where only the (key, value) pairs key, a of m such that f key 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]
Builds the subset of those elements that satisfy the predicate
filter [BatHashtbl.Cap.Labels]
filter [BatHashtbl.Cap]
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.Cap.Labels]
filter [BatArray.Cap]
filter [BatArray.Labels]
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 [BatText]
filter_map f l calls (f a0) (f a1).... (f an) where a0..an are the characters of l.
filter_map [BatString.Cap]
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.PSet]
filter_map f m combines the features of filter and map.
filter_map [BatSet.S.Labels]
filter_map [BatSet.S]
filter_map f m combines the features of filter and map.
filter_map [BatSet]
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 [BatPervasives]
Similar to a map, except that you can skip over some items of the incoming enumeration by returning None instead of Some value.
filter_map [BatMap.PMap]
filter_map f m combines the features of filter and map.
filter_map [BatMap.S]
filter_map f m combines the features of filter and map.
filter_map [BatMap]
filter_map f m combines the features of filter and map.
filter_map [BatList.Labels]
filter_map [BatList]
filter_map f l calls (f a0) (f a1).... (f an) where a0,a1..an are the elements of l.
filter_map [BatLazyList.Labels]
filter_map [BatLazyList]
Lazily eliminate some elements and transform others.
filter_map [BatHashtbl.Cap.Labels]
filter_map [BatHashtbl.Cap]
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,a1...an are the elements of l.
filter_map [BatArray.Cap.Labels]
filter_map [BatArray.Cap]
filter_map [BatArray.Labels]
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 [BatHashtbl.Cap.Labels]
filteri [BatHashtbl.Cap]
filteri [BatHashtbl.S.Labels]
filteri [BatHashtbl.S]
filteri [BatHashtbl.Labels]
filteri [BatHashtbl]
filter f m returns a hashtbl where only the key, values pairs key, a of m such that f key a = true remain.
filteri [BatArray]
As filter but with the index passed to the predicate.
filterv [BatMap.PMap]
filterv f m returns a map where only the values a of m such that f a = true remain.
filterv [BatMap.S.Labels]
filterv [BatMap.S]
filterv f m returns a map where only the values a of m such that f a = true remain.
filterv [BatMap]
filterv f m returns a map where only the values a of m such that f a = true remain.
finalise [BatGc]
finalise f v registers f as a finalisation function for v.
finalise_release [BatGc]
A finalisation function may call finalise_release to tell the GC that it can launch the next finalisation function without waiting for the current one to return.
finally [BatPervasives]
finally fend f x calls f x and then fend() even if f x raised an exception.
finally [BatInnerPervasives]
find [BatVect.Make]
find p a returns the first element of vect a that satisfies the predicate p.
find [BatVect]
find p a returns the first element of vect a that satisfies the predicate p.
find [BatText]
find s x returns the starting index of the first occurrence of rope x within rope s.
find [BatString.Cap.Exceptionless]
find [BatString.Cap]
find [BatString.Exceptionless]
find s x returns Some i, the starting index of the first occurrence of string x within string s, or None if x is not a substring of s.
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 [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 [BatMultiPMap]
find x m returns the current binding of x in m
find [BatMultiMap]
find x m returns the current binding of x in m
find [BatMap.PMap.Exceptionless]
find [BatMap.PMap]
find x m returns the current binding of x in m, or raises Not_found if no such binding exists.
find [BatMap.Exceptionless]
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 [BatMap]
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 [BatList]
find p l returns the first element of the list l that satisfies the predicate p.
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.
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 x t returns the y that is bound to x in t.
find [BatHashtbl.Cap.Exceptionless]
find [BatHashtbl.Cap]
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.
find [BatDllist]
find p l returns the first element, l or after, for which p returns true.
find [BatDeque]
find ~backwards f dq returns Some (n, x) if x at position n is such that f x is true, or None if there is no such element.
find [BatArray.Cap.Labels]
find [BatArray.Cap.Exceptionless]
find [BatArray.Cap]
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]
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 Vect.filter.
find_all [BatVect]
find_all is another name for Vect.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]
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 [BatArray]
find_all is another name for Array.filter.
find_default [BatHashtbl.Cap]
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 [BatText]
find_from s ofs x behaves as find s x but starts searching at offset ofs.
find_from [BatString.Cap.Exceptionless]
find_from [BatString.Cap]
find_from [BatString.Exceptionless]
find_from s ofs x behaves as find s x but starts searching at offset ofs.
find_from [BatString]
find_from s pos x behaves as find s x but starts searching at position pos.
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.Exceptionless]
find_map f xs returns Some y such that x is the first element of the list where f x returns Some y.
find_map [BatList]
find_map pred list finds the first element of list for which pred element returns Some r.
find_map [BatEnum]
find_map f e finds the first element x of e such that f x returns Some r, then returns r.
find_min [BatHeap.H]
find_min [BatHeap]
Find the minimal element of the heap.
find_option [BatHashtbl.Cap]
find_option [BatHashtbl.S]
find_option [BatHashtbl]
Find a binding for the key, or return None if no value is found
findi [BatVect.Make]
findi p a returns the index of the first element of vect a that satisfies the predicate p.
findi [BatVect]
findi p a returns the index of the first element of vect 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
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.
findi [BatArray.Cap.Exceptionless]
findi [BatArray.Cap]
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]
findi p a returns the index of the first element of array a that satisfies the predicate p.
first [BatVect.Make]
first [BatVect]
first [BatUTF8]
The position of the head of the first Unicode character.
first [BatTuple.Tuple5]
first [BatTuple.Tuple4]
first [BatTuple.Tuple3]
first [BatTuple.Tuple2]
Equivalent to Pervasives.fst.
first [BatSubstring]
first sus returns Some c where c is the first character in sus, if sus is non-empty; otherwise returns None.
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 [BatList]
Returns the first element of the list, or
first [BatLazyList]
As hd
flags [BatLog.Config]
flags [BatLog]
This ref holds the output flags.
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 [BatPervasives]
Argument flipping.
flip [BatInnerPervasives]
float [BatRandom.Incubator.Private_state_enums.State]
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_dynarray [BatteriesPrint]
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.
floats_of [BatIO.BigEndian]
Read an enumeration of IEEE single precision floating point values.
floats_of [BatIO]
Read an enumeration of IEEE single precision floating point values.
floor [BatNum]
floor [BatFloat.Safe_float]
Round the given float to an integer value.
floor [BatFloat]
Round the given float to an integer value.
floor_num [BatNum]
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.
flush_input [BatLexing]
Discard the contents of the buffer and reset the current position to 0.
flush_str_formatter [BatFormat]
Returns the material printed with str_formatter, flushes the formatter and resets the corresponding buffer.
fold [BatVect.Make]
An alias for fold_left
fold [BatVect]
An alias for BatVect.fold_left
fold [BatText]
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 [BatStream.StreamLabels]
fold [BatStream]
fold is foldl without initialization value, where the first element of stream is taken as init.
fold [BatSet.PSet]
fold f s a computes (f xN ... (f x1 (f x0 a))...), where x0,x1..xN are the elements of s, in increasing order.
fold [BatSet.S.Labels]
fold [BatSet.S]
fold f s a computes (f xN ... (f x1 (f x0 a))...), where x0,x1..
fold [BatSet]
fold f s a computes (f xN ... (f x1 (f x0 a))...), where x0,x1..xN are the elements of s, in increasing order.
fold [BatQueue]
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 [BatMultiPMap]
fold f m a computes (f kN dN ... (f k1 d1 (f k0 d0 a))...), where k0,k1..kN are the keys of all bindings in m, and d0,d1..dN are the associated data.
fold [BatMultiMap]
fold f m a computes (f kN dN ... (f k1 d1 (f k0 d0 a))...), where k0,k1..kN are the keys of all bindings in m, and d0,d1..dN are the associated data.
fold [BatMap.PMap]
fold f m a computes (f kN dN ... (f k1 d1 (f k0 d0 a))...), where k0,k1..kN are the keys of all bindings in m, and d0,d1..dN are the associated data.
fold [BatMap.S.Labels]
fold [BatMap.S]
fold f m a computes (f kN dN ... (f k1 d1 (f k0 d0 a))...), where k0,k1..kN are the keys of all bindings in m (in increasing order), and d1 ... dN are the associated data.
fold [BatMap]
fold f m a computes (f kN dN ... (f k1 d1 (f k0 d0 a))...), where k0,k1..kN are the keys of all bindings in m, and d0,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 f t x0 returns the final result of merging each element of t into x0 using merge function f
fold [BatIMap]
fold f t x0 folds all the bindings of t into x0 using f to merge.
fold [BatHashtbl.Cap.Labels]
fold [BatHashtbl.Cap]
fold [BatHashtbl.S.Labels]
fold [BatHashtbl.S]
fold [BatHashtbl.Labels]
fold [BatHashtbl]
Hashtbl.fold f tbl init computes (f kN dN ... (f k1 d1 (f k0 d0 init))...), where k0,k1..kN are the keys of all bindings in tbl, and d0,d1..dN are the associated values.
fold [BatHashcons.Table]
fold f tab x0 folds f across every live hashed object in the table tab, starting with value x0
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.Cap]
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 b0 (... bn)) is f (... (f (f a b0) b1) ...) bn.
fold_left [BatRefList]
List.fold_left f a (ref [b0; b1; ...; bn]) is f (... (f (f a b0) b1) ...) bn.
fold_left [BatList.Labels]
fold_left [BatList]
List.fold_left f a [b1; ...; bn] is f (... (f (f a b1) b2) ...) bn.
fold_left [BatLazyList.Labels]
fold_left [BatLazyList]
Eager fold_left
fold_left [BatFingerTree.S]
fold_left is equivalent to List.fold_left.
fold_left [BatDynArray]
fold_left f x darr computes f ( ... ( f ( f a0 x) a1) ) ... ) aN, where a0,a1..aN are the indexed elements of darr.
fold_left [BatDllist]
Accumulate a value over the entire list.
fold_left [BatDeque]
fold_left f acc dq is equivalent to List.fold_left f acc (to_list dq), but more efficient.
fold_left [BatArray.Cap.Labels]
fold_left [BatArray.Cap]
fold_left [BatArray.Labels]
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 [b0; b1; ...; bn] [c0; c1; ...; cn] is f (... (f (f a b0 c0) b1 c1) ...) bn cn.
fold_left2 [BatLazyList]
fold_left2 f a [^ b0; b1; ...; bn ^] [^ c0; c1; ...; cn ^] is f (... (f (f a b0 c0) b1 c1) ...) bn cn.
fold_lefti [BatArray]
As fold_left, but with the index of the element as additional argument
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]
As fold, but operates on contiguous ranges
fold_range [BatIMap]
fold_range f t x0 folds all the contiguous ranges of t into x0 using f to merge.
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.Cap]
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 a0 (cons a1 (cons a2 ...))) b is f a0 (f a1 (f a2 ...)).
fold_right [BatRefList]
List.fold_right f (ref [a0; a1; ...; an]) b is f a0 (f a1 (... (f an b) ...)).
fold_right [BatList.Labels]
fold_right [BatList]
List.fold_right f [a0; a1; ...; an] b is f a0 (f a1 (... (f an b) ...)).
fold_right [BatLazyList.Labels]
fold_right [BatLazyList]
Eager fold_right
fold_right [BatFingerTree.S]
fold_right is equivalent to List.fold_right.
fold_right [BatDynArray]
fold_right f darr x computes f a0 (f a1 ( ... ( f aN x ) ... ) ) , where a0,a1..aN are the indexed elements of darr.
fold_right [BatDllist]
Accumulate a value over the entire list.
fold_right [BatDeque]
fold_right f dq acc is equivalent to List.fold_right f (to_list dq) acc, but more efficient.
fold_right [BatArray.Cap.Labels]
fold_right [BatArray.Cap]
fold_right [BatArray.Labels]
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 [a0; a1; ...; an] [b0; b1; ...; bn] c is f a0 b0 (f a1 b1 (... (f an bn c) ...)).
fold_right2 [BatLazyList.Labels]
fold_right2 [BatLazyList]
fold_right2 f [^ a0; a1; ...; an ^] [^ b0; b1; ...; bn ^] c is f a0 b0 (f a1 b1 (... (f an bn c) ...)).
fold_righti [BatArray]
As fold_right, but with the index of the element as additional argument
foldi [BatVect.Make]
As fold, but with the position of each value passed to the folding function
foldi [BatVect]
As BatVect.fold, but with the position of each value passed to the folding function
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 [BatMultiMap]
Same as fold, but the function receives as arguments both the key and the associated value for each binding of the map.
foldi [BatMap.PMap]
Same as fold, but the function receives as arguments both the key and the associated value for each binding of the map.
foldi [BatMap]
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 [BatStream]
foldl f init stream is a lazy fold_left.
foldr [BatStream.StreamLabels]
foldr [BatStream]
foldr f init stream is a lazy fold_right.
for_all [BatVect.Make]
for_all p [a0; a1; ...; an] checks if all elements of the vect satisfy the predicate p.
for_all [BatVect]
for_all p [a0; a1; ...; an] checks if all elements of the vect satisfy the predicate p.
for_all [BatSet.PSet]
Returns whether the given predicate applies to all elements in the set
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 [BatSet]
Returns whether the given predicate applies to all elements in the set
for_all [BatSeq]
for_all p (cons a0 (cons a1 ...)) 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 [BatMap.PMap]
Tests whether all key value pairs satisfy some predicate function
for_all [BatMap.S]
for_all p m checks if all the bindings of the map satisfy the predicate p.
for_all [BatMap]
Tests whether all key value pairs satisfy some predicate function
for_all [BatList.Labels]
for_all [BatList]
for_all p [a1; ...; an] checks if all elements of the list satisfy the predicate p.
for_all [BatLazyList.Labels]
for_all [BatLazyList]
Eager universal.
for_all [BatISet]
Tests whether a predicate applies to all elements of the set
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]
Test whether a given predicate returns true for all members of the given list.
for_all [BatArray.Cap.Labels]
for_all [BatArray.Cap]
for_all [BatArray.Labels]
for_all [BatArray]
for_all p [|a0; 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.
force_newline [BatFormat]
Forces a newline in the current box.
foreach [BatPervasives]
Imperative loop on an enumeration.
forever [BatPervasives]
forever f x invokes f on x repeatedly (until an exception occurs).
forever [BatInnerPervasives]
fork [BatUnix]
Fork a new process.
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_buffer [BatFormat]
formatter_of_buffer b returns a new formatter writing to buffer b.
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]
fourth [BatTuple.Tuple5]
fourth [BatTuple.Tuple4]
fprintf [BatPrintf]
General function.
fprintf [BatFormat]
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 [BatStream]
Stream.from f returns a stream built from the function f.
from [BatLazyList]
from next creates a (possibly infinite) lazy list from the successive results of next.
from [BatISet]
from x t returns the portion of t in the range x, max_int
from [BatIMap]
Return the sub-map of bindings in the range x,max_int
from [BatEnum.Labels]
from [BatEnum]
from next creates an enumeration from the next function.
from_channel [BatScanf.Scanning]
from_channel [BatMarshal]
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_function [BatLexing]
Create a lexer buffer with the given function as its reading method.
from_hex [BatDigest]
Convert a hexadecimal representation back into the corresponding digest.
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_string [BatMarshal]
Marshal.from_string buff ofs unmarshals a structured value like Marshal.from_channel does, except that the byte representation is not read from a channel, but taken from the string buff, starting at position ofs.
from_string [BatLexing]
Create a lexer 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.
front [BatFingerTree.S]
front t returns None when t is empty, or Some (tl, hd) when hd is the first element of the sequence and tl is the rest of the sequence.
front [BatDeque]
front dq returns Some (x, dq') iff x is at the front of dq and dq' is the rest of dq excluding x, and None if dq has no elements.
front_exn [BatFingerTree.S]
front_exn t returns (tl, hd) when hd is the first element of the sequence and tl is the rest of the sequence.
fscanf [BatScanf]
Same as Scanf.bscanf, but reads from the given channel.
fstat [BatUnix.LargeFile]
fstat [BatUnix]
Return the information for the file associated with the given descriptor.
fsum [BatList]
fsum l returns the sum of the floats of l
fsum [BatEnum]
fsum [BatArray]
fsum l returns the sum of the floats of l
ftruncate [BatUnix.LargeFile]
ftruncate [BatUnix]
Truncates the file corresponding to the given descriptor to the given size.
full_init [BatRandom]
Same as Random.init but takes more data as seed.
full_major [BatGc]
Do a minor collection, finish the current major collection cycle, and perform a complete new cycle.
full_range_int [BatRandom]
full_range_int () returns the maximum entropy possible in a single int: 31 bits on 32-bit platforms and 63 bits on 64-bit platforms.

G
gcd_big_int [BatBig_int]
Greatest common divisor of two big integers.
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 v n returns the (n+1)th element from the vect v; 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 n-th Unicode character of s.
get [BatText]
get r n returns the (n+1)th character from the rope r; i.e.
get [BatSubstring]
sub sus k returns the k'th character of the substring; that is, s(i+k) where sus = (s, i, n).
get [BatString.Cap]
get [BatString]
String.get s n returns character number n in string s.
get [BatResult]
get (Ok x) returns x, and get (Bad e) raises 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.
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]
Return None if the global is undefined, else Some v where v is the current global value contents.
get [BatGc]
Return the current values of the GC parameters in a control record.
get [BatFingerTree]
get t i returns the i-th element of t.
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]
get [BatArray]
Array.get a n returns the element number n of array a.
get12 [BatTuple.Tuple5]
get12 [BatTuple.Tuple4]
get12 [BatTuple.Tuple3]
get123 [BatTuple.Tuple5]
get123 [BatTuple.Tuple4]
get1234 [BatTuple.Tuple5]
get1235 [BatTuple.Tuple5]
get124 [BatTuple.Tuple5]
get124 [BatTuple.Tuple4]
get1245 [BatTuple.Tuple5]
get125 [BatTuple.Tuple5]
get13 [BatTuple.Tuple5]
get13 [BatTuple.Tuple4]
get13 [BatTuple.Tuple3]
get134 [BatTuple.Tuple5]
get1345 [BatTuple.Tuple5]
get135 [BatTuple.Tuple5]
get14 [BatTuple.Tuple5]
get14 [BatTuple.Tuple4]
get145 [BatTuple.Tuple5]
get15 [BatTuple.Tuple5]
get23 [BatTuple.Tuple5]
get23 [BatTuple.Tuple4]
get23 [BatTuple.Tuple3]
get234 [BatTuple.Tuple5]
get234 [BatTuple.Tuple4]
get2345 [BatTuple.Tuple5]
get235 [BatTuple.Tuple5]
get24 [BatTuple.Tuple5]
get24 [BatTuple.Tuple4]
get245 [BatTuple.Tuple5]
get25 [BatTuple.Tuple5]
get34 [BatTuple.Tuple5]
get34 [BatTuple.Tuple4]
get345 [BatTuple.Tuple5]
get35 [BatTuple.Tuple5]
get45 [BatTuple.Tuple5]
get_all_formatter_output_functions [BatFormat]
Return the current output functions of the pretty-printer, including line breaking and indentation functions.
get_backtrace [BatPrintexc]
Printexc.get_backtrace () returns a string containing the same exception backtrace that Printexc.print_backtrace would print.
get_cmp [BatSet.PSet]
get the comparison function used for a polymorphic map
get_cmp [BatMap.PMap]
returns the comparison function of the given map
get_dec_eq [BatIMap]
Get the equality function used in an IMap.t
get_ellipsis_text [BatFormat]
Return the text of the ellipsis.
get_exn [BatOption]
get_exn (Some x) e returns x and get_exn None e raises e.
get_exn [BatGlobal]
Get the global value contents - raise Global_not_initialized if not defined.
get_exn [BatEnum]
get_exn e returns the first element of e.
get_formatter_output_functions [BatFormat]
Return the current output functions of the pretty-printer.
get_formatter_tag_functions [BatFormat]
Return the current tag functions of the pretty-printer.
get_margin [BatFormat]
Returns the position of the right margin.
get_mark_tags [BatFormat]
Return the current status of tags printing and tags marking.
get_max_boxes [BatFormat]
Returns the maximum number of boxes allowed before ellipsis.
get_max_indent [BatFormat]
Return the value of the maximum indentation limit (in characters).
get_method [BatOo.Internal]
get_method_label [BatOo.Internal]
get_method_labels [BatOo.Internal]
get_print_tags [BatFormat]
get_public_method [BatOo.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.Internal]
get_variables [BatOo.Internal]
getaddrinfo [BatUnix]
getaddrinfo host service opts returns a list of Unix.addr_info records describing socket parameters and addresses suitable for communicating with the given host and service.
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.
getcwd [BatUnix]
Return the name of the current working directory.
getcwd [BatSys]
Return the current working directory of the process.
getegid [BatUnix]
Return the effective group id under which the process runs.
getenv [BatUnix]
Return the value associated to a variable in the process environment.
getenv [BatSys]
Return the value associated to a variable in the process environment.
geteuid [BatUnix]
Return the effective user id under which the process runs.
getgid [BatUnix]
Return the group id of the user executing the process.
getgrgid [BatUnix]
Find an entry in group with the given group id.
getgrnam [BatUnix]
Find an entry in group with the given name.
getgroups [BatUnix]
Return the list of groups to which the user executing the process belongs.
gethostbyaddr [BatUnix]
Find an entry in hosts with the given address.
gethostbyname [BatUnix]
Find an entry in hosts with the given name.
gethostname [BatUnix]
Return the name of the local host.
getitimer [BatUnix]
Return the current status of the given interval timer.
getlogin [BatUnix]
Return the login name of the user executing the process.
getnameinfo [BatUnix]
getnameinfo addr opts returns the host name and service name corresponding to the socket address addr.
getpeername [BatUnix]
Return the address of the host connected to the given socket.
getpid [BatUnix]
Return the pid of the process.
getppid [BatUnix]
Return the pid of the parent process.
getprotobyname [BatUnix]
Find an entry in protocols with the given name
getprotobynumber [BatUnix]
Find an entry in protocols with the given protocol number.
getpwnam [BatUnix]
Find an entry in passwd with the given name.
getpwuid [BatUnix]
Find an entry in passwd with the given user id.
getservbyname [BatUnix]
Find an entry in services with the given name.
getservbyport [BatUnix]
Find an entry in services with the given service number.
getsockname [BatUnix]
Return the address of the given socket.
getsockopt [BatUnix]
Return the current status of a boolean-valued option in the given socket.
getsockopt_error [BatUnix]
Return the error condition associated with the given socket, and clear it.
getsockopt_float [BatUnix]
Same as Unix.getsockopt for a socket option whose value is a floating-point number.
getsockopt_int [BatUnix]
Same as Unix.getsockopt for an integer-valued socket option.
getsockopt_optint [BatUnix]
Same as Unix.getsockopt for a socket option whose value is an int option.
gettimeofday [BatUnix]
Same as Unix.time, but with resolution better than 1 second.
getuid [BatUnix]
Return the user id of the user executing the process.
gmtime [BatUnix]
Convert a time in seconds, as returned by Unix.time, into a date and a time.
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 divides e into an enumeration of enumerations, where each sub-enumeration is the longest continuous enumeration of elements whose test results are the same.
group_by [BatEnum]
group_by eq e divides e into an enumeration of enumerations, where each sub-enumeration is the longest continuous enumeration of elements that are equal, as judged by eq.
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_unix_error [BatUnix]
handle_unix_error f x applies f to x and returns the result.
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 [BatChar]
hash_param [BatHashtbl]
Hashtbl.hash_param n m x computes a hash value for x, with the same properties as for hash.
hashcons [BatHashcons.Table]
hashcons tab k returns either k, adding it to the table tab as a side effect, or if k is already in the table then it returns the hashed object corresponding to that entry.
hc0 [BatHashcons.H]
hc0 ho is the hashcode of a first constructor applied to the hashed object ho
hc0_ [BatHashcons.H]
hc0_ h corresponds to the hashcode of a first constructor applied to an object of hashcode h
hc1 [BatHashcons.H]
hc1 ho k corresponds to the hashcode of the kth constructor applied to the hashed object ho.
hc1_ [BatHashcons.H]
hc1_ h k corresponds to the hashcode of the kth constructor applied to an object of hashcode h.
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 [BatList.Exceptionless]
hd l returns Some x such that x is the first element of the given list l.
hd [BatList]
Similar to first, but
hd [BatLazyList]
Return the first element of the given list.
head [BatText]
head [BatString.Cap]
head [BatString]
head [BatFingerTree.S]
head t returns None if t is empty, or Some hd otherwise, where hd is the first element of the sequence.
head [BatArray]
head_exn [BatFingerTree.S]
head_exn t returns the first element of the sequence.
header_size [BatMarshal]
The bytes representing a marshaled value are composed of a fixed-size header and a variable-sized data part, whose size can be determined from the header.
height [BatVect.Make]
Returns the height (depth) of the vect.
height [BatVect]
Returns the height (depth) of the vect.
height [BatText]
Returns the height (depth) of the rope.
height [BatAvlTree]
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 [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 [BatString.Cap]
icompare [BatString]
Compare two strings, case-insensitive.
id [BatOo]
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 [BatPervasives]
The identity function.
identity [BatInnerPervasives]
ifprintf [BatPrintf]
As BatPrintf.fprintf but doesn't actually print anything.
ifprintf [BatFormat]
Same as fprintf above, but does not print anything.
ignore_exceptions [BatPervasives]
ignore_exceptions f x invokes f on x, ignoring both the returned value and the exceptions that may be raised.
ignore_exceptions [BatInnerPervasives]
ignore_ok [BatPervasives]
ignore_ok (f x) ignores the result of f x if it's ok, but throws the exception contained if Bad is returned.
ignore_ok [BatInnerPervasives]
ignore_one_plus [BatParserCo]
Ignore a (non-empty) list of expressions.
ignore_zero_plus [BatParserCo]
Ignore a (possibly empty) list of expressions.
ikfprintf [BatFormat]
Same as kfprintf above, but does not print anything.
implode [BatText]
implode cs returns a rope resulting from concatenating the characters in the list cs.
implode [BatString.Cap]
implode [BatString]
implode cs returns a string resulting from concatenating the characters in the list cs.
in_channel_of_descr [BatUnix]
Create an input channel reading from the given descriptor.
in_place_mirror [BatString]
in_place_mirror s mutates the string s, so that its new value is the mirror of its old one: for instance if s contained "Example!", after the mutation it will contain "!elpmaxE".
incr_num [BatNum]
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 [BatText]
Rope.index s c returns the position of the leftmost occurrence of character c in rope s.
index [BatSubstring]
index sus c returns the index of the first occurence of c in sus or
index [BatString.Cap.Exceptionless]
index [BatString.Cap]
index [BatString.Exceptionless]
index s c returns Some p, the position of the leftmost occurrence of character c in string s or None if c does not occur in s.
index [BatString]
String.index s c returns the character number of the first occurrence of character c in string 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 [BatText]
Same as Rope.index, but start searching at the character position given as second argument.
index_from [BatSubstring]
index_from sus i c returns the index of the first occurence of c in sus after the index i or
index_from [BatString.Cap.Exceptionless]
index_from [BatString.Cap]
index_from [BatString.Exceptionless]
Same as String.Exceptionless.index, but start searching at the character position given as second argument.
index_from [BatString]
String.index_from s i c returns the character number of the first occurrence of character c in string s after position i.
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
inet6_addr_any [BatUnix]
A special IPv6 address, for use only with bind, representing all the Internet addresses that the host machine possesses.
inet6_addr_loopback [BatUnix]
A special IPv6 address representing the host machine (::1).
inet_addr_any [BatUnix]
A special IPv4 address, for use only with bind, representing all the Internet addresses that the host machine possesses.
inet_addr_loopback [BatUnix]
A special IPv4 address representing the host machine (127.0.0.1).
inet_addr_of_string [BatUnix]
Conversion from the printable representation of an Internet address to its internal representation.
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.Internal]
init [BatVect.Make]
init n f returns a fresh vect of length n, with element number i initialized to the result of f i.
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 [BatText]
init l f returns the rope of length l with the chars f 0 , f 1 , f 2 ...
init [BatString.Cap]
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 [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 [BatFingerTree.S]
init t returns None if t is empty, or Some init where init is the sequence t where the last element has been removed.
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.Cap.Labels]
init [BatArray.Cap]
init [BatArray.Labels]
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.Internal]
init_exn [BatFingerTree.S]
init_exn t returns the sequence t where the last element has been removed.
init_from_string [BatLogger]
init_from_string name_level_string formatter initializes the logging system enabling the specified levels for each named logger.
initgroups [BatUnix]
initgroups user group initializes the group access list by reading the group database /etc/group and using all groups of which user is a member.
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_all [BatPervasives]
Return the whole contents of an input channel as a single string.
input_binary_float [BatPervasives]
Read a float encoded in binary format (8 bytes, IEEE 754 double format) from the given input channel.
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_chars [BatPervasives]
Returns an enumeration over characters of an input channel.
input_enum [BatIO]
Create an input that will read from an enum.
input_file [BatPervasives]
returns the data of a given filename.
input_line [BatPervasives]
Read characters from the given input channel, until a newline character is encountered.
input_lines [BatPervasives]
Returns an enumeration over lines of an input channel, as read by the input_line function.
input_list [BatPervasives]
Returns the list of lines read from an input channel.
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 [BatText]
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 [BatHeap.H]
insert [BatHeap]
Insert an element into the heap.
insert [BatDynArray]
insert darr idx v inserts v into darr at index idx.
insert [BatArray]
insert xs x i returns a copy of xs except the value x is inserted in position i (and all later indices are shifted to the right).
int [BatRandom.Incubator.Private_state_enums.State]
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.Incubator.Private_state_enums.State]
int32 [BatRandom.State]
int32 [BatRandom]
Random.int32 bound returns a random integer between 0 (inclusive) and bound (exclusive).
int32 [BatBigarray]
See Bigarray.char.
int32_of_big_int [BatBig_int]
Convert a big integer to a 32-bit integer.
int64 [BatRandom.Incubator.Private_state_enums.State]
int64 [BatRandom.State]
int64 [BatRandom]
Random.int64 bound returns a random integer between 0 (inclusive) and bound (exclusive).
int64 [BatBigarray]
See Bigarray.char.
int64_of_big_int [BatBig_int]
Convert a big integer to a 64-bit integer.
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_dynarray [BatteriesPrint]
int_enum [BatteriesPrint]
int_int_pmap [BatteriesPrint]
int_of [BatUChar]
Alias of code
int_of_big_int [BatBig_int]
Convert a big integer to a small integer (type int).
int_of_num [BatNum]
int_option [BatOptParse.StdOpt]
int_option ?default ?metavar () returns an option which takes a single integer argument.
int_pset [BatteriesPrint]
int_set [BatteriesPrint]
int_str_pmap [BatteriesPrint]
integer [BatGenlex.Languages.Make]
Parse an integer.
integer_num [BatNum]
inter [BatSet.S]
Set intersection.
inter [BatISet]
Compute the intersection of two sets.
inter [BatBitSet]
inter s t returns the intersection of sets s and t.
interactive [BatSys]
This reference is initially set to false in standalone programs and to true if the code is being executed under the interactive toplevel system ocaml.
interleave [BatList]
interleave ~first ~last sep [a0;a1;a2;...;an] returns first; a0; sep; a1; sep; a2; sep; ...; sep; an; last
intersect [BatSet.PSet]
intersect s t returns a new set of those elements that are in both s and t.
intersect [BatSet]
intersect s t returns a new set of those elements that are in both s and t.
intersect [BatMap.PMap]
intersect merge_f m1 m2 returns a map with bindings only for keys bound in both m1 and m2, and with k bound to merge_f v1 v2, where v1 and v2 are k's bindings in m1 and m2.
intersect [BatMap]
intersect merge_f m1 m2 returns a map with bindings only for keys bound in both m1 and m2, and with k bound to merge_f v1 v2, where v1 and v2 are k's bindings in m1 and m2.
intersect [BatBitSet]
intersect s t sets s to the intersection of the sets s and t.
inv [BatComplex]
Multiplicative inverse (1/z).
invpi [BatFloat]
1. /. pi
invpi2 [BatFloat]
2. /. pi
invsqrt2 [BatFloat]
1. /. sqrt 2.
is_absolute [BatPathGen.PathType]
is_bad [BatResult]
is_bad (Bad _) is true, otherwise false
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_directory [BatSys]
Returns true if the given name refers to a directory, false if it refers to another kind of file.
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 [BatText]
Returns whether the rope is empty or not.
is_empty [BatSubstring]
isEmpty (s, i, n) true if the substring is empty (that is, n = 0).
is_empty [BatString.Cap]
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 [BatStack]
Return true if the given stack is empty, false otherwise.
is_empty [BatSet.PSet]
Test whether a set is empty or not.
is_empty [BatSet.S]
Test whether a set is empty or not.
is_empty [BatSet]
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 [BatRefList]
Return true if a ref list is empty
is_empty [BatQueue]
Return true if the given queue is empty, false otherwise.
is_empty [BatMultiPMap]
returns true if the map is empty.
is_empty [BatMultiMap]
returns true if the map is empty.
is_empty [BatMap.PMap]
returns true if the map is empty.
is_empty [BatMap.S]
Test whether a map is empty or not.
is_empty [BatMap]
returns true if the map is empty.
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]
Test whether a set is empty, returns true if the set is empty.
is_empty [BatIMap]
Test whether a map is empty (i.e.
is_empty [BatHashtbl.Cap]
is_empty [BatHashtbl.S]
is_empty [BatHashtbl]
Hashtbl.is_empty tbl returns true if there are no bindings in tbl, false otherwise.
is_empty [BatFingerTree.S]
is_empty t returns true when the sequence has no elements.
is_empty [BatEnum]
is_empty e returns true if e does not contains any element.
is_empty [BatDeque]
is_empty dq returns false iff dq has no elements.
is_empty [BatAvlTree]
is_exn [BatResult]
is_exn e1 r is true iff r is Bad e2 with e1=e2
is_finite [BatFloat]
is_finite f returns true if f is not nan or +/- infinity, false otherwise.
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_integer_num [BatNum]
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 [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 [BatChar]
Determine if a character is a newline.
is_none [BatOption]
is_none None returns true otherwise it returns false.
is_ok [BatResult]
is_ok (Ok _) is true, otherwise false.
is_prefix [BatSubstring]
is_prefix 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_some [BatOption]
is_some (Some x) returns true otherwise it returns false.
is_special [BatFloat]
is_special f returns true if f is nan or +/- infinity, false otherwise.
is_symbol [BatChar]
Determine if a character represents a (OCaml-style) symbol.
is_uppercase [BatChar]
Determine if a character is uppercase ASCII.
is_uppercase_latin1 [BatChar]
Determine if a character is uppercase Latin 1.
is_whitespace [BatChar]
Determine if a character is a whitespace.
isatty [BatUnix]
Return true if the given file descriptor refers to a terminal or console window, false otherwise.
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 [BatText]
iter f r applies f to all the characters in the r rope, in order.
iter [BatSubstring]
iter f sus applies f to all characters of sus, from left to right.
iter [BatString.Cap]
iter [BatString]
String.iter f s applies function f in turn to all the characters of s.
iter [BatStream.StreamLabels]
iter [BatStream]
Stream.iter f s scans the whole stream s, applying function f in turn to each stream element encountered.
iter [BatStack]
iter f s applies f in turn to all elements of s, from the element at the top of the stack to the element at the bottom of the stack.
iter [BatSet.PSet]
iter f s applies f in turn to all elements of s.
iter [BatSet.S.Labels]
iter [BatSet.S]
iter f s applies f in turn to all elements of s.
iter [BatSet]
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 [BatRefList]
Apply the given function to all elements of the ref list, in respect with the order of the list
iter [BatQueue]
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 [BatMultiPMap]
iter f m applies f to all bindings in map m.
iter [BatMultiMap]
iter f m applies f to all bindings in map m.
iter [BatMap.PMap]
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 [BatMap]
iter f m applies f to all bindings in map m.
iter [BatList.Labels]
iter [BatList]
List.iter f [a1; ...; an] applies function f in turn to a1; ...; an.
iter [BatLazyList.Labels]
iter [BatLazyList]
Eager iteration
iter [BatInnerWeaktbl]
Weaktbl.iter f tbl applies f to all bindings in table tbl.
iter [BatISet]
iter f t calls f once for each element of t
iter [BatIMap]
iter f t calls f on every binding
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 [BatHashcons.Table]
iter f tab applies f to every live hashed object in the table tab.
iter [BatFingerTree.S]
iter is equivalent to List.iter.
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 [BatDeque]
iter f dq calls f x on each element x of dq.
iter [BatBigarray.Genarray]
iter f a applies function f in turn to all the elements of a.
iter [BatAvlTree]
iter [BatArray.Cap.Labels]
iter [BatArray.Cap]
iter [BatArray.Labels]
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 [a0; a1; ...; an] [b0; b1; ...; bn] calls in turn f a0 b0; f a1 b1; ...; f an bn.
iter2 [BatLazyList.Labels]
iter2 [BatLazyList]
iter2 f [^ a0; ...; an ^] [^ b0; ...; bn ^] calls in turn f a0 b0; ...; f an bn.
iter2 [BatEnum.Labels]
iter2 [BatEnum]
iter2 f e1 e2 calls the function f with the next elements of e1 and e2 repeatedly until one of the two enumerations ends.
iter2 [BatArray.Cap.Labels]
iter2 [BatArray.Cap]
iter2 [BatArray.Labels]
iter2 [BatArray]
Array.iter2 f [|a0; a1; ...; an|] [|b0; b1; ...; bn|] performs calls f a0 b0; f a1 b1; ...; f an bn in that order.
iter2i [BatEnum.Labels]
iter2i [BatEnum]
iter2i [BatArray.Cap.Labels]
iter2i [BatArray.Cap]
iter2i [BatArray.Labels]
iter2i [BatArray]
Array.iter2i f [|a0; a1; ...; an|] [|b0; b1; ...; bn|] performs calls f 0 a0 b0; f 1 a1 b1; ...; f n an bn in that order.
iter_range [BatISet]
iter_range f t calls f once for each contiguous range of t.
iter_range [BatIMap]
iter_range f t calls f on every contiguous range.
iter_right [BatFingerTree.S]
iter_right is equivalent to List.iter o List.rev.
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 [BatText]
Operates like iter, but also passes the index of the character to the given function.
iteri [BatString]
Same as String.iter, but the function is applied to the index of the element as first argument (counting from 0), and the character itself as second argument.
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 [BatDeque]
iteri f dq calls f n x on each element x of dq.
iteri [BatBigarray.Genarray]
Same as BatBigarray.Genarray.iter, but the function is applied to the index of the element as the first argument, and the element itself as the second argument.
iteri [BatArray.Cap.Labels]
iteri [BatArray.Cap]
iteri [BatArray.Labels]
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 [BatText]
Same as BatText.concat
join [BatString.Cap]
join [BatString]
join [BatPathGen.PathType]
Create a path from given components.
junk [BatStream]
Remove the first element of the stream, possibly unfreezing it before.
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.
kbprintf2 [BatPrintf]
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.PMap]
Return an enumeration of all the keys of a map.
keys [BatMap.S]
Return an enumeration of all the keys of a map.
keys [BatMap]
Return an enumeration of all the keys of a map.
keys [BatHashtbl.Cap]
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 [BatFormat]
Same as fprintf above, but instead of returning immediately, passes the formatter to its first argument at the end of printing.
kill [BatUnix]
kill pid sig sends signal number sig to the process with id pid.
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 [BatFormat]
A deprecated synonym for ksprintf.
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 [BatFormat]
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.
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.Make]
These return the first and last values in the vector
last [BatVect]
These return the first and last values in the vector
last [BatUTF8]
The position of the head of the last Unicode character.
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.Exceptionless]
last l returns either Some x where x is the last element of the list, or None if the list is empty.
last [BatList]
Returns the last element of the list, or
last [BatLazyList]
Returns the last element of the list.
last [BatFingerTree.S]
last t returns None if t is empty, or Some hd otherwise, where hd is the last element of the sequence.
last [BatDynArray]
last darr returns the last element of darr.
last_exn [BatFingerTree.S]
last_exn t returns the last element of the sequence.
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 [BatText]
Returns the same rope but without the first character.
lchop [BatString.Cap]
lchop [BatString]
Returns the same string but without the first n characters.
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 [BatText]
left r len returns the rope containing the len first characters of r
left [BatString.Cap]
left [BatString]
left r len returns the string containing the len first characters of r.
left [BatArray]
left r len returns the array 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 [BatText]
Returns the length of the rope (O(1)).
length [BatSubstring]
Equivalent to BatSubstring.size.
length [BatString.Cap]
length [BatString]
Return the length (number of characters) of the given string.
length [BatStack]
Return the number of elements in a stack.
length [BatSeq]
Return the number of elements of the given sequence.
length [BatRefList]
Returns the number of elements - O(n)
length [BatQueue]
Return the number of elements in a queue.
length [BatPathGen.StringType]
Length - number of indexing units
length [BatList]
Return the length (number of elements) of the given list.
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 [BatBuffer]
Return the number of characters currently contained in the buffer.
length [BatArray.Cap]
length [BatArray]
Return the length (number of elements) of the given array.
letter [BatPathGen.StringType.Parse]
letter [BatCharParser]
Recognizes one lower- or upper-case ASCII character, including accentuated characters.
level [BatLog.Make_lev]
level [BatLog.Easy]
Set this ref to the lowest level of log you want logged.
level_of_name [BatLogger]
level_of_name str returns the level associated with str.
lexeme [BatLexing]
Lexing.lexeme lexbuf returns the string matched by the regular expression.
lexeme_char [BatLexing]
Lexing.lexeme_char lexbuf i returns character number i in the matched string.
lexeme_end [BatLexing]
Lexing.lexeme_end lexbuf returns the offset in the input stream of the character following the last character of the matched string.
lexeme_end_p [BatLexing]
Like lexeme_end, but return a complete position instead of an offset.
lexeme_start [BatLexing]
Lexing.lexeme_start lexbuf returns the offset in the input stream of the first character of the matched string.
lexeme_start_p [BatLexing]
Like lexeme_start, but return a complete position instead of an offset.
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 [BatText]
offer the lines of a UTF-8 encoded input as an enumeration
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.
lines_of2 [BatIO]
link [BatUnix]
link source dest creates a hard link named dest to the file named source.
listen [BatUnix]
Set up a socket for receiving connection requests.
ln10 [BatFloat]
log 10
ln2 [BatFloat]
log 2
localtime [BatUnix]
Convert a time in seconds, as returned by Unix.time, into a date and a time.
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 [BatInnerPervasives]
lock [BatIO]
A lock used to synchronize internal operations.
lock [BatConcurrent.BaseLock]
lock [BatConcurrent.Lock]
lock_factory [BatIO]
A factory used to create locks.
lockf [BatUnix]
lockf fd cmd size puts a lock on a region of the file opened as fd.
log [BatLogger]
log logger level event_fun raises a log event if if the specified level is currently enabled for the logger.
log [BatLog.Make_lev]
log [BatLog.Easy]
log lev msg logs the message msg if the current logging level is lev or lower.
log [BatLog.Make]
print s logs the message s, returning unit.
log [BatLog]
log s logs the message s, returning unit.
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.
log10e [BatFloat]
log10 e
log2e [BatFloat]
Math.log2 e
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.
logf [BatLog.Make_lev]
logf [BatLog.Easy]
As log, but instead of a string message, a printf format is allowed with whatever arguments are appropriate.
logf [BatLog.Make]
As Printf.printf, only the message is printed to the logging output and prefixed with status information per the current flags and the currently set prefix.
logf [BatLog]
As Printf.printf, only the message is printed to the logging output and prefixed with status information per the current flags and the currently set prefix.
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 [BatFingerTree.Generic]
lookup p t, when p is monotonic, returns the first element of the sequence for which the measure of its predecessors in the sequence (itself included) satisfies p.
lookup_tables [BatOo.Internal]
lowercase [BatString.Cap]
lowercase [BatString]
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 [BatChar]
Convert the given character to its equivalent lowercase character.
lowercase_latin1 [BatCharParser]
Recognizes one lower-case Latin-1 character, including accentuated characters.
lru_cache [BatCache]
lseek [BatUnix.LargeFile]
lseek [BatUnix]
Set the current position for a file descriptor
lstat [BatUnix.LargeFile]
lstat [BatUnix]
Same as Unix.stat, but in case the file is a symbolic link, return the information for the link itself.
lt_big_int [BatBig_int]
lt_num [BatNum]

M
major [BatGc]
Do a minor collection and finish the current major collection cycle.
major_slice [BatGc]
Do a minor collection and a slice of major collection.
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 [BatText]
make i c returns a rope of length i consisting of c chars; it is similar to String.make
make [BatSubstring]
make [BatString.Cap]
make [BatString]
String.make n c returns a fresh string of length n, filled with the character c.
make [BatSeq]
make n e returns the sequence of length n where all elements are e
make [BatRandom.Incubator.Private_state_enums.State]
Create a new state and initialize it with the given seed.
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]
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 [BatBounded.S]
make x will return a value of type BatBounded.S.t derived from x.
make [BatArray.Cap.Labels]
make [BatArray.Cap]
make [BatArray]
Array.make n x returns a fresh array of length n, initialized with x.
make_class [BatOo.Internal]
make_class_store [BatOo.Internal]
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_formatter [BatFormat]
make_formatter out flush returns a new formatter that writes according to the output function out, and the flushing function flush.
make_ht [BatCache]
Make a manual cache backed by a hashtable.
make_lexer [BatGenlex]
Construct the lexer function.
make_log [BatLogger]
make_log name returns a new logger.
make_logger [BatLog]
make_map [BatCache]
Make a manual cache for function ~gen backed by a Set.t.
make_matrix [BatArray.Cap.Labels]
make_matrix [BatArray.Cap]
make_matrix [BatArray.Labels]
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.Incubator.Private_state_enums.State]
Create a new state and initialize it with a system-dependent low-entropy seed.
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]
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 [BatTuple.Tuple5]
map [BatTuple.Tuple4]
map [BatTuple.Tuple3]
map [BatTuple.Tuple2]
Equivalent to BatPervasives.
(***)
.
map [BatText]
map f s returns a rope where all characters c in s have been replaced by f c.
map [BatString.Cap]
map [BatString]
String.map f s applies function f in turn to all the characters of s and stores the results in a new string that is returned.
map [BatStream.StreamLabels]
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.PSet]
map f x creates a new set with elements f a0, f a1...
map [BatSet.S.Labels]
map [BatSet.S]
map f x creates a new set with elements f a0, f a1...
map [BatSet]
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 [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 [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 [BatMultiMap]
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.PMap]
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 [BatMap]
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 [a0; a1; ...; an] applies function f to a0, a1, ..., an, and builds the list [f a0; 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]
Create a new map by modifying each y by the given function.
map [BatHashtbl.Cap.Labels]
map [BatHashtbl.Cap]
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 [BatFingerTree.S]
map is equivalent to List.map.
map [BatEnum.Labels]
map [BatEnum]
map f e returns an enumeration over (f a0, f a1, ...) where a0,a1... 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 [BatDeque]
map f dq returns a deque where every element x of dq has been replaces with f x.
map [BatBounded.S]
map f x applies f to x.
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 kind a applies function f to all the elements of a, and builds a Bigarray.t of kind kind with the results returned by f.
map [BatArray.Cap.Labels]
map [BatArray.Cap]
map [BatArray.Labels]
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) |].
map1 [BatTuple.Tuple5]
map1 [BatTuple.Tuple4]
map1 [BatTuple.Tuple3]
map1 [BatTuple.Tuple2]
map1 f (x,y) returns (f x,y)
map2 [BatTuple.Tuple5]
map2 [BatTuple.Tuple4]
map2 [BatTuple.Tuple3]
map2 [BatTuple.Tuple2]
map2 f (x,y) returns (x,f y)
map2 [BatStream.StreamLabels]
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 [a0; a1; ...; an] [b0; b1; ...; bn] is [f a0 b0; f a1 b1; ...; f an bn].
map2 [BatLazyList.Labels]
map2 [BatLazyList]
Operations on two lists
map2 [BatBounded.S]
map f x y applies f to x and y.
map2 [BatArray]
As Array.map but on two arrays.
map2_exn [BatBounded.S]
map f x y applies f to x and y.
map3 [BatTuple.Tuple5]
map3 [BatTuple.Tuple4]
map3 [BatTuple.Tuple3]
map4 [BatTuple.Tuple5]
map4 [BatTuple.Tuple4]
map5 [BatTuple.Tuple5]
map_comp [BatOrd]
map_default [BatResult]
map_default d f r evaluates to d if r is Bad else f x when r is Ok x
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_eq [BatOrd]
map_exn [BatBounded.S]
map_exn f x applies f to 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_ord [BatOrd]
These functions extend an existing equality/comparison/ordering to a new domain through a mapping function.
map_range [BatIMap]
Create a new map by modifying each y using the given function.
map_right [BatFingerTree.S]
map_right is equivalent to List.rev o List.map o List.rev.
map_to_set [BatIMap]
map_to_set p t returns the set of keys of t where p evaluates as true
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 [BatMultiPMap]
Same as map, but the function receives as arguments both the key and the associated value for each binding of the map.
mapi [BatMultiMap]
Same as map, but the function receives as arguments both the key and the associated value for each binding of the map.
mapi [BatMap.PMap]
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 [BatMap]
Same as 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]
Create a new map by computing new values based on key and value of the existing bindings.
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 f e returns an enumeration over (f 0 a0, f 1 a1, ...) where a0,a1... are the elements of e.
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 [BatDeque]
map f dq returns a deque where every element x of dq has been replaces with f n x, where n is the position of x from the front of dq.
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.Cap.Labels]
mapi [BatArray.Cap]
mapi [BatArray.Labels]
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.
mapn [BatTuple.Tuple5]
Like BatTuple.Tuple5.map but specialized for tuples with elements of the same type.
mapn [BatTuple.Tuple4]
Like BatTuple.Tuple4.map but specialized for tuples with elements of the same type.
mapn [BatTuple.Tuple3]
Like BatTuple.Tuple3.map but specialized for tuples with elements of the same type.
mapn [BatTuple.Tuple2]
Like BatTuple.Tuple2.map but specialized for tuples with elements of the same type.
max [BatSeq.Exceptionless]
max [BatSeq]
max s returns the largest value in s as judged by Pervasives.compare
max [BatOrd]
max ord will choose the biggest element according to ord.
max [BatList]
max l returns the largest value in l as judged by Pervasives.compare
max [BatInt]
The maximum of two integers.
max [BatFloat]
max [BatArray]
max a returns the largest value in a as judged by Pervasives.compare
max_array_length [BatteriesConfig]
max_array_length [BatSys]
Maximum length of a normal array.
max_big_int [BatBig_int]
Return the greater of its two arguments.
max_binding [BatMap.PMap]
returns the binding with the largest key
max_binding [BatMap.S]
return the (key,value) pair with the largest key
max_binding [BatMap]
returns the binding with the largest key
max_comp [BatOrd]
max_elt [BatSet.PSet]
returns the largest element of the set.
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 [BatSet]
returns the largest element of the set.
max_elt [BatISet]
Returns the maximum element in the set
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 [BatText]
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 greatest representable integer, which is either 230-1 or 262-1.
max_num [BatInt]
The greatest representable integer, which is either 230-1 or 262-1.
max_num [BatFloat.Safe_float]
max_num [BatFloat]
max_num [BatBool]
max_ord [BatOrd]
max_string_length [BatteriesConfig]
max_string_length [BatSys]
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.
measure [BatFingerTree.Generic]
measure m gives the measure of the whole tree, whose meaning depends on the measure chosen.
mem [BatVect.Make]
mem m a is true if and only if m is equal to an element of a.
mem [BatVect]
mem m a is true if and only if m is equal to an element of a.
mem [BatSet.PSet]
mem x s tests whether x belongs to the set s.
mem [BatSet.S]
mem x s tests whether x belongs to the set s.
mem [BatSet]
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 [BatMultiPMap]
mem x m returns true if m contains at least a binding for x, and false otherwise.
mem [BatMultiMap]
mem x m returns true if m contains at least a binding for x, and false otherwise.
mem [BatMap.PMap]
mem x m returns true if m contains 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 [BatMap]
mem x m returns true if m contains a binding for x, and false otherwise.
mem [BatList]
mem a l is true if and only if a is equal to an element of l.
mem [BatLazyList]
mem x l determines if x is part of l.
mem [BatInnerWeaktbl]
Weaktbl.mem tbl x checks if x is bound in tbl.
mem [BatISet]
test whether a given int is a member of the set
mem [BatIMap]
Test whether there is a binding from the given int
mem [BatHashtbl.Cap]
mem [BatHashtbl.S]
mem [BatHashtbl]
Hashtbl.mem tbl x checks if x is bound in tbl.
mem [BatBitSet]
mem s n returns true if nth-bit in the bitset s is set, or false otherwise.
mem [BatArray.Cap]
mem [BatArray]
mem m a is true if and only if m is equal to an element of a.
mem_assoc [BatList]
Same as List.assoc, but simply return true if a binding exists, and false if no bindings exist for the given key.
mem_assoc [BatLazyList]
As BatLazyList.assoc but simply returns true if a binding exists, false otherwise.
mem_assq [BatList]
Same as List.mem_assoc, but uses physical equality instead of structural equality to compare keys.
mem_assq [BatLazyList]
As BatLazyList.mem_assoc but with physical equality.
memq [BatVect.Make]
Same as Vect.mem but uses physical equality instead of structural equality to compare vect elements.
memq [BatVect]
Same as Vect.mem but uses physical equality instead of structural equality to compare vect elements.
memq [BatList]
Same as List.mem, but uses physical equality instead of structural equality to compare list elements.
memq [BatLazyList]
As mem, but with physical equality
memq [BatArray.Cap]
memq [BatArray]
Same as Array.mem but uses physical equality instead of structural equality to compare array elements.
merge [BatStream.StreamLabels]
merge [BatStream]
merge test (streama, streamb) merge the elements from streama and streamb into a single stream.
merge [BatMap.PMap]
merge f m1 m2 computes a map whose keys is a subset of keys of m1 and of m2.
merge [BatMap.S]
merge f m1 m2 computes a map whose keys is a subset of keys of m1 and of m2.
merge [BatMap]
merge f m1 m2 computes a map whose keys is a subset of keys of m1 and of m2.
merge [BatList.Labels]
merge [BatList]
Merge two lists: Assuming that l1 and l2 are sorted according to the comparison function cmp, merge cmp l1 l2 will return a sorted list containting all the elements of l1 and l2.
merge [BatIMap]
merge [BatHeap.H]
merge [BatHeap]
Merge two heaps.
merge [BatEnum]
merge test (a, b) merge the elements from a and b into a single enumeration.
merge_unsafe [BatMap.PMap]
Same as merge, but assumes the comparison function of both maps are equal.
mid [BatInt]
Midpoint function; mid a b returns floor((a+b)/2), but done correctly to compensate for numeric overflows.
min [BatSeq.Exceptionless]
min [BatSeq]
min s returns the smallest value in s as judged by Pervasives.compare
min [BatOrd]
min ord will choose the smallest element, according to ord.
min [BatList]
min l returns the smallest value in l as judged by Pervasives.compare
min [BatInt]
The minimum of two integers.
min [BatFloat]
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 [BatMap.PMap]
returns the binding with the smallest key
min_binding [BatMap.S]
return the (key,value) pair with the smallest key
min_binding [BatMap]
returns the binding with the smallest key
min_comp [BatOrd]
min_elt [BatSet.PSet]
returns the smallest element of the set.
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 [BatSet]
returns the smallest element of the set.
min_elt [BatISet]
Returns the minimum element in the set
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 smallest representable integer, -230 or 262.
min_num [BatInt]
The smallest representable integer, -230 or -262.
min_num [BatFloat.Safe_float]
min_num [BatFloat]
min_num [BatBool]
min_ord [BatOrd]
minor [BatGc]
Trigger a minor collection.
minus_big_int [BatBig_int]
Unary negation.
minus_num [BatNum]
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.
mkdir [BatUnix]
Create a directory with the given permissions.
mkfifo [BatUnix]
Create a named pipe with the given permissions.
mktime [BatUnix]
Convert a date and time, specified by the tm argument, into a time in seconds, as returned by Unix.time.
mod_big_int [BatBig_int]
Euclidean modulus of two big integers.
mod_num [BatNum]
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.Make]
modify v n f is equivalent to set v n (f (get v n)), but more efficient.
modify [BatVect]
modify v n f is equivalent to set v n (f (get v n)), but more efficient.
modify [BatMap.PMap]
modify k f m replaces the previous binding for k with f applied to that value.
modify [BatMap.S]
modify k f m replaces the previous binding for k with f applied to that value.
modify [BatMap]
modify k f m replaces the previous binding for k with f applied to that value.
modify [BatBigarray.Array3]
modify f a changes each element x in a to f x in-place.
modify [BatBigarray.Array2]
modify f a changes each element x in a to f x in-place.
modify [BatBigarray.Array1]
modify f a changes each element x in a to f x in-place.
modify [BatBigarray.Genarray]
modify f a changes each element x in a to f x in-place.
modify [BatArray.Cap.Labels]
modify [BatArray.Cap]
modify [BatArray.Labels]
modify [BatArray]
modify f a replaces every element x of a with f x.
modify_def [BatMap.PMap]
modify_def v0 k f m replaces the previous binding for k with f applied to that value.
modify_def [BatMap.S]
modify_def v0 k f m replaces the previous binding for k with f applied to that value.
modify_def [BatMap]
modify_def v0 k f m replaces the previous binding for k with f applied to that value.
modifyi [BatBigarray.Array1]
Same as Bigarray.Array1.modify, but the function is applied to the index of the element as the first argument, and the element itself as the second argument.
modifyi [BatBigarray.Genarray]
Same as BatBigarray.Genarray.modify, but the function is applied to the index of the coordinates as the first argument, and the element itself as the second argument.
modifyi [BatArray.Cap.Labels]
modifyi [BatArray.Cap]
modifyi [BatArray.Labels]
modifyi [BatArray]
Same as BatArray.modify, but the function is applied to the index of the element as the first argument, and the element itself as the second argument.
modifyij [BatBigarray.Array2]
Same as Bigarray.Array2.modify, but the function is applied to the index of the element as the first two arguments, and the element itself as the third argument.
modifyijk [BatBigarray.Array3]
Same as Bigarray.Array3.modify, but the function is applied to the index of the coordinates as the first three arguments, and the element itself as the fourth argument.
modulo [BatNumber.Numeric]
modulo [BatNum]
modulo [BatNativeint]
modulo [BatInt64]
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]
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]
mult_big_int [BatBig_int]
Multiplication of two big integers.
mult_int_big_int [BatBig_int]
Multiplication of a big integer by a small integer
mult_num [BatNum]
multi_choice [BatRandom]
multi_choice n e returns an enumeration of n randomly-chosen elements of e.
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_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.Internal]
nat_of_num [BatNum]
Coercions between numerical types
nativeint [BatRandom.Incubator.Private_state_enums.State]
nativeint [BatRandom.State]
nativeint [BatRandom]
Random.nativeint bound returns a random integer between 0 (inclusive) and bound (exclusive).
nativeint [BatBigarray]
See Bigarray.char.
nativeint_of_big_int [BatBig_int]
Convert a big integer to a native integer.
neg [BatPervasives]
neg p returns a new predicate that is the negation of the given predicate.
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 [BatInnerPervasives]
neg [BatFloat.Safe_float]
neg [BatFloat]
Returns the negation of the input, i.e.
neg [BatComplex]
Unary negation.
neg [BatBool]
neg [BatBig_int]
neg2 [BatPervasives]
as neg but for predicates with two arguments
neg2 [BatInnerPervasives]
neg_infinity [BatFloat.Safe_float]
Negative infinity.
neg_infinity [BatFloat]
Negative infinity.
nested_comments [BatGenlex.Languages.Definition]
new_line [BatLexing]
Update the lex_curr_p field of the lexbuf to reflect the start of a new line.
new_method [BatOo.Internal]
new_methods_variables [BatOo.Internal]
new_variable [BatOo.Internal]
newline [BatCharParser]
Recognizes a newline
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.
next_set_bit [BatBitSet]
next_set_bit s n returns Some m when m is the next set element with index greater than or equal n, or None if no such element exists (i.e.
nice [BatUnix]
Change the process priority.
nil [BatSeq]
nil = fun () -> Nil
nil [BatLazyList]
The empty list.
nolock [BatConcurrent]
A lock which does nothing.
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]
Deprecated name for normalize_in_tree
normalize_filepath [BatPathGen.PathType]
Consumes single dots where possible, e.g.:
normalize_in_graph [BatPathGen.PathType]
Another name for normalize_filepath.
normalize_in_tree [BatPathGen.PathType]
Consumes single dots and applies double dots where possible, e.g.:
not [BatBool]
The boolean negation.
not_char [BatCharParser]
Accept any value not a given char As none_of.
npeek [BatStream]
npeek n returns the list of the n first elements of the stream, or all its remaining elements if less than n elements are available.
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.
nreplace [BatString.Cap]
nreplace [BatString]
nreplace ~str ~sub ~by returns a string obtained by iteratively replacing each occurrence of sub by by in str, from right to left.
nsplit [BatText]
nsplit s sep splits the rope s into a list of ropes which are separated by sep.
nsplit [BatString.Cap]
nsplit [BatString]
nsplit s sep splits the string s into a list of strings which are separated by sep (excluded).
nth [BatUTF8]
nth s n returns the position of the n-th Unicode character.
nth [BatList]
Obsolete.
nth [BatLazyList]
Obsolete.
nth [BatBuffer]
get the n-th character of the buffer.
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_int [BatNum]
num_of_nat [BatNum]
num_of_ratio [BatNum]
num_of_string [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
ocaml_version [BatSys]
ocaml_version is the version of OCaml.
of_array [BatVect.Make]
of_array s returns a vect corresponding to the array s.
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.Make]
Build a vector from an enumeration, from last to first.
of_backwards [BatVect]
Build a vector from an enumeration, from last to first.
of_backwards [BatString.Cap]
of_backwards [BatString]
Build a string 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 [BatFingerTree.S]
of_backward e is equivalent to reverse (of_enum e).
of_backwards [BatArray.Cap]
of_backwards [BatArray]
Build an array from an enumeration, with the first element of the enumeration as the last element of the array and vice versa.
of_byte [BatInt32]
of_channel [BatStream]
Return the stream of the characters read from the input channel.
of_char [BatUChar]
of_char c returns the Unicode character of the Latin-1 character c
of_char [BatText]
of_char c returns a rope containing exactly Latin-1 character c.
of_char [BatString.Cap]
of_char [BatString]
Returns a string containing one given character.
of_container [BatVect.Make]
of_container s returns a vect corresponding to the container s.
of_digit [BatChar]
Return the character representing a given digit.
of_enum [BatVect.RANDOMACCESS]
of_enum [BatVect.Make]
Build a vector from an enumeration.
of_enum [BatVect]
Build a vector from an enumeration.
of_enum [BatTuple.Tuple5]
of_enum [BatTuple.Tuple4]
of_enum [BatTuple.Tuple3]
of_enum [BatTuple.Tuple2]
of_enum [BatString.Cap]
of_enum [BatString]
Creates a string from a character enumeration.
of_enum [BatStream]
Convert an enumeration to a stream.
of_enum [BatStack]
of_enum e returns a new stack containing all the elements of e.
of_enum [BatSet.PSet]
of_enum [BatSet.S]
of_enum [BatSet]
of_enum [BatRefList]
Creates a ref list from an enumeration
of_enum [BatQueue]
of_enum e returns a new queue containing all the elements of e.
of_enum [BatParserCo.Source]
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 [BatMultiMap]
creates a map from an enumeration, using the specified function for key comparison or compare by default.
of_enum [BatMap.PMap]
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 [BatMap]
Creates a map from an enumeration
of_enum [BatList]
Build a list from an enumeration.
of_enum [BatLazyList]
Lazy conversion from enum.
of_enum [BatISet]
of_enum [BatHeap.H]
of_enum [BatHeap]
Build a heap from an enumeration.
of_enum [BatHashtbl.Cap]
of_enum [BatHashtbl.S]
of_enum [BatHashtbl]
Create a hashtable from a (key,value) enumeration.
of_enum [BatFingerTree.S]
of_enum e build the sequence containing the elements of e in the same order.
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 [BatDeque]
of_enum e is a deque representation of the elements of e.
of_enum [BatBuffer]
Creates a buffer from a character enumeration.
of_enum [BatBitSet]
of_enum ~cap e builds a bitset of capacity cap an enumeration of ints e.
of_enum [BatArray.Cap]
of_enum [BatArray]
Build an array from an enumeration.
of_enum_cmp [BatSet.PSet]
of_float [BatString.Cap]
of_float [BatString]
Returns the string representation of an 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, 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 [BatComplex]
Complex.of_float x returns the complex number x+0i
of_float [BatBool]
0., nan +infinity and -infiity are false.
of_float [BatBig_int]
rounds to the nearest integer
of_fun [BatStream]
Stream.of_fun f returns a stream built from the function f.
of_input [BatSubstring]
of_input [BatStream]
Convert an input to a stream.
of_int [BatUChar]
Alias of chr
of_int [BatString.Cap]
of_int [BatString]
Returns the string 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]
anything but 0 is true
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_int64 [BatNativeint]
Convert the given 64-bit integer (type int64) to a native integer.
of_int64 [BatInt32]
Convert the given 64-bit integer (type int64) to a 32-bit integer (type int32).
of_latin1 [BatText]
Constructs a unicode rope from a latin-1 string.
of_list [BatVect.Make]
of_list [BatVect]
of_list [BatString.Cap]
of_list [BatString]
Converts a list of characters to a string.
of_list [BatStream]
Return the stream holding the elements of the list in the same order.
of_list [BatSplay.Map]
of_list [BatSet.PSet]
builds a set from the given list, using the default comparison function
of_list [BatSet]
builds a set from the given list, using the default comparison function
of_list [BatRefList]
Creates a ref list from a list - O(1)
of_list [BatLazyList]
Lazy conversion from lists
of_list [BatISet]
Build a ISet.t out of a list or enum of ranges
of_list [BatHeap.H]
of_list [BatHeap]
Build a heap from a given list.
of_list [BatGenlex]
Create a lexer from a list of keywords
of_list [BatFingerTree.S]
of_list l is equivalent to of_enum (BatList.enum l).
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 [BatDeque]
of_list l is a deque representation of the elements of l.
of_list [BatBitSet]
As of_enum, but from a list
of_list [BatArray.Cap]
of_list [BatArray]
Array.of_list l returns a fresh array containing the elements of l.
of_list_backwards [BatFingerTree.S]
of_list_backwards l is equivalent to of_enum_backwards (BatList.enum l).
of_nativeint [BatInt64]
Convert the given native integer (type nativeint) to a 64-bit integer (type int64).
of_nativeint [BatInt32]
Convert the given native integer (type nativeint) to a 32-bit integer (type int32).
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 [BatText]
of_string s returns a rope corresponding to the UTF-8 encoded string s.
of_string [BatSubstring]
of_string [BatString.Cap]
Adopt a regular string.
of_string [BatStream]
Return the stream of the characters of the string parameter.
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 s accepts strings with the following formats:
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 [BatText]
of_uchar c returns a rope containing exactly character c.
oget_exn [BatRef]
Get a value from an option ref;
ok [BatPervasives]
f x |> ok unwraps the Ok result of f x and returns it, or throws the exception contained if Bad is returned.
ok [BatInnerPervasives]
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_box [BatFormat]
open_box d opens a new pretty-printing box with offset d.
open_connection [BatUnix]
Connect to a server at the given address.
open_hbox [BatFormat]
open_hbox () opens a new pretty-printing box.
open_hovbox [BatFormat]
open_hovbox d opens a new pretty-printing box with offset d.
open_hvbox [BatFormat]
open_hvbox d opens a new pretty-printing box with offset d.
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_tag [BatFormat]
open_tag t opens the tag named t; the print_open_tag function of the formatter is called with t as argument; the tag marker mark_open_tag t will be flushed into the output device of the formatter.
open_tbox [BatFormat]
Opens a tabulation box.
open_temporary_out [BatFile]
open_temporary_out () opens a new temporary file for writing.
open_vbox [BatFormat]
open_vbox d opens a new pretty-printing box with offset d.
opendir [BatUnix]
Open a descriptor on a directory
openfile [BatUnix]
Open the named file with the given flags.
operations [BatNumber.Numeric]
operations [BatNum]
operations [BatNativeint]
operations [BatInt64]
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_of_ord [BatBounded]
opt_of_ord ~bounds:(low, high) ord will returning a bounding function using ord for value comparison and None for values which fall outside of the requested range.
or_big_int [BatBig_int]
Bitwise logical ``or''.
ord [BatVect]
ord [BatUnit]
Always returns BatOrd.Eq
ord [BatTuple.Tuple5]
ord [BatTuple.Tuple4]
ord [BatTuple.Tuple3]
ord [BatTuple.Tuple2]
ord [BatString]
Ordering function for strings, see BatOrd
ord [BatRef]
ord [BatOrd]
Returns a variant ordering from a legacy comparison
ord [BatNumber.Numeric]
ord [BatNum]
ord [BatNativeint]
ord [BatList]
ord [BatInt64]
ord [BatInt32]
ord [BatInt.Safe_int]
ord [BatInt]
ord [BatISet]
Same as compare but returns BatOrd.Lt | BatOrd.Eq | BatOrd.Gt instead of an int.
ord [BatFloat]
ord [BatEnum]
Same as compare but returning a BatOrd.order instead of an interger.
ord [BatComplex]
ord [BatOrd.Ord]
ord [BatChar]
ord [BatBool]
ord [BatBitSet]
ord s1 s2 returns BatOrd.Lt, BatOrd.Eq or BatOrd.Gt if compare s1 s2 is, respectively, < 0, 0 or > 0.
ord [BatBig_int]
ord [BatArray.Incubator.Ord]
ord [BatArray.Cap]
ord [BatArray]
Hoist an element comparison function to compare arrays of those elements, with shorter arrays less than longer ones, and lexicographically for arrays of the same size.
ord0 [BatOrd]
ord_by [BatOrd.Incubator]
Build a eq, cmp or ord function from a projection function.
os_type [BatSys]
Operating system currently executing the OCaml program.
oset [BatRef]
Set the given option ref to Some x
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 [BatLog.Config]
out_channel_of_descr [BatUnix]
Create an output channel writing on the given descriptor.
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 [BatLog.Make_lev]
output [BatLog.Easy]
output [BatLog]
This ref holds the output channel for simple logging.
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_float [BatPervasives]
Write one float in binary format (8 bytes, IEEE 754 double format) on the given output channel.
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 [BatBuffer]
output_buffer b creates an output channel that writes to that buffer, and when closed, returns the contents of the buffer.
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 [BatPervasives]
creates a filename, write text into it and close it.
output_of_descr [BatUnix]
Create an output writing on the given descriptor.
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_text [BatText]
Write the text on the given output channel.
output_value [BatPervasives]
Write the representation of a structured value of any type to a channel.
over_max_boxes [BatFormat]
Tests if the maximum number of boxes allowed have already been opened.

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.Internal]
parent [BatPathGen.PathType]
Returns parent path, i.e.
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 v returns a pair of vects (v1, v2), where v1 is the vect of all the elements of v that satisfy the predicate p, and v2 is the vect of all the elements of v that do not satisfy p.
partition [BatVect]
partition p v returns a pair of vects (v1, v2), where v1 is the vect of all the elements of v that satisfy the predicate p, and v2 is the vect of all the elements of v that do not satisfy p.
partition [BatSet.PSet]
returns two disjoint subsets, those that satisfy the given predicate and those that don't
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 [BatSet]
returns two disjoint subsets, those that satisfy the given predicate and those that don't
partition [BatMap.PMap]
partition p m returns a pair of maps (m1, m2), where m1 contains all the bindings of s that satisfy the predicate p, and m2 is the map with all the bindings of s that do not satisfy p.
partition [BatMap.S]
partition p m returns a pair of maps (m1, m2), where m1 contains all the bindings of s that satisfy the predicate p, and m2 is the map with all the bindings of s that do not satisfy p.
partition [BatMap]
partition p m returns a pair of maps (m1, m2), where m1 contains all the bindings of s that satisfy the predicate p, and m2 is the map with all the bindings of s that do not satisfy p.
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]
partitions the input set into two sets with elements that satisfy the predicate and those that don't
partition [BatEnum]
as switch
partition [BatArray.Cap]
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.
pause [BatUnix]
Wait until a non-ignored, non-blocked signal is delivered.
peek [BatStream]
Return Some of "the first element" of the stream, or None if the stream is empty.
peek [BatQueue.Exceptionless]
peek [BatQueue]
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
perturb [BatRandom.Incubator.Private_state_enums.State]
perturb s returns a new state based on the given state that is, in a sense, the hash of the input state.
pi [BatFloat.Safe_float]
The constant pi (3.14159...)
pi [BatFloat]
The constant pi (3.14159...)
pi2 [BatFloat]
pi /. 2.
pi4 [BatFloat]
pi /. 4.
pipe [BatUnix]
Create a pipe.
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.
poly [BatOrd]
Polymorphic comparison functions, based on the Pervasives.compare function from inria's stdlib, have polymorphic types: they claim to be able to compare values of any type.
poly_comp [BatOrd]
poly_ord [BatOrd]
pop [BatVect.Make]
Return the last element of a vector and its first n-1 elements.
pop [BatVect]
Return the last element of a vector and its first n-1 elements.
pop [BatStack.Exceptionless]
pop [BatStack]
pop s removes and returns the topmost element in stack s, or
pop [BatSet.PSet]
returns one element of the set and the set without that element.
pop [BatSet.S]
returns one element of the set and the set without that element.
pop [BatSet]
returns one element of the set and the set without that element.
pop [BatRefList]
Removes and returns the first element or raises Empty_list if the ref list is empty
pop [BatQueue]
pop is a synonym for take.
pop [BatMap.PMap]
pop m returns a binding from m and m without that binding.
pop [BatMap.S]
pop m returns a binding from m and m without that binding.
pop [BatMap]
pop m returns a binding from m and m without that binding.
popcount [BatInt]
Returns the number of 1 bits set in the binary representation of the number.
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]
Pass the (successful) result of some parser through a map.
pow [BatNumber.Numeric]
pow [BatNum]
pow [BatNativeint]
pow [BatInt64]
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]
power_num [BatNum]
pp_close_box [BatFormat]
pp_close_tag [BatFormat]
pp_close_tbox [BatFormat]
pp_force_newline [BatFormat]
pp_get_all_formatter_output_functions [BatFormat]
pp_get_ellipsis_text [BatFormat]
pp_get_formatter_output_functions [BatFormat]
pp_get_formatter_tag_functions [BatFormat]
These functions are the basic ones: usual functions operating on the standard formatter are defined via partial evaluation of these primitives.
pp_get_margin [BatFormat]
pp_get_mark_tags [BatFormat]
pp_get_max_boxes [BatFormat]
pp_get_max_indent [BatFormat]
pp_get_print_tags [BatFormat]
pp_open_box [BatFormat]
pp_open_hbox [BatFormat]
pp_open_hovbox [BatFormat]
pp_open_hvbox [BatFormat]
pp_open_tag [BatFormat]
pp_open_tbox [BatFormat]
pp_open_vbox [BatFormat]
pp_over_max_boxes [BatFormat]
pp_print_as [BatFormat]
pp_print_bool [BatFormat]
pp_print_break [BatFormat]
pp_print_char [BatFormat]
pp_print_cut [BatFormat]
pp_print_float [BatFormat]
pp_print_flush [BatFormat]
pp_print_if_newline [BatFormat]
pp_print_int [BatFormat]
pp_print_newline [BatFormat]
pp_print_space [BatFormat]
pp_print_string [BatFormat]
pp_print_tab [BatFormat]
pp_print_tbreak [BatFormat]
pp_set_all_formatter_output_functions [BatFormat]
pp_set_ellipsis_text [BatFormat]
pp_set_formatter_out_channel [BatFormat]
pp_set_formatter_output [BatFormat]
pp_set_formatter_output_functions [BatFormat]
pp_set_formatter_tag_functions [BatFormat]
pp_set_margin [BatFormat]
pp_set_mark_tags [BatFormat]
pp_set_max_boxes [BatFormat]
pp_set_max_indent [BatFormat]
pp_set_print_tags [BatFormat]
pp_set_tab [BatFormat]
pp_set_tags [BatFormat]
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 [BatNumber.Numeric]
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]
pred_big_int [BatBig_int]
Predecessor (subtract 1).
pred_num [BatNum]
prefix [BatLog.Config]
prefix [BatLog]
This ref holds the text printed before each log message.
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 [BatText]
prepend_char c r returns a new rope with the c character at the beginning in amortized O(1) time.
prepend_list [BatDeque]
prepent_list l dq is equivalent to append (of_list l) dq, but more efficient.
prerr_all [BatPervasives]
Print the contents of an input to the error output.
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]
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]
print [BatVect]
print [BatUref]
Print the uref.
print [BatUnit]
Printing
print [BatTuple.Tuple5]
print [BatTuple.Tuple4]
print [BatTuple.Tuple3]
print [BatTuple.Tuple2]
print [BatText]
Prints a rope to the given out_channel
print [BatSubstring]
print oc ss prints ss to the output channel oc
print [BatString.Cap]
print [BatString]
Print a string.
print [BatStack]
print [BatSet.PSet]
print [BatSet.S]
print [BatSet]
print [BatSeq]
Print the contents of a sequence
print [BatResult]
Print a result as Ok(x) or Bad(exn)
print [BatRef]
print [BatQueue]
print [BatPrintexc]
Print an exception.
print [BatPervasives]
Print and consume the contents of an enumeration.
print [BatOption]
print [BatNum]
Printing
print [BatNativeint]
print [BatMultiPMap]
print [BatMultiMap]
print [BatMap.PMap]
print [BatMap.S]
print [BatMap]
print [BatList]
Print the contents of a list
print [BatLazyList]
print [BatInt64]
Printing
print [BatInt.Safe_int]
print [BatInt]
prints as decimal string
print [BatISet]
print [BatHeap.H]
print [BatHeap]
Print the contents of the heap in heap order.
print [BatHashtbl.Cap]
print [BatHashtbl.S]
print [BatHashtbl]
print [BatFloat.Safe_float]
Printing
print [BatFloat]
Printing
print [BatFingerTree.S]
print [BatEnum]
Print and consume the contents of an enumeration.
print [BatDynArray]
print [BatDllist]
print [BatDigest]
Write a digest on the given output in hexadecimal.
print [BatDeque]
Print the contents of the deque.
print [BatComplex]
Printing
print [BatChar]
print [BatBuffer]
print [BatBool]
Printing
print [BatBitSet]
print [BatBig_int]
print [BatArray.Cap]
print [BatArray]
Print the contents of an array, with ~first preceeding the first item (default: "|"), [~last] following the last item (default: "|") and ~sep separating items (default: "; ").
print_all [BatPervasives]
Print the contents of an input to the standard output.
print_any [BatPervasives]
Attempt to print a value to an output.
print_as [BatFormat]
print_as len str prints str in the current box.
print_as_list [BatSplay.Map]
print_backtrace [BatPrintexc]
print_backtrace oc Prints the an exception backtrace on the output channel oc.
print_bool [BatPervasives]
Print a boolean on standard output.
print_bool [BatFormat]
Prints a boolean in the current box.
print_break [BatFormat]
Inserts a break hint in a pretty-printing box.
print_char [BatFormat]
Prints a character in the current box.
print_cut [BatFormat]
print_cut () is used to mark a good break position.
print_float [BatFormat]
Prints a floating point number in the current box.
print_flush [BatFormat]
Flushes the pretty printer: all opened boxes are closed, and all pending text is displayed.
print_guess [BatPervasives]
Attempt to print the representation of a runtime value on the standard output.
print_hex [BatInt64]
prints as hex string
print_hex [BatInt]
prints as hex string
print_if_newline [BatFormat]
Executes the next formatting command if the preceding line has just been split.
print_int [BatFormat]
Prints an integer in the current box.
print_newline [BatFormat]
Equivalent to print_flush followed by a new line.
print_quoted [BatString.Cap]
print_quoted [BatString]
Print a string, with quotes as added by the quote function.
print_rope [BatteriesPrint]
print_space [BatFormat]
print_space () is used to separate items (typically to print a space between two words).
print_stat [BatGc]
Print the current values of the memory management counters (in human-readable form) into the channel argument.
print_string [BatFormat]
print_string str prints str in the current box.
print_string_cap_ro [BatteriesPrint]
print_string_cap_rw [BatteriesPrint]
print_tab [BatFormat]
print_tab () is equivalent to print_tbreak 0 0.
print_tbreak [BatFormat]
Break hint in a tabulation box.
print_uchar [BatteriesPrint]
print_ustring [BatteriesPrint]
printf [BatPrintf]
The usual printf function, prints to the standard output stdout, i.e.
printf [BatFormat]
Same as fprintf above, but output on std_formatter.
println [BatString.Cap]
println [BatString]
Print a string, end the line.
printn [BatTuple.Tuple5]
printn [BatTuple.Tuple4]
printn [BatTuple.Tuple3]
printn [BatTuple.Tuple2]
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.Internal]
push [BatStack]
push x s adds the element x at the top of stack s.
push [BatRefList]
Adds an element at the head - O(1)
push [BatQueue]
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.
putenv [BatUnix]
Unix.putenv name value sets the value associated to a variable in the process environment.

Q
quick_stat [BatGc]
Same as stat except that live_words, live_blocks, free_words, free_blocks, largest_free, and fragments are set to 0.
quo [BatNum]
Additional operations
quo_num [BatNum]
quomod_big_int [BatBig_int]
Euclidean division of two big integers.
quote [BatString.Cap]
quote [BatString]
Add quotes around a string and escape any quote or escape appearing in that string.

R
range [BatParserCo]
Accept any element from a given range.
range [BatLazyList]
Compute lazily a range of integers a ..
range [BatEnum]
range p until:q creates an enumeration of integers [p, p+1, ..., q].
range [BatChar]
range from ?until produces an enumeration of the characters from from to until included until defaults to '\255'
range [BatArray]
range a returns an enumeration of all valid indexes into the given array.
range_iter [BatText]
rangeiter f m n r applies f to all the characters whose indices k satisfy m <= k < m + n.
range_iteri [BatText]
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]
Returns a list of all contiguous ranges in the set
ratio_of_num [BatNum]
rchop [BatText]
Returns the same rope but without the last character.
rchop [BatString.Cap]
rchop [BatString]
Returns the same string but without the last n characters.
rcontains_from [BatText]
rcontains_from s stop c tests if character c appears in the subrope of s starting from the beginning of s to index stop.
rcontains_from [BatString.Cap]
rcontains_from [BatString]
String.rcontains_from s stop c tests if character c appears in s before position stop+1.
read [BatUnix]
read fd buff ofs len reads len characters from descriptor fd, storing them in string buff, starting at position ofs in string buff.
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 [BatText]
Read the whole contents of a UTF-8 encoded input
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_char [BatText]
Read one Unicode char from a UTF-8 encoded input
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 [BatText]
Read a line of UTF-8
read_line [BatInnerIO]
Read a LF or CRLF terminated string.
read_line [BatIO]
Read a LF or CRLF terminated string.
read_only [BatString.Cap]
Drop capabilities to read only.
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_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_text [BatText]
Read up to n chars 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.
readdir [BatUnix]
Return the next entry in a directory.
readdir [BatSys]
Return the names of all files present in the given directory.
readlink [BatUnix]
Read the contents of a link.
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.
rear [BatFingerTree.S]
rear t returns None when t is empty, or Some (init, last) where last is the last element of the sequence and init is the rest of the sequence.
rear [BatDeque]
rear dq returns Some (dq', x) iff x is at the rear of dq and dq' is the rest of dq excluding x, and None if dq has no elements.
rear_exn [BatFingerTree.S]
rear t returns (init, last) when last is the last element of the sequence and init is the rest of the sequence.
record_backtrace [BatPrintexc]
Printexc.record_backtrace b turns recording of exception backtraces on (if b = true) or off (if b = false).
recv [BatUnix]
Receive data from a connected socket.
recvfrom [BatUnix]
Receive data from an unconnected socket.
reduce [BatVect.Make]
as fold_left, but no initial value - just applies reducing function to elements from left to right.
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); ..; a.(n-1)|].
ref [BatRef]
Return a fresh reference containing the given value.
register_formatter [BatLogger]
register_formatter name formatter registers a named log formatter.
register_printer [BatPrintexc]
Printexc.register_printer fn registers fn as an exception printer.
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 [BatText]
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 [BatSys]
Remove the given file name from the file system.
remove [BatSet.PSet]
remove x s returns a set containing all elements of s, except x.
remove [BatSet.S]
remove x s returns a set containing all elements of s, except x.
remove [BatSet]
remove x s returns a set containing all elements of s, except x.
remove [BatRefList]
Remove an element from the ref list raise Not_found if the element is not found
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 [BatMultiMap]
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.PMap]
remove x m returns a map containing the same bindings as m, except for x which is unbound 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 [BatMap]
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 an element from the given set, returning a new set
remove [BatIMap]
Remove any bindings from the given value.
remove [BatHashtbl.Cap]
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 [BatBitSet]
remove n s returns a copy of s with bit n false.
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 [BatMultiMap]
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 [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 lo hi t removes a range of elements from the given set, returning a new set
remove_range [BatIMap]
Remove any bindings within the given range
rename [BatUnix]
rename old new changes the name of a file from old to new.
rename [BatSys]
Rename a file.
repeat [BatString.Cap]
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 [BatText]
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 [BatString.Cap]
replace [BatString]
replace ~str ~sub ~by returns a tuple consisting of a boolean and a string where the first occurrence of the string sub within str has been replaced by the string 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]
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.Cap]
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.
reserved_names [BatGenlex.Languages.Definition]
reset [BatUTF8.Buf]
Empty the buffer and de-allocate the internal storage.
reset [BatBuffer]
Empty the buffer and deallocate the internal string holding the buffer contents, replacing it with the initial internal string of length n that was allocated by Buffer.create n.
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.
restart_on_EINTR [BatUnix]
restart_on_EINTR f x invokes f on x repetedly until the function returns a value or raises another exception than EINTR.
return [BatReturn]
Return to a label.
return [BatResult.Monad]
Monadic return, just encapsulates the given value with Ok
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 [BatInterfaces.Monad]
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 [BatOrd]
Reverse a given ordering.
rev [BatList]
List reversal.
rev [BatLazyList]
Eager list reversal.
rev [BatDllist]
List reversal.
rev [BatDeque]
rev dq reverses dq.
rev [BatArray.Cap]
rev [BatArray]
Array reversal.
rev_append [BatList]
List.rev_append l1 l2 reverses l1 and concatenates it to l2.
rev_append [BatLazyList]
Eager reverse-and-append
rev_comp [BatOrd]
rev_comp0 [BatOrd]
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]
rev_in_place [BatArray]
In-place array reversal.
rev_map [BatList.Labels]
rev_map [BatList]
List.rev_map f l gives the same result as List.rev (List.map f l).
rev_map2 [BatList.Labels]
rev_map2 [BatList]
List.rev_map2 f l1 l2 gives the same result as List.rev (List.map2 f l1 l2), but is tail-recursive and more efficient.
rev_ord [BatOrd]
rev_ord0 [BatOrd]
reverse [BatFingerTree.S]
reverse t is equivalent to of_list (List.rev (to_list t)).
rewinddir [BatUnix]
Reposition the descriptor to the beginning of the directory
rfind [BatText]
rfind s x returns the starting index of the last occurrence of rope x within rope s.
rfind [BatString.Cap.Exceptionless]
rfind [BatString.Cap]
rfind [BatString.Exceptionless]
rfind s x returns Some i, the starting index of the last occurrence of string x within string s, or None if x is not a substring of s.
rfind [BatString]
rfind s x returns the starting index of the last occurrence of string x within string 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
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.
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 [BatText]
rfind_from s ofs x behaves as rfind s x but starts searching at offset ofs.
rfind_from [BatString.Cap.Exceptionless]
rfind_from [BatString.Cap]
rfind_from [BatString.Exceptionless]
rfind_from s ofs x behaves as rfind s x but starts searching at offset ofs.
rfind_from [BatString]
rfind_from s pos x behaves as rfind s x but starts searching from the right at position pos + 1.
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.
right [BatText]
left r len returns the rope containing the len last characters of r
right [BatString.Cap]
right [BatString]
left r len returns the string containing the len last characters of r.
right [BatArray]
left r len returns the array containing the len last characters of r.
right_branch [BatAvlTree]
rindex [BatText]
Rope.rindex s c returns the position of the rightmost occurrence of character c in rope s.
rindex [BatSubstring]
rindex sus c returns the index of the last occurence of c in sus or
rindex [BatString.Cap.Exceptionless]
rindex [BatString.Cap]
rindex [BatString.Exceptionless]
rindex s c returns Some p, the position of the rightmost occurrence of character c in string s or None if c does not occur in s.
rindex [BatString]
String.rindex s c returns the character number of the last occurrence of character c in string s.
rindex [BatPathGen.StringType]
rindex_from [BatText]
Same as BatText.rindex, but start searching at the character position given as second argument.
rindex_from [BatSubstring]
index_from sus i c returns the index of the last occurence of c in sus before the index i or
rindex_from [BatString.Cap.Exceptionless]
rindex_from [BatString.Cap]
rindex_from [BatString.Exceptionless]
Same as String.Exceptionless.rindex, but start searching at the character position given as second argument.
rindex_from [BatString]
String.rindex_from s i c returns the character number of the last occurrence of character c in string s before position i+1.
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
rmdir [BatUnix]
Remove an empty directory.
root [BatPathGen.PathType]
Root of the filesystem ([""]).
root [BatFloat]
root x n calculates the nth root of x.
root [BatAvlTree]
rope_enum [BatteriesPrint]
rope_pset [BatteriesPrint]
round [BatNum]
round [BatFloat]
round x rounds x to the nearest integral floating-point (the nearest of floor x and ceil x).
round_num [BatNum]
round_to_int [BatFloat]
round_to_int x is int_of_float (round x).
round_to_string [BatFloat]
round_to_string ~digits:d x will return a string representation of x -- in base 10 -- rounded to d digits after the decimal point.
rsplit [BatText]
rsplit s sep splits the rope s between the last occurrence of sep.
rsplit [BatString.Cap.Exceptionless]
rsplit [BatString.Cap]
rsplit [BatString.Exceptionless]
rsplit s sep splits the string s between the last occurrence of sep, or returns None if the separator is not found.
rsplit [BatString]
rsplit s sep splits the string s between the last occurrence of sep, and returns the two parts before and after the occurence (excluded).
run [BatParserCo]
run p s executes parser p on source s.
run_initializers [BatOo.Internal]
run_initializers_opt [BatOo.Internal]

S
s [BatPathGen.PathType]
sat [BatParserCo]
satisfy p accepts one value p x such that p x = true
satisfy [BatParserCo]
satisfy p accepts one value p x such that p x = true
saturate_of_ord [BatBounded]
saturate_of_ord ~bounds:(low, high) ord will returning a bounding function using ord for value comparison and low and high for values which fall outside of the requested range.
scan [BatStream.StreamLabels]
scan [BatStream]
scan is similar to scanl but without the init value: scanl f init [< 'e0; 'e1; 'e2; ... >] is equivalent to [< 'e0; '(f e0 e1); '(f (f e0 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 x0, x1, x2 ..., scan f e is the enumeration containing x0, f x0 x1, f (f x0 x1) x2...
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 [BatStream]
scanl f init stream returns a stream of successive reduced values from the left: scanl f init [< 'e0; 'e1; ... >] is equivalent to [< 'init; '(f init e0); '(f (f init e0) e1); ... >]
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.
second [BatTuple.Tuple5]
second [BatTuple.Tuple4]
second [BatTuple.Tuple3]
second [BatTuple.Tuple2]
Equivalent to Pervasives.snd.
select [BatUnix]
Wait until some input/output operations become possible on some channels.
self_init [BatRandom]
Initialize the generator with a more-or-less random seed chosen in a system-dependent way.
send [BatUnix]
Send data over a connected socket.
send [BatOo.Internal]
sendcache [BatOo.Internal]
sendself [BatOo.Internal]
sendto [BatUnix]
Send data over an unconnected socket.
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 BatEnum.t m.
set [BatVect.RANDOMACCESS]
set [BatVect.Make]
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 [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 [BatText]
set r n c returns a copy of rope r where the (n+1)th character has been set to c.
set [BatString.Cap]
set [BatString]
String.set s n c modifies string s in place, replacing the character number n by 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 [BatGc]
set r changes the GC parameters according to the control record r.
set [BatFingerTree]
set t i v returns t where the i-th element is now v.
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]
set [BatArray]
Array.set a n x modifies array a in place, replacing element number n with x.
set_all_formatter_output_functions [BatFormat]
set_all_formatter_output_functions out flush outnewline outspace redirects the pretty-printer output to the functions out and flush as described in set_formatter_output_functions.
set_browser [BatteriesConfig]
set_close_on_exec [BatUnix]
Set the ``close-on-exec'' flag on the given descriptor.
set_ellipsis_text [BatFormat]
Set the text of the ellipsis printed when too many boxes are opened (a single dot, ., by default).
set_formatter_out_channel [BatFormat]
Redirect the pretty-printer output to the given channel.
set_formatter_output [BatFormat]
Sets the output of the formatter to the given argument
set_formatter_output_functions [BatFormat]
set_formatter_output_functions out flush redirects the relevant pretty-printer output functions to the functions out and flush.
set_formatter_tag_functions [BatFormat]
set_full_state [BatParserCo.Source]
set_margin [BatFormat]
set_margin d sets the value of the right margin to d (in characters): this value is used to detect line overflows that leads to split lines.
set_mark_tags [BatFormat]
set_print_tags b turns on or off the printing of tags, while set_mark_tags b turns on or off the output of tag markers.
set_max_boxes [BatFormat]
set_max_boxes max sets the maximum number of boxes simultaneously opened.
set_max_indent [BatFormat]
set_max_indent d sets the value of the maximum indentation limit to d (in characters): once this limit is reached, boxes are rejected to the left, if they do not fit on the current line.
set_method [BatOo.Internal]
set_methods [BatOo.Internal]
set_nonblock [BatUnix]
Set the ``non-blocking'' flag on the given descriptor.
set_permissions [BatFile]
Set the permissions on a file.
set_print_tags [BatFormat]
set_resizer [BatDynArray]
Change the resizer for this array.
set_signal [BatSys]
Same as Sys.signal but return value is ignored.
set_state [BatRandom]
Set the state of the generator used by the basic functions.
set_tab [BatFormat]
Sets a tabulation mark at the current insertion point.
set_tags [BatFormat]
set_tags b turns on or off the treatment of tags (default is off).
set_to_map [BatIMap]
set_to_map s x returns a map where every element of s is bound to x.
setgid [BatUnix]
Set the real group id and effective group id for the process.
setgroups [BatUnix]
setgroups groups sets the supplementary group IDs for the calling process.
setitimer [BatUnix]
setitimer t s sets the interval timer t and returns its previous status.
setsid [BatUnix]
Put the calling process in a new session and detach it from its controlling terminal.
setsockopt [BatUnix]
Set or clear a boolean-valued option in the given socket.
setsockopt_float [BatUnix]
Same as Unix.setsockopt for a socket option whose value is a floating-point number.
setsockopt_int [BatUnix]
Same as Unix.setsockopt for an integer-valued socket option.
setsockopt_optint [BatUnix]
Same as Unix.setsockopt for a socket option whose value is an int option.
setuid [BatUnix]
Set the real user id and effective user id for the process.
shift [BatVect.Make]
Return the first element of a vector and its last n-1 elements.
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_left_big_int [BatBig_int]
shift_left_big_int b n returns b shifted left by n 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_big_int [BatBig_int]
shift_right_big_int b n returns b shifted right by n 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.
shift_right_towards_zero_big_int [BatBig_int]
shift_right_towards_zero_big_int b n returns b shifted right by n 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 [BatUnix]
Shutdown a socket connection.
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.
sigabrt [BatSys]
Abnormal termination
sigalrm [BatSys]
Timeout
sigchld [BatSys]
Child process terminated
sigcont [BatSys]
Continue
sigfpe [BatSys]
Arithmetic exception
sighup [BatSys]
Hangup on controlling terminal
sigill [BatSys]
Invalid hardware instruction
sigint [BatSys]
Interactive interrupt (ctrl-C)
sigkill [BatSys]
Termination (cannot be ignored)
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.
sign_num [BatNum]
signal [BatSys]
Set the behavior of the system on receipt of a given signal.
signbit [BatFloat]
signed_bytes_of [BatIO]
Read an enumeration of signed 8-bit integers.
sigpending [BatUnix]
Return the set of blocked signals that are currently pending.
sigpipe [BatSys]
Broken pipe
sigprocmask [BatUnix]
sigprocmask cmd sigs changes the set of blocked signals.
sigprof [BatSys]
Profiling interrupt
sigquit [BatSys]
Interactive termination
sigsegv [BatSys]
Invalid memory reference
sigstop [BatSys]
Stop
sigsuspend [BatUnix]
sigsuspend sigs atomically sets the blocked signals to sigs and waits for a non-ignored, non-blocked signal to be delivered.
sigterm [BatSys]
Termination
sigtstp [BatSys]
Interactive stop
sigttin [BatSys]
Terminal read from background process
sigttou [BatSys]
Terminal write from background process
sigusr1 [BatSys]
Application-defined signal 1
sigusr2 [BatSys]
Application-defined signal 2
sigvtalrm [BatSys]
Timeout in virtual time
sin [BatFloat.Safe_float]
sin [BatFloat]
single_write [BatUnix]
Same as write, but attempts to write only once.
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.PSet]
Creates a new set with the single given element in it.
singleton [BatSet.S]
singleton x returns the one-element set containing only x.
singleton [BatSet]
Creates a new set with the single given element in it.
singleton [BatMap.PMap]
creates a new map with a single binding
singleton [BatMap.S]
singleton x y returns the one-element map that contains a binding y for x.
singleton [BatMap]
creates a new map with a single binding
singleton [BatISet]
Return the singleton set containing only the given element
singleton [BatIMap]
singleton [BatFingerTree.S]
singleton elt build the sequence containing elt as its sole element.
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 [BatHeap.H]
size [BatHeap]
Number of elements in the heap.
size [BatFingerTree.S]
size t returns the number of elements in the sequence.
size [BatFingerTree]
size t returns the number of elements in the sequence.
size [BatDeque]
size dq is the number of elements in the dq.
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.
sleep [BatUnix]
Stop execution for the given number of seconds.
slice [BatText]
slice ?first ?last s returns a "slice" of the rope which corresponds to the characters s.[first], s.[first+1], ..., s[last-1].
slice [BatSubstring]
slice sus i' None returns the substring (s, i+i', n-i'), where sus = (s, i, n).
slice [BatString.Cap]
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_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.
snoc [BatFingerTree.S]
snoc t elt adds elt to the right of t.
snoc [BatDeque]
snoc x dq adds x to the rear of dq.
socket [BatUnix]
Create a new socket in the given domain, and with the given kind.
socketpair [BatUnix]
Create a pair of unnamed sockets, connected together.
sort [BatRefList]
Sort elements using the specified comparator
sort [BatList]
Sort a list in increasing order according to a comparison function.
sort [BatLazyList]
Sort the list using optional comparator (by default compare).
sort [BatArray.Cap.Labels]
sort [BatArray.Cap]
sort [BatArray.Labels]
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 [BatCharParser]
Create a source from a latin-1 character.
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
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 [BatText]
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 [BatString.Cap]
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 [BatDllist]
splice n1 n2 Connects n1 and n2 so that next n1 == n2 && prev n2 == n1.
split [BatText]
split s sep splits the rope s between the first occurrence of sep.
split [BatString.Cap.Exceptionless]
split [BatString.Cap]
Splitting around
split [BatString.Exceptionless]
split s sep splits the string s between the first occurrence of sep, or returns None if the separator is not found.
split [BatString]
split s sep splits the string s between the first occurrence of sep, and returns the two parts before and after the occurence (excluded).
split [BatStream]
split is the opposite of comb
split [BatSet.PSet]
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 [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 [BatSet]
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 [BatPathGen.PathType]
Dissect the path to its components (parent path, core part of name and possibly an extension).
split [BatMap.PMap]
split x m returns a triple (l, data, r), where l is the map with all the bindings of m whose key is strictly less than x; r is the map with all the bindings of m whose key is strictly greater than x; data is None if m contains no binding for x, or Some v if m binds v to x.
split [BatMap.S]
split x m returns a triple (l, data, r), where l is the map with all the bindings of m whose key is strictly less than x; r is the map with all the bindings of m whose key is strictly greater than x; data is None if m contains no binding for x, or Some v if m binds v to x.
split [BatMap]
split x m returns a triple (l, data, r), where l is the map with all the bindings of m whose key is strictly less than x; r is the map with all the bindings of m whose key is strictly greater than x; data is None if m contains no binding for x, or Some v if m binds v to x.
split [BatList]
Transform a list of pairs into a pair of lists: split [(a0,b0); (a1,b1); ...; (an,bn)] is ([a0; a1; ...; an], [b0; b1; ...; bn]).
split [BatFingerTree.Generic]
split p t, when p is monotonic, returns (t1, t2) where t1 is the longest prefix of t whose measure does not satifies p, and t2 is the rest of t.
split_at [BatSubstring]
split_at 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_at [BatFingerTree]
split_at is equivalent to List.split_at.
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.
sprintf [BatPrintf]
A function which doesn't print its result but returns it as a string.
sprintf [BatFormat]
Same as printf above, but instead of printing on a formatter, returns a string containing the result of formatting the arguments.
sprintf2 [BatPrintf]
A function which doesn't print its result but returns it as a string.
sqrt [BatFloat]
Square root.
sqrt [BatComplex]
Square root.
sqrt2 [BatFloat]
sqrt 2.
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.
sqrtpi2 [BatFloat]
2. *. sqrt pi
square [BatNum]
square_big_int [BatBig_int]
Return the square of the given big integer
square_num [BatNum]
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 [BatList]
Same as List.sort, but the sorting algorithm is guaranteed to be stable (i.e.
stable_sort [BatLazyList]
stable_sort [BatArray.Cap.Labels]
stable_sort [BatArray.Cap]
stable_sort [BatArray.Labels]
stable_sort [BatArray]
Same as Array.sort, but the sorting algorithm is stable (i.e.
start [BatGenlex.Languages.Make]
Medium-level API
starts_with [BatText]
starts_with s x returns true if s is starting with x, false otherwise.
starts_with [BatString.Cap]
starts_with [BatString]
starts_with s x returns true if s is starting with x, false otherwise.
stat [BatUnix.LargeFile]
stat [BatUnix]
Return the information for the named file.
stat [BatGc]
Return the current values of the memory management counters in a stat record.
state [BatParserCo]
Succeed and return the state of the parser
stats [BatOo.Internal]
std_formatter [BatFormat]
The standard formatter used by the formatting functions above.
stdbuf [BatFormat]
The string buffer in which str_formatter writes.
stderr [BatUnix]
File descriptor for standard error.
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 [BatUnix]
File descriptor for standard input.
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 [BatUnix]
File descriptor for standard output.
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_formatter [BatFormat]
A formatter to use with formatting functions below for output to the stdbuf string buffer.
str_int_pmap [BatteriesPrint]
str_option [BatOptParse.StdOpt]
See OptParse.StdOpt.int_option.
str_str_pmap [BatteriesPrint]
string [BatGenlex.Languages.Make]
As CharParser.string, but case-insensitive if specified by case_sensitive.
string [BatDigest]
Return the digest of the given string.
string [BatCharParser]
Recognize exactly one string
string_dynarray [BatteriesPrint]
string_enum [BatteriesPrint]
string_literal [BatGenlex.Languages.Make]
Accepts a string, i.e.
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_cap [BatteriesPrint]
string_of_inet_addr [BatUnix]
Return the printable representation of the given Internet address.
string_of_num [BatNum]
string_of_token [BatGenlex]
string_pset [BatteriesPrint]
string_set [BatteriesPrint]
strings_of [BatIO]
Read an enumeration of null-terminated strings.
strip [BatText]
Returns the rope without the chars if they are at the beginning or at the end of the rope.
strip [BatString.Cap]
strip [BatString]
Returns the string without the chars if they are at the beginning or at the end of the string.
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 [BatText]
sub r m n returns a sub-rope of r containing all characters whose indexes range from m to m + n - 1 (included).
sub [BatString.Cap]
sub [BatString]
String.sub s start len returns a fresh string of length len, containing the substring of s that starts at position start and has length len.
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 [BatBuffer]
Buffer.sub b off len returns (a copy of) the substring of the current contents of the buffer b starting at offset off of length len bytes.
sub [BatBool]
sub [BatBigarray.Array1]
Extract a sub-array of the given one-dimensional big array.
sub [BatBig_int]
sub [BatArray.Cap.Labels]
sub [BatArray.Cap]
sub [BatArray.Labels]
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_big_int [BatBig_int]
Subtraction.
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_num [BatNum]
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.PSet]
subset a b returns true if a is a subset of b.
subset [BatSet.S]
subset s1 s2 tests whether the set s1 is a subset of the set s2.
subset [BatSet]
subset a b returns true if a is a subset of b.
subset [BatISet]
subset t u returns true if t is a subset of u
substring [BatSubstring]
substring s o l returns a substring with base-string s, offset o and length l.
substring [BatDigest]
Digest.substring s ofs len returns the digest of the substring of s starting at character number ofs and containing len characters.
succ [BatNumber.Discrete]
succ [BatNumber.Numeric]
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]
succ_big_int [BatBig_int]
Successor (add 1).
succ_num [BatNum]
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 integers of l
sum [BatEnum]
sum returns the sum of the given int enum.
sum [BatArray]
sum l returns the sum of the integers of l
suspend [BatParserCo]
suspend s returns the state of the parser in a form that can be resumed by calling the returned function.
swap [BatTuple.Tuple2]
swap [BatRef]
swap a b puts !b in a and !a in b
switch [BatStream.StreamLabels]
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 [BatSet.PSet]
sym_diff s t returns the set of all elements in s or t but not both.
sym_diff [BatSet.S]
sym_diff s t returns the set of all elements in s or t but not both.
sym_diff [BatSet]
sym_diff s t returns the set of all elements in s or t but not both, also known as the symmetric difference.
sym_diff [BatBitSet]
sym_diff s t returns the symmetrical difference of s and t.
symlink [BatUnix]
symlink source dest creates the file dest as a symbolic link to the file source.
sync [BatConcurrent]
Specialized version of synchronized.
synchronize [BatRMutex]
Protect a function.
synchronize [BatMutex]
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.
system [BatUnix]
Execute the given command, wait until it terminates, and return its termination status.

T
tab_out [BatIO]
Create an output shifted to the right by a number of spaces (or other character as specified by tab).
tail [BatText]
tail r pos returns the rope containing all but the pos first characters of r
tail [BatString.Cap]
tail [BatString]
tail r pos returns the string containing all but the pos first characters of r
tail [BatFingerTree.S]
tail t returns None when t is empty, or Some tl where tl is the sequence t where the first element has been removed.
tail [BatArray]
tail r pos returns the array containing all but the pos first characters of r
tail_exn [BatFingerTree.S]
tail_exn t returns the sequence t where the first element has been removed.
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.Exceptionless]
take [BatQueue]
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 [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]
take_while p xs returns the (possibly empty) longest prefix of elements of xs that satisfy the predicate p.
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.
tap [BatPervasives]
Allows application of a function in the middle of a pipe sequence without disturbing the sequence.
tap [BatInnerPervasives]
tcdrain [BatUnix]
Waits until all output written on the given file descriptor has been transmitted.
tcflow [BatUnix]
Suspend or restart reception or transmission of data on the given file descriptor, depending on the second argument: TCOOFF suspends output, TCOON restarts output, TCIOFF transmits a STOP character to suspend input, and TCION transmits a START character to restart input.
tcflush [BatUnix]
Discard data written on the given file descriptor but not yet transmitted, or data received but not yet read, depending on the second argument: TCIFLUSH flushes data received but not read, TCOFLUSH flushes data written but not transmitted, and TCIOFLUSH flushes both.
tcgetattr [BatUnix]
Return the status of the terminal referred to by the given file descriptor.
tcsendbreak [BatUnix]
Send a break condition on the given file descriptor.
tcsetattr [BatUnix]
Set the status of the terminal referred to by the given file descriptor.
text_set [BatteriesPrint]
third [BatTuple.Tuple5]
third [BatTuple.Tuple4]
third [BatTuple.Tuple3]
time [BatUnix]
Return the current time since 00:00:00 GMT, Jan.
time [BatSys]
Return the processor time, in seconds, used by the program since the beginning of execution.
times [BatUnix]
Return the execution times of the process.
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 [BatList.Exceptionless]
tl l returns Some x such that x is the given list l without its first element.
tl [BatList]
Return the given list without its first element.
tl [BatLazyList]
Return the given list without its first element.
to_array [BatVect.Make]
to_array r returns an array corresponding to the vect r.
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_buffer [BatMarshal]
Marshal.to_buffer buff ofs len v flags marshals the value v, storing its byte representation in the string buff, starting at character number ofs, and writing at most len characters.
to_byte [BatInt32]
to_channel [BatMarshal]
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_f_printer [BatIO]
to_float [BatString.Cap.Exceptionless]
to_float [BatString.Cap]
to_float [BatString.Exceptionless]
Returns the float represented by the given string or None if the string does not represent a float.
to_float [BatString]
Returns the float represented by the given string or
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 [BatComplex]
Complex.to_float (a+bi) returns the float a
to_float [BatBool]
to_float [BatBig_int]
to_hex [BatDigest]
Return the printable hexadecimal representation of the given digest.
to_input_channel [BatIO]
Create a channel that will read from an input.
to_int [BatString.Cap.Exceptionless]
to_int [BatString.Cap]
to_int [BatString.Exceptionless]
Returns the integer represented by the given string or None if the string does not represent an integer.
to_int [BatString]
Returns the integer represented by the given string or
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 c is the integer part of the real part of c
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_int64 [BatNativeint]
Convert the given native integer to a 64-bit integer (type int64).
to_int64 [BatInt32]
Convert the given 32-bit integer (type int32) to a 64-bit integer (type int64).
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.Cap]
to_list [BatString]
Converts a string to the list of its characters.
to_list [BatStream]
Convert a stream to a list
to_list [BatSplay.Map]
to_list [BatRefList]
Returns the current elements as a list - O(1)
to_list [BatLazyList]
Eager conversion to string.
to_list [BatHeap.H]
to_list [BatHeap]
Enumerate the elements of the heap.
to_list [BatFingerTree.S]
to_list t is equivalent to BatList.of_enum (enum t).
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 [BatDeque]
to_list dq is a list representation of the elements of dq.
to_list [BatArray.Cap]
to_list [BatArray]
Array.to_list a returns the list of all the elements of a.
to_list_backwards [BatFingerTree.S]
to_list_backwards t is equivalent to BatList.of_enum (backwards t).
to_nativeint [BatInt64]
Convert the given 64-bit integer (type int64) to a native integer.
to_nativeint [BatInt32]
Convert the given 32-bit integer (type int32) 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 [BatText]
to_string t returns a UTF-8 encoded string representing t
to_string [BatSubstring]
string sus is the string si..i+n-1 represented by sus = (s, i, n).
to_string [BatString.Cap]
Return a capability string as a regular string.
to_string [BatStream]
convert stream of chars to string, using buffer
to_string [BatPrintexc]
Printexc.to_string e returns a string representation of the exception e.
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 [BatMarshal]
Marshal.to_string v flags returns a string containing the representation of v as a sequence of bytes.
to_string [BatLog.Level_sig]
The default level for loggers created with this; log messages with level less than this won't be printed by default.
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_string_fmt [BatStream.StreamLabels]
to_string_fmt [BatStream]
convert stream to string, using Printf with given format
to_string_fun [BatStream.StreamLabels]
to_string_fun [BatStream]
convert stream to string, using given conversion function
to_string_in_base [BatBig_int]
to_string_in_base b n returns the string representation in base b of the given big integer n.
to_string_in_binary [BatBig_int]
as string_of_big_int, but in base 2
to_string_in_custom_base [BatBig_int]
First argument, called symbols, is the vector of the symbols used to represent the digits in base b.
to_string_in_hexa [BatBig_int]
as string_of_big_int, but in base 16
to_string_in_octal [BatBig_int]
as string_of_big_int, but in base 8
to_table [BatHashtbl.Cap]
Return a capability hashtable as a regular hashtable.
to_ustring [BatPathGen.PathType]
Convert to the chosen ustring type.
toggle [BatRef]
Invert the boolean stored in the reference
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 [BatStack.Exceptionless]
top [BatStack]
top s returns the topmost element in stack s, or
top [BatQueue]
top is a synonym for peek.
total_size [BatMarshal]
See Marshal.header_size.
transfer [BatQueue]
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.
transpose [BatList]
Transposes a list of lists, turning rows of the input into columns of the output and vice versa.
trim [BatSubstring]
removes whitespace from left and right ends of input
trim [BatString.Cap]
trim [BatString]
Return a copy of the argument, without leading and trailing whitespace.
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.
truncate [BatUnix.LargeFile]
truncate [BatUnix]
Truncates the named file to the given size.
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 [BatConcurrent.BaseLock]
try_lock [BatConcurrent.Lock]

U
uget [BatUref]
uget ur returns the value stored in the uref ur.
ui16s_of [BatIO.BigEndian]
Read an enumeration of unsigned 16-bit words.
ui16s_of [BatIO]
Read an enumeration of unsigned 16-bit words.
umask [BatUnix]
Set the process's file mode creation mask, and return the previous mask.
uncapitalize [BatString.Cap]
uncapitalize [BatString]
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 [BatTuple.Tuple5]
uncurry [BatTuple.Tuple4]
uncurry [BatTuple.Tuple3]
uncurry [BatTuple.Tuple2]
uncurry [BatPervasives]
Convert a function which accepts a two arguments into a function which accepts a pair of arguments.
uncurry [BatInnerPervasives]
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]
As from_loop, except uses option type to signal the end of the enumeration.
union [BatSet.PSet]
union s t returns the union of s and t - the set containing all elements in either s and t.
union [BatSet.S]
Set union.
union [BatSet]
union s t returns the union of s and t - the set containing all elements in either s and t.
union [BatMap.PMap]
union m1 m2 merges two maps, using the comparison function of m1.
union [BatMap]
union m1 m2 merges two maps, using the comparison function of m1.
union [BatISet]
Compute the union of two sets.
union [BatIMap]
Merge two maps, giving a value
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 [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]
unique cmp l returns the list l without any duplicate element.
unique [BatInnerPervasives]
unique_cmp [BatList]
As unique, except comparator parameter returns an int.
unique_eq [BatLazyList]
as unique except only uses an equality function.
unique_hash [BatList]
As unique, except uses a hash table to cut down the expected runtime to linear, assuming a good hash function.
unique_value [BatInnerPervasives]
unit_big_int [BatBig_int]
The big integer 1.
unite [BatUref]
unite ~sel ur1 ur2 unites the urefs ur1 and ur2, selecting the result of sel (uget ur1) (uget ur2) for the contents of the resulting united uref.
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.
unlink [BatUnix]
Removes the named file
unlock [BatRMutex]
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 x t returns the portion of t in the range min_int, x
until [BatIMap]
Return the sub-map of bindings in the range min_int, x
update [BatFingerTree]
update t i f returns t where the i-th element is now f (get i t).
uppercase [BatString.Cap]
uppercase [BatString]
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 [BatChar]
Convert the given character to its equivalent uppercase character.
uppercase_latin1 [BatCharParser]
Recognizes one upper-case Latin-1 character, including accentuated characters.
uref [BatUref]
uref x allocates a new uref and places the value x in it.
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
uset [BatUref]
uset ur x updates the contents of ur with x.
utimes [BatUnix]
Set the last access time (second arg) and last modification time (third arg) for a file.

V
validate [BatUTF8]
validate s successes if s is valid UTF-8, otherwise raises Malformed_code.
value_option [BatOptParse.Opt]
Make an option which takes a single argument.
values [BatMap.PMap]
Return an enumeration of al the values of a map.
values [BatMap.S]
Return an enumeration of al the values of a map.
values [BatMap]
Return an enumeration of al the values of a map.
values [BatHashtbl.Cap]
values [BatHashtbl.S]
values [BatHashtbl]
Return an enumeration of all the values of a hashtable.
verify_arg [BatPervasives]
verify_arg condition message will raise Invalid_argument message if condition is false, otherwise it does nothing.
version [BatteriesConfig]
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
wait [BatUnix]
Wait until one of the children processes die, and return its pid and termination status.
waitpid [BatUnix]
Same as Unix.wait, but waits for the child process whose pid is given.
while_do [BatEnum]
while_do cont f e is a loop on e using f as body and cont as condition for continuing.
whitespace [BatCharParser]
Recognizes white-space
whitespaces [BatGenlex.Languages.Make]
widen [BatOo.Internal]
with_dispose [BatPervasives]
with_dispose dispose f x invokes f on x, calling dispose x when f terminates (either with a return value or an exception).
with_dispose [BatInnerPervasives]
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 [BatteriesConfig]
word_size [BatSys]
Size of one word on the machine currently executing the OCaml 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 [BatPervasives]
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 [BatInnerPervasives]
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 [BatUnix]
write fd buff ofs len writes len characters to descriptor fd, taking them from string buff, starting at position ofs in string buff.
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_byte [BatInnerIO]
Write an unsigned 8-bit byte.
write_byte [BatIO]
Write an unsigned 8-bit byte.
write_char [BatText]
Write one uchar to a UTF-8 encoded output.
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_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_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_i64 [BatInnerIO]
Write an OCaml int64.
write_i64 [BatIO.BigEndian]
Write an OCaml int64.
write_i64 [BatIO]
Write an OCaml int64.
write_line [BatText]
Write one line onto a UTF-8 encoded output, followed by a \n.
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 [BatFile]
write_lines name lines writes strings given by lines to file name with newline character appended to each line.
write_only [BatString.Cap]
Drop capabilities to write only.
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_string [BatInnerIO]
Write a string and append an null character.
write_string [BatIO]
Write a string and append an null character.
write_text [BatText]
Write a character text 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.

X
xor_big_int [BatBig_int]
Bitwise logical ``exclusive or''.

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_big_int [BatBig_int]
The big integer 0.
zero_plus [BatParserCo]
Accept a (possibly empty) list of expressions.