Index of values

( * ) [BatNum]
( * ) [BatNativeint]
( * ) [BatInt64]
( * ) [BatInt32]
( * ) [BatInt.Safe_int]

Multiplication.

( * ) [BatInt]

Multiplication.

( * ) [BatFloat.Safe_float]
( * ) [BatFloat]
( * ) [BatComplex]
( * ) [BatBounded.NumericSig]
( * ) [BatBool]
( * ) [BatNumber.Infix]
( * ) [BatBig_int]
( ** ) [BatNum]
( ** ) [BatNativeint]
( ** ) [BatInt64]
( ** ) [BatInt32]
( ** ) [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]
(+) [BatInt32]
(+) [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]
(-) [BatInt32]
(-) [BatInt.Safe_int]

Subtraction.

(-) [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]
(/) [BatInt32]
(/) [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]

Comparison: 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]

Comparison: 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]

Comparison: 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]

Comparison: 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]

Comparison: 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]

Comparison: 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

(>>=) [BatOption.Infix]

as Monad.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

_exit [BatUnix]

Terminate the calling process immediately, returning the given status code to the operating system: usually 0 to indicate no errors, and a small positive integer to indicate failure.

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.S]
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 the end of 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_bytes [BatBuffer]

add_bytes b s appends the string s at the end of the buffer b.

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_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_int16_be [BatBuffer]

add_int16_be b i appends a binary big-endian signed 16-bit integer i to b.

add_int16_le [BatBuffer]

add_int16_le b i appends a binary little-endian signed 16-bit integer i to b.

add_int16_ne [BatBuffer]

add_int16_ne b i appends a binary native-endian signed 16-bit integer i to b.

add_int32_be [BatBuffer]

add_int32_be b i appends a binary big-endian 32-bit integer i to b.

add_int32_le [BatBuffer]

add_int32_le b i appends a binary little-endian 32-bit integer i to b.

add_int32_ne [BatBuffer]

add_int32_ne b i appends a binary native-endian 32-bit integer i to b.

add_int64_be [BatBuffer]

add_int64_be b i appends a binary big-endian 64-bit integer i to b.

add_int64_le [BatBuffer]

add_int64_ne b i appends a binary little-endian 64-bit integer i to b.

add_int64_ne [BatBuffer]

add_int64_ne b i appends a binary native-endian 64-bit integer i to b.

add_int8 [BatBuffer]

add_int8 b i appends a binary signed 8-bit integer i to 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_range lo hi y t adds bindings to y for all values in the range lo,hi, returning a new map

add_seq [BatSet.PSet]

add the given elements to the set, in order.

add_seq [BatSet.S]

add the given elements to the set, in order.

add_seq [BatSet]

add the given elements to the set, in order.

add_seq [BatQueue]

Add the elements from the generator to the end of the queue

add_seq [BatMap.PMap]

add the given bindings to the map, in order.

add_seq [BatMap.S]

add the given bindings to the map, in order.

add_seq [BatMap]

add the given bindings to the map, in order.

add_seq [BatBuffer]

Add chars to the buffer

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_subbytes [BatBuffer]

add_subbytes b s ofs len takes len characters from offset ofs in byte sequence s and appends them 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.

add_uint16_be [BatBuffer]

add_uint16_be b i appends a binary big-endian unsigned 16-bit integer i to b.

add_uint16_le [BatBuffer]

add_uint16_le b i appends a binary little-endian unsigned 16-bit integer i to b.

add_uint16_ne [BatBuffer]

add_uint16_ne b i appends a binary native-endian unsigned 16-bit integer i to b.

add_uint8 [BatBuffer]

add_uint8 b i appends a binary unsigned 8-bit integer i to b.

add_utf_16be_uchar [BatBuffer]

add_utf_16be_uchar b u appends the UTF-16BE encoding of u at the end of buffer b.

add_utf_16le_uchar [BatBuffer]

add_utf_16le_uchar b u appends the UTF-16LE encoding of u at the end of buffer b.

add_utf_8_uchar [BatBuffer]

add_utf_8_uchar b u appends the UTF-8 encoding of u at the end of 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 [BatSet.PSet]

Return one element of the given set.

any [BatSet.S.Exceptionless]
any [BatSet.S]

Return one element of the given set.

any [BatSet]

Return one element of the given set.

any [BatParserCo]

Accept any singleton value.

any [BatMap.PMap.Exceptionless]
any [BatMap.PMap]

Return one binding of the given map.

any [BatMap.Exceptionless]
any [BatMap.S.Exceptionless]
any [BatMap.S]

Return one binding of the given map.

any [BatMap]

Return one binding of the given map.

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]

append l1 l2 is a concatenation of l1 and l2.

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.

append_to_buffer [BatSubstring]

append_to_buffer buff ss appends the sub string ss to buffer b.

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.

array0_of_genarray [BatBigarray]

Return the zero-dimensional big array corresponding to the given generic big array.

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.

array_shuffle [BatInnerShuffle]
asin [BatFloat.Safe_float]
asin [BatFloat]
asprintf [BatFormat]

Same as printf above, but instead of printing on a formatter, returns a string containing the result of formatting the arguments.

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.

assoc_opt [BatList]

assoc_opt a l returns the value associated with key a 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.

assq_opt [BatList]

Same as List.assoc_opt, but uses physical equality instead of structural equality to compare keys.

at [BatVect.Make.Labels]
at [BatVect.Make]

as get

at [BatVect.Labels]
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

at_opt [BatList]

at_opt returns the n-th element of the list l or None if the index is beyond the length of l.

at_rank_exn [BatSet.PSet]

at_rank_exn i s returns element at rank i in s, that is the i-th element in increasing order (the 0-th element being the smallest element of s).

at_rank_exn [BatSet.S]

at_rank_exn i s returns element at rank i in s, that is the i-th element in increasing order (the 0-th element being the smallest element of s).

at_rank_exn [BatSet]

at_rank_exn i s returns element at rank i in s, that is the i-th element in increasing order (the 0-th element being the smallest element of s).

at_rank_exn [BatMap.PMap]

at_rank_exn i m returns the (key,value) pair whose key is at rank i in m, that is the i-th element in increasing order of the keys (the 0-th element being the smallest key in m with its associated value).

at_rank_exn [BatMap]

at_rank_exn i m returns the (key,value) pair whose key is at rank i in m, that is the i-th element in increasing order of the keys (the 0-th element being the smallest key in m with its associated value).

atan [BatFloat.Safe_float]
atan [BatFloat]
atan2 [BatFloat.Safe_float]

The usual trigonometric functions.

atan2 [BatFloat]

The usual trigonometric functions.

avg [BatDynArray]

avg l returns the average of l

avg [BatArray]

avg l returns the average of l

B
backend_type [BatSys]

Backend type currently executing the OCaml program.

backtrace_slots [BatPrintexc]

Returns the slots of a raw backtrace, or None if none of them contain useful information.

backtrace_slots_of_raw_entry [BatPrintexc]

Returns the slots of a single raw backtrace entry, or None if this entry lacks debug information.

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 [BatText]

enumerates the rope's characters, in reverse order

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.

basename [BatFilename]

Split a file name into directory name / base file name.

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.

big_int_of_string_opt [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' otherwise.

bind [BatUnix]

Bind a socket to an address.

bind [BatResult.Monad]

Monadic composition.

bind [BatResult]

bind r f is f v if r is Ok v and r if r is Error _.

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.

bindings [BatHashtbl]

Alias for to_list.

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 the byte sequence 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 [BatBytes]

blit src srcoff dst dstoff len copies len bytes from sequence src, starting at index srcoff, to sequence dst, starting at index dstoff.

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.Array0]

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.

blit_string [BatBytes]

blit_string src srcoff dst dstoff len copies len bytes from string src, starting at index srcoff, to byte sequence dst, starting at index dstoff.

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 scanning buffer ib, according to the given format string fmt, and applies f to the resulting format string value.

bsearch [BatArray]

bsearch cmp arr x finds the index of the object x in the array arr, provided arr is sorted using cmp.

buffer_add_subbytes [BatBytesCompat]
buffer_to_bytes [BatBytesCompat]
bytes [BatDigest]

Return the digest of the given byte sequence.

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.

capitalize [BatBytes]

Return a copy of the argument, with the first byte set to uppercase.

capitalize_ascii [BatString]

Return a copy of the argument, with the first character set to uppercase, using the US-ASCII character set.

capitalize_ascii [BatBytes]

Return a copy of the argument, with the first character set to uppercase, using the US-ASCII character set.

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 [BatSet.Make2]

cartesian product of the two sets

cartesian_product [BatSet]

cartesian product of the two sets

cartesian_product [BatList]

Different from List.combine, this returns every pair of elements formed out of the two lists.

cartesian_product [BatEnum]

cartesian_product e1 e2 computes the cartesian product of e1 and e2.

cartesian_product [BatDynArray]

Cartesian product of the two arrays.

cartesian_product [BatArray]

Cartesian product of the two arrays.

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.

cat [BatString]

cat s1 s2 concatenates s1 and s2 (equivalent to s1 ^ s2).

cat [BatBytes]

cat s1 s2 concatenates s1 and s2 and returns the result as new byte sequence.

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 parameters.

catch3 [BatResult]

As catch but three parameters.

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]
change_layout [BatBigarray.Array3]

Array3.change_layout a layout returns a bigarray with the specified layout, sharing the data with a (and hence having the same dimensions as a).

change_layout [BatBigarray.Array2]

Array2.change_layout a layout returns a bigarray with the specified layout, sharing the data with a (and hence having the same dimensions as a).

change_layout [BatBigarray.Array1]

Array1.change_layout a layout returns a bigarray with the specified layout, sharing the data with a (and hence having the same dimension as a).

change_layout [BatBigarray.Array0]

Array0.change_layout a layout returns a big array with the specified layout, sharing the data with a.

change_layout [BatBigarray.Genarray]

Genarray.change_layout a layout returns a bigarray with the specified layout, sharing the data with a (and hence having the same dimensions as a).

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]
char_set [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.

check [BatAvlTree]

Check that the tree is balanced according to the AVL tree rules.

check_suffix [BatFilename]

check_suffix name suff returns true if the filename name ends with the suffix suff.

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.

choose [BatSet]

returns an arbitrary (but deterministic) element of the given set.

choose [BatMap.PMap.Exceptionless]
choose [BatMap.PMap]

Return one binding of the given map.

choose [BatMap.Exceptionless]
choose [BatMap.S.Exceptionless]
choose [BatMap.S]

Return one binding of the given map.

choose [BatMap]

Return one binding of the given map.

choose [BatISet]

Returns some element in the set

choose_opt [BatSet.PSet]

Return Some e for one element e of the given set.

choose_opt [BatSet.S]

Return Some e for one element e of the given set.

choose_opt [BatSet]

Return Some e for one element e of the given set.

choose_opt [BatMap.PMap]

Return Some (k, v) for one binding (k, v) of the given map, if the map is not empty.

choose_opt [BatMap.S]

Return Some (k, v) for one binding (k, v) of the given map, if the map is not empty.

choose_opt [BatMap]

Return Some (k, v) for one binding (k, v) of the given map, if the map is not empty.

chop [BatString.Cap]
chop [BatString]

Returns the same string but with the first l characters on the left and the first r characters on the right removed.

chop_extension [BatFilename]

Same as Filename.remove_extension, but raise Invalid_argument if the given name has an empty extension.

chop_suffix [BatFilename]

chop_suffix name suff removes the suffix suff from the filename name.

chop_suffix_opt [BatFilename]

chop_suffix_opt ~suffix filename removes the suffix from the filename if possible, or returns None if the filename does not end with the suffix.

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.S]
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.

combination [BatEnum]

combination n k returns an enumeration over combination of k elements between n distincts elements.

combinations [BatLazyList]

combinations l yields a list of all combinations of elements of l.

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 two streams into a stream of pairs of corresponding elements.

combine [BatDynArray]

combine a b converts arrays [a0,...aN] [b0,...,bN] into an array of pairs [(a0,b0),...,(aN,bN)].

combine [BatArray.Cap]
combine [BatArray]

combine [|a1; ...; an|] [|b1; ...; bn|] is [|(a1,b1); ...; (an,bn)|].

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 [BatResult]

compare ~ok ~error r0 r1 totally orders r0 and r1 using ok and error to respectively compare values wrapped by Ok _  and Error _.

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]

a comparison function between levels, to know whether logging at a particular level should be printed

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 [BatEither]

compare ~left ~right e0 e1 totally orders e0 and e1 using left and right to respectively compare values wrapped by Left _  and Right _.

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 [BatBytes]

The comparison function for byte sequences, 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_length_with [BatList]

Compare the length of a list to an integer.

compare_lengths [BatList]

Compare the lengths of two lists.

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 [BatFilename]

concat dir file returns a file name that designates file file in directory dir.

concat [BatEnum]

concat e returns an enumeration over all elements of all enumerations of e.

concat [BatBytes]

concat sep sl concatenates the list of byte sequences sl, inserting the separator byte sequence sep between each, and returns the result as a new byte sequence.

concat [BatAvlTree]
concat [BatArray.Cap]
concat [BatArray]

Same as Array.append, but concatenates a list of arrays.

concat_map [BatStream]

Composition of BatStream.concat and BatStream.map.

concat_map [BatSeq]

Alias for BatSeq.flat_map.

concat_map [BatList.Labels]
concat_map [BatList]

List.concat_map f l gives the same result as List.concat (List.map f l).

concat_map [BatEnum]

Synonym of BatEnum.Monad.bind, with flipped arguments.

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 [BatSubstring]

contains s c tests if character c appears in the substring s.

contains [BatString.Cap]
contains [BatString]

String.contains s c tests if character c appears in the string s.

contains [BatBytes]

contains s c tests if byte c appears in 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.

contains_from [BatBytes]

contains_from s start c tests if byte 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.

convert_raw_backtrace_slot [BatPrintexc]

Extracts the user-friendly backtrace_slot from a low-level raw_backtrace_slot.

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 [BatInnerWeaktbl.S]
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 a returns a fresh copy of a, such that no modification of a 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 [BatBytes]

Return a new byte sequence that contains the same bytes as the argument.

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 [BatInt]

copysign n o multiplies o by the "sign" of n, i.e.

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_char [BatString.Cap]
count_char [BatString]

count_char str c returns the number of times c is used in str.

count_lines [BatFile]

count_lines filename count the number of lines in given file.

count_matching [BatList.Labels]
count_matching [BatList]

count_matching p l returns the number of elements in l that satisfy p.

count_matching [BatArray.Cap.Labels]
count_matching [BatArray.Cap]
count_matching [BatArray.Labels]
count_matching [BatArray]

count_matching p a returns the number of elements of a satisfying predicate p.

count_option [BatOptParse.StdOpt]

Create a counting option which increments its value each time the option is encountered on the command line.

count_string [BatString]

count_string s x count how many times x is found in s.

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]

create kcomp vcomp creates a new empty map, using kcomp for key comparison and vcomp for value comparison.

create [BatMap.PMap]

Creates a new empty map, using the provided function for key comparison.

create [BatInnerWeaktbl.S]
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 [BatBytes]

create n returns a new byte sequence of length n.

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.Array0]

Array0.create kind layout returns a new bigarray of zero dimension.

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 [BatAvlTree]

create l v r is similar to make_tree l v r but performs no rebalancing; in other words, you should use this only when you know that l and r are already balanced.

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_float [BatArray]
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_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_with [BatDynArray]

create a new dynamic array that uses the given resizer.

current_browse [BatteriesConfig]
current_dir_name [BatFilename]

The conventional name for the current directory (e.g.

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]
cut_on_char [BatString]

Similar to Unix cut.

cycle [BatEnum]

cycle is similar to repeat, except that the content to fill is a subenum rather than a single element.

cygwin [BatSys]

True if Sys.os_type = "Cygwin".

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 Error 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_delayed [BatOption]

Like BatOption.default, but the default value is passed as a thunk that is only computed if needed.

default_level [BatLog.Level_sig]

The default level for loggers created with this; log messages with level less than this won't be printed by default.

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_uncaught_exception_handler [BatPrintexc]

Printexc.default_uncaught_exception_handler prints the exception and backtrace on standard error output.

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 idx len deletes len elements starting at index idx.

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.Labels]
destructive_set [BatVect.Make]

destructive_set v n c sets the element of index n in the v vect to c.

destructive_set [BatVect.Labels]
destructive_set [BatVect]

destructive_set v n c sets the element of index n in the v vect to c.

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.

dir_sep [BatFilename]

The directory separator (e.g.

dirname [BatFilename]

See Filename.basename.

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 take_while 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_pos [BatLexing]

A value of type position, guaranteed to be different from any valid position.

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_fold_right [BatLazyList]

Eager fold_right

eager_of_list [BatLazyList]

Eager conversion from lists.

edit_distance [BatString]

Edition distance (also known as "Levenshtein distance").

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 [BatString]

The empty string.

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 [BatSeq]

the empty sequence, containing no elements

empty [BatRefList]

Returns a new empty ref list

empty [BatMultiPMap]

The empty map, using compare as comparison function for both keys and values.

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 [BatBytes]

A byte sequence of size 0.

empty [BatBitSet]

Create an empty bitset of capacity 0, the bitset will automatically expand when needed.

empty [BatAvlTree]
enable_runtime_warnings [BatSys]

Control whether the OCaml runtime system can emit warnings on stderr.

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.

ends_with [BatBytes]

ends_with ~suffix s is true if and only if s ends with suffix.

ends_with_stdlib [BatString]

Equivalent to ends_with but the suffix is a labelled parameter.

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 [BatText]

enumerate the rope's characters

enum [BatSubstring]

enum ss returns an enumeration of the characters represented by ss.

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]

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_destruct 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 [BatDeque]

eq dq1 dq2 is true if dq1 and dq2 have the same sequence of elements.

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 [BatText]

Equality of ropes (based on compare)

equal [BatSubstring]

Substring equality

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 [BatSeq]

equal ~eq s1 s2 compares elements of s1 and s2 pairwise using eq

equal [BatResult]

equal ~ok ~error r0 r1 tests equality of r0 and r1 using ok and error to respectively compare values wrapped by Ok _ and Error _.

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 [BatList]

equal eq [a1; ...; an] [b1; ..; bm] holds when the two input lists have the same length, and for each pair of elements ai, bi at the same position we have eq ai bi.

equal [BatLazyList]

equal eq s1 s2 compares elements of s1 and s2 pairwise using eq and returns true if all elements pass the test and the lists have the same length; otherwise it returns false.

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 [BatInnerWeaktbl.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 [BatEither]

equal ~left ~right e0 e1 tests equality of e0 and e1 using left and right to respectively compare values wrapped by Left _ and Right _.

equal [BatDigest]

The equal function for digests.

equal [BatComplex]
equal [BatChar]
equal [BatBytes]

The equality function for byte sequences.

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 [BatResult]

error e is Error e.

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.

escaped [BatBytes]

Return a copy of the argument, with special characters represented by escape sequences, following the lexical conventions of OCaml.

establish_server [BatUnix]

Establish a server on the given address.

eternity [BatLazyList]

An infinite list of nothing

eventlog_pause [BatGc]

eventlog_pause () will pause the collection of traces in the runtime.

eventlog_resume [BatGc]

eventlog_resume () will resume the collection of traces in the runtime.

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.Labels]
exists [BatVect.Make]

exists p [a0; a1; ...; an] checks if at least one element of the vect satisfies the predicate p.

exists [BatVect.Labels]
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 a 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 a predicate function.

exists [BatList.Labels]
exists [BatList]

exists p [a0; 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 [BatHashtbl.Cap.Labels]
exists [BatHashtbl.Cap]
exists [BatHashtbl.S.Labels]
exists [BatHashtbl.S]
exists [BatHashtbl.Labels]
exists [BatHashtbl]

Check if at least one key-value pair satisfies p k v

exists [BatEnum.Labels]
exists [BatEnum]

exists f e returns true if there is some x in e such that f x

exists [BatDynArray]

exists p [a0; a1; ...; an] checks if at least one element of the array satisfies the predicate p.

exists [BatDllist]

Test whether there exists an element of the given list for which the predicate returns true.

exists [BatBytes]

exists p s checks if at least one character of s satisfies the predicate p.

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 [BatDynArray]

As BatDynArray.exists but on two arrays.

exists2 [BatArray]

As Array.exists but on two arrays.

exists_stdlib [BatString]

exists_stdlib p str check if at least one char of str satisfies the predicate p.

exn_slot_id [BatPrintexc]

Printexc.exn_slot_id returns an integer which uniquely identifies the constructor used to create the exception value exn (in the current runtime).

exn_slot_name [BatPrintexc]

Printexc.exn_slot_name exn returns the internal name of the constructor used to create the exception value exn.

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.

extend [BatBytes]

extend s left right returns a new byte sequence that contains the bytes of s, with left uninitialized bytes prepended and right uninitialized bytes appended to it.

extension [BatFilename]

extension name is the shortest suffix ext of name0 where:

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.

favg [BatList]

favg l returns the average of the floats of l

favg [BatDynArray]

favg l returns the average of l

favg [BatArray]

favg l returns the average of l

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 the byte sequence s in place, replacing len characters by c, starting at start.

fill [BatOptParse.Formatter]

See OptParse.Formatter.wrap.

fill [BatDynArray]

fill a start len x modifies the array a in place, storing x in elements number start to start + len - 1.

fill [BatBytes]

fill s start len c modifies s in place, replacing len characters with c, starting at start.

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.Array0]

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.Labels]
filter [BatVect.Make]

filter f v returns a vect with the elements x from v such that f x returns true.

filter [BatVect.Labels]
filter [BatVect]

filter f v returns a vect with the elements a from v such that f a 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 [BatQueue]

filter p q returns a new queue that contain the elements of q that satisfy the predicate p, in the same order.

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 of m such that f key value = true remain.

filter [BatMap.S.Labels]
filter [BatMap.S]

filter f m returns a map where only the (key, value) pairs of m such that f key value = true remain.

filter [BatMap]

filter f m returns a map where only the (key, value) pairs of m such that f key value = 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_inplace [BatQueue]

filter_inplace p q removes all the elements of the queue q that don't satisfy the predicate p.

filter_inplace [BatHashtbl.Cap.Labels]
filter_inplace [BatHashtbl.Cap]
filter_inplace [BatHashtbl.S.Labels]
filter_inplace [BatHashtbl.S]
filter_inplace [BatHashtbl.Labels]
filter_inplace [BatHashtbl]

filter_inplace f m removes from m all bindings that does not satisfy the predicate f.

filter_inplace [BatConcreteQueue]
filter_map [BatVect.Make.Labels]
filter_map [BatVect.Make]

filter_map f e returns a vect consisting of all elements x such that f y returns Some x , where y is an element of e.

filter_map [BatVect.Labels]
filter_map [BatVect]

filter_map f v returns a vect consisting of all elements b such that f a returns Some b , where a is an element of v.

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 [BatQueue]

filter_map f q applies f to the elements a0,a1..an of q in order, and returns the queue of the elements bi such that f ai = Some bi, in the corresponding order.

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 of 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 of all elements x such that f y returns Some x , where y is an element of e.

filter_map_endo [BatSet.PSet]

filter_map_endo f m combines the features of filter and map.

filter_map_endo [BatSet]

filter_map_endo f m combines the features of filter and map.

filter_map_inplace [BatInnerWeaktbl.S]
filter_map_inplace [BatHashtbl.Cap.Labels]
filter_map_inplace [BatHashtbl.Cap]
filter_map_inplace [BatHashtbl.S.Labels]
filter_map_inplace [BatHashtbl.S]
filter_map_inplace [BatHashtbl.Labels]
filter_map_inplace [BatHashtbl]

filter_map_inplace f m performs like filter_map but modify m inplace instead of creating a new Hashtbl.

filteri [BatList]

filteri p [a0; a1; ...; an] returns all the elements ai of index i that satisfy the predicate p i ai.

filteri [BatHashtbl.Cap.Labels]
filteri [BatHashtbl.Cap]
filteri [BatHashtbl.S.Labels]
filteri [BatHashtbl.S]
filteri [BatHashtbl.Labels]
filteri [BatHashtbl]

filteri f m returns a hashtbl where only the key, values pairs key, a of m such that f key a = true remain.

filteri [BatDynArray]

As filter but with the index passed to the predicate.

filteri [BatArray]

As filter but with the index passed to the predicate.

filteri_inplace [BatHashtbl.Cap.Labels]
filteri_inplace [BatHashtbl.Cap]
filteri_inplace [BatHashtbl.S.Labels]
filteri_inplace [BatHashtbl.S]
filteri_inplace [BatHashtbl.Labels]
filteri_inplace [BatHashtbl]

filteri_inplace f m performs as filter_inplace but f receive the value in additiuon to the key.

filteri_map [BatList]

filteri_map f l calls (f 0 a0) (f 1 a1).... (f n an) where a0,a1..an are the elements of l.

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_last [BatGc]

same as BatGc.finalise except the value is not given as argument.

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.Labels]
find [BatVect.Make]

find p a returns the first element of vect a that satisfies the predicate p.

find [BatVect.Labels]
find [BatVect]

find p v returns the first element of vect v 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 [BatSet.PSet]

find x s returns the element in s that tests equal to x under its comparison function.

find [BatSet.S.Exceptionless]
find [BatSet.S]

find x s returns the element in s that tests equal to x under its comparison function.

find [BatSet]

find x s returns the set element that compares equal to x.

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]

find 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.S]
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 [BatDynArray.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 [BatDynArray]

find p a returns the first element of array a that satisfies the predicate p.

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.Labels]
find_all [BatVect.Make]

find_all is another name for Vect.filter.

find_all [BatVect.Labels]
find_all [BatVect]

find_all is another name for Vect.filter.

find_all [BatString]

find_all s x enumerates positions of s at which x occurs.

find_all [BatList.Labels]
find_all [BatList]

find_all is another name for List.filter.

find_all [BatInnerWeaktbl.S]
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 [BatDynArray]

find_all is another name for filter.

find_all [BatArray.Cap]
find_all [BatArray]

find_all is another name for Array.filter.

find_default [BatMap.PMap]

find_default d x m returns the current binding of x in m, or the default value d if no such binding exists.

find_default [BatMap.S]

find_default d x m returns the current binding of x in m, or the default value d if no such binding exists.

find_default [BatMap]

find_default d x m returns the current binding of x in m, or the default value d if no such binding exists.

find_default [BatHashtbl.Cap]
find_default [BatHashtbl.S]
find_default [BatHashtbl]

Hashtbl.find_default tbl key default finds a binding for key, or return default if key is unbound in tbl.

find_exc [BatRefList]

Alias for find_exn.

find_exn [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_first [BatSet.PSet]

find_first f m returns the first element e for which f e is true or raises Not_found if there is no such element.

find_first [BatSet.S]

find_first f m returns the first element e for which f e is true or raises Not_found if there is no such element.

find_first [BatSet]

find_first f m returns the first element e for which f e is true or raises Not_found if there is no such element.

find_first [BatMap.PMap]

find_first f m returns the first binding (k, v) for which f k is true or raises Not_found if there is no such binding.

find_first [BatMap.S]

find_first f m returns the first binding (k, v) for which f k is true or raises Not_found if there is no such binding.

find_first [BatMap]

find_first f m returns the first binding (k, v) for which f k is true or raises Not_found if there is no such binding.

find_first_opt [BatSet.PSet]

find_first_opt f m returns Some e for the first element e for which f e is true or returns None if there is no such element.

find_first_opt [BatSet.S]

find_first_opt f m returns Some e for the first element e for which f e is true or returns None if there is no such element.

find_first_opt [BatSet]

find_first_opt f m returns Some e for the first element e for which f e is true or returns None if there is no such element.

find_first_opt [BatMap.PMap]

find_first_opt f m returns Some (k, v) for the first binding (k, v) for which f k is true or returns None if there is no such binding.

find_first_opt [BatMap.S]

find_first_opt f m returns Some (k, v) for the first binding (k, v) for which f k is true or returns None if there is no such binding.

find_first_opt [BatMap]

find_first_opt f m returns Some (k, v) for the first binding (k, v) for which f k is true or returns None if there is no such binding.

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_last [BatSet.PSet]

find_last f m returns the last element e for which f e is true or raises Not_found if there is no such element.

find_last [BatSet.S]

find_last f m returns the last element e for which f e is true or raises Not_found if there is no such element.

find_last [BatSet]

find_last f m returns the last element e for which f e is true or raises Not_found if there is no such element.

find_last [BatMap.PMap]

find_last f m returns the last binding (k, v) for which f k is true or raises Not_found if there is no such binding.

find_last [BatMap.S]

find_last f m returns the last binding (k, v) for which f k is true or raises Not_found if there is no such binding.

find_last [BatMap]

find_last f m returns the last binding (k, v) for which f k is true or raises Not_found if there is no such binding.

find_last_opt [BatSet.PSet]

find_last_opt f m returns Some e for the last element e for which f e is true or returns None if there is no such element.

find_last_opt [BatSet.S]

find_last_opt f m returns Some e for the last element e for which f e is true or returns None if there is no such element.

find_last_opt [BatSet]

find_last_opt f m returns Some e for the last element e for which f e is true or returns None if there is no such element.

find_last_opt [BatMap.PMap]

find_last_opt f m returns Some (k, v) for the last binding (k, v) for which f k is true or returns None if there is no such binding.

find_last_opt [BatMap.S]

find_last_opt f m returns Some (k, v) for the last binding (k, v) for which f k is true or returns None if there is no such binding.

find_last_opt [BatMap]

find_last_opt f m returns Some (k, v) for the last binding (k, v) for which f k is true or returns None if there is no such binding.

find_left [BatEither]

find_left (Left v) is Some v, find_left (Right _) is None

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_map [BatArray.Cap.Labels]
find_map [BatArray.Cap]
find_map [BatArray.Labels]
find_map [BatArray]

find_map f a applies f to the elements of a in order, and returns the first result of the form Some v, or None if none exist.

find_map_opt [BatList.Labels]
find_map_opt [BatList]

find_map_opt f l applies f to the elements of l in order, and returns the first result of the form Some v, or None if none exist.

find_min [BatHeap.H]
find_min [BatHeap]

Find the minimal element of the heap.

find_opt [BatVect.Make]

find_opt p a returns Some x, where x is the first element of vect a that satisfies the predicate p, or None if no such element exists.

find_opt [BatVect]

find_opt p v returns Some a, where a is the first element of vect v that satisfies the predicate p, or None if no such element exists.

find_opt [BatSet.PSet]

find_opt x s returns Some k for the element k in s that tests equal to x under its comparison function.

find_opt [BatSet.S]

find_opt x s returns Some k for the element k in s that tests equal to x under its comparison function.

find_opt [BatSet]

find_opt x s returns Some k for the element k in s that tests equal to x under its comparison function.

find_opt [BatMap.S]

find_opt x m returns Some b where b is the current binding * of x in m, or None if no such binding exists.

find_opt [BatMap]

find_opt x m returns Some b where b is the current binding * of x in m, or None if no such binding exists.

find_opt [BatList]

find_opt p l returns the first element of the list l that satisfies the predicate p, or None if there is no value that satisfies p in the list l.

find_opt [BatInnerWeaktbl.S]
find_opt [BatArray.Cap.Labels]
find_opt [BatArray.Cap]
find_opt [BatArray.Labels]
find_opt [BatArray]

find_opt p a returns the first element of the array a that satisfies the predicate p, or None if there is no such element.

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

find_right [BatEither]

find_right (Right v) is Some v, find_right (Left _) is None

findi [BatVect.Make.Labels]
findi [BatVect.Make]

findi p a returns the index of the first element of vect a that satisfies the predicate p.

findi [BatVect.Labels]
findi [BatVect]

findi p v returns the index of the first element of vect v that satisfies the predicate p.

findi [BatList.Labels.LExceptionless]
findi [BatList.Labels]
findi [BatList.Exceptionless]

findi p 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 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 [BatDynArray.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 [BatDynArray]

findi p a returns the index of the first element of array a that satisfies the predicate p.

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]

Alias to hd

first [BatLazyList]

As hd

first [BatDynArray]

first darr returns the first element of darr.

flags [BatLog.Config]
flags [BatLog]

This ref holds the output flags.

flat_map [BatSeq]

Map each element to a subsequence, then return each element of this sub-sequence in turn.

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.

float_set [BatteriesPrint]
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.Labels]
fold [BatVect.Make]

An alias for fold_left

fold [BatVect.Labels]
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 [BatResult]

fold ~ok ~error r is ok v if r is Ok v and error e if r is Error e.

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 [BatList.Labels]
fold [BatList]

Alias for fold_left.

fold [BatInnerWeaktbl.S]
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 [BatEither]

fold ~left ~right (Left v) is left v, and fold ~left ~right (Right v) is right v.

fold [BatAvlTree]
fold [BatArray.Cap.Labels]
fold [BatArray.Cap]
fold [BatArray.Labels]
fold [BatArray]

Alias for fold_left.

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.Labels]
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.Labels]
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]

fold_left 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 [b0; b1; ...; bn] is f (... (f (f a b0) b1) ...) 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 [BatBytes]

fold_left f x s computes f (... (f (f x (get s 0)) (get s 1)) ...) (get s (n-1)), where n is the length of s.

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_left_map [BatList]

Combines fold_left and map.

fold_left_map [BatArray]

fold_left_map is a combination of BatArray.fold_left and BatArray.map that threads an accumulator through calls to f.

fold_lefti [BatSubstring]

As fold_left, but with the index of the element as additional argument

fold_lefti [BatString.Cap]
fold_lefti [BatString]

As fold_left, but with the index of the element as additional argument

fold_lefti [BatList]

As fold_left, but with the index of the element, from 0 to length li - 1, as additional argument.

fold_lefti [BatDynArray]

As fold_left, but with the index of the element as additional argument.

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.Labels]
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.Labels]
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]

fold_right 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 [BatBytes]

fold_right f s x computes f (get s 0) (f (get s 1) ( ... (f (get s (n-1)) x) ...)), where n is the length of s.

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 [BatSubstring]

As fold_right, but with the index of the element as additional argument

fold_righti [BatString.Cap]
fold_righti [BatString]

As fold_right, but with the index of the element as additional argument

fold_righti [BatList]

As fold_right, but with the index of the element, from 0 to length li - 1, as additional argument.

fold_righti [BatDynArray]

As fold_right, but with the index of the element as additional argument.

fold_righti [BatArray]

As fold_right, but with the index of the element as additional argument

fold_while [BatList]

fold_while p f init l, accumulates elements x of list l using function f, as long as predicate p acc x holds.

fold_while [BatArray.Cap.Labels]
fold_while [BatArray.Cap]
fold_while [BatArray.Labels]
fold_while [BatArray]

fold_while p f init a, accumulates elements x of array a using function f, as long as the predicate p acc x holds.

foldi [BatVect.Make.Labels]
foldi [BatVect.Make]

As fold, but with the position of each value passed to the folding function

foldi [BatVect.Labels]
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.Labels]
for_all [BatVect.Make]

for_all p [a0; a1; ...; an] checks if all elements of the vect satisfy the predicate p.

for_all [BatVect.Labels]
for_all [BatVect]

for_all p [a0; a1; ...; an] checks if all elements of the vect satisfy the predicate p.

for_all [BatString]

for_all p s check if all chars in s 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]

for_all 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 a 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 a predicate function.

for_all [BatList.Labels]
for_all [BatList]

for_all p [a0; 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 [BatHashtbl.Cap.Labels]
for_all [BatHashtbl.Cap]
for_all [BatHashtbl.S.Labels]
for_all [BatHashtbl.S]
for_all [BatHashtbl.Labels]
for_all [BatHashtbl]

Hashtbl.for_all p tbl check if the predicate p k v holds for all bindings currently in tbl.

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 [BatEither]

for_all ~left ~right (Left v) is left v, and for_all ~left ~right (Right v) is right v.

for_all [BatDynArray]

for_all p [a0; a1; ...; an] checks if all elements of the array satisfy the predicate p.

for_all [BatDllist]

Test whether a given predicate returns true for all members of the given list.

for_all [BatBytes]

for_all p s checks if all characters in s satisfy the predicate p.

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 [BatDynArray]

As BatDynArray.for_all but on two arrays.

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 [BatPrintexc.Slot]

format pos slot returns the string representation of slot as raw_backtrace_to_string would format it, assuming it is the pos-th element of the backtrace: the 0-th element is pretty-printed differently than the others.

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]
frange [BatList]

frange start `To stop n generates (without accumulating floating point errors) n floats in the range [start..stop].

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_bytes [BatMarshal]

Marshal.from_bytes 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 byte sequence buff, starting at position ofs.

from_channel [BatScanf.Scanning]
from_channel [BatMarshal]
from_channel [BatLexing]

Create a lexer buffer on the given input channel.

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_input ic returns a scanning buffer which reads from the input channel ic, starting 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]

Same as from_bytes but take a string as argument instead of a byte sequence.

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 [BatDynArray]

fsum l returns the sum of the floats of l.

fsum [BatArray]

fsum l returns the sum of the floats of l

fsync [BatUnix]

Flush file buffers to disk.

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_int [BatRandom.State]
full_int [BatRandom]

Random.full_int bound returns a random integer between 0 (inclusive) and bound (exclusive).

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_array0 [BatBigarray]

Return the generic big array corresponding to the given zero-dimensional big array.

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.Labels]
get [BatVect.Make]

get v n returns the (n+1)th element from the vect v; i.e.

get [BatVect.Labels]
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]

get 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 (Error 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 [BatBytes]

get s n returns the byte at index n in argument s.

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.Array0]

Array0.get a returns the only element in a.

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]
get_backtrace [BatPrintexc]

Printexc.get_backtrace () returns a string containing the same exception backtrace that Printexc.print_backtrace would print.

get_bucket [BatGc]

get_bucket n returns the current size of the n-th future bucket of the GC smoothing system.

get_callstack [BatPrintexc]
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_credit [BatGc]

get_credit () returns the current size of the "work done in advance" counter of the GC smoothing system.

get_dec_eq [BatIMap]

Get the equality function used in an IMap.t

get_ellipsis_text [BatFormat]

Return the text of the ellipsis.

get_error [BatResult]

get_error r is e if r is Error e and

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]
get_formatter_tag_functions [BatFormat]
get_int16_be [BatString]

get_int16_be b i is b's big-endian signed 16-bit integer starting at character index i.

get_int16_be [BatBytes]

get_int16_be b i is b's big-endian signed 16-bit integer starting at byte index i.

get_int16_le [BatString]

get_int16_le b i is b's little-endian signed 16-bit integer starting at character index i.

get_int16_le [BatBytes]

get_int16_le b i is b's little-endian signed 16-bit integer starting at byte index i.

get_int16_ne [BatString]

get_int16_ne b i is b's native-endian signed 16-bit integer starting at character index i.

get_int16_ne [BatBytes]

get_int16_ne b i is b's native-endian signed 16-bit integer starting at byte index i.

get_int32_be [BatString]

get_int32_be b i is b's big-endian 32-bit integer starting at character index i.

get_int32_be [BatBytes]

get_int32_be b i is b's big-endian 32-bit integer starting at byte index i.

get_int32_le [BatString]

get_int32_le b i is b's little-endian 32-bit integer starting at character index i.

get_int32_le [BatBytes]

get_int32_le b i is b's little-endian 32-bit integer starting at byte index i.

get_int32_ne [BatString]

get_int32_ne b i is b's native-endian 32-bit integer starting at character index i.

get_int32_ne [BatBytes]

get_int32_ne b i is b's native-endian 32-bit integer starting at byte index i.

get_int64_be [BatString]

get_int64_be b i is b's big-endian 64-bit integer starting at character index i.

get_int64_be [BatBytes]

get_int64_be b i is b's big-endian 64-bit integer starting at byte index i.

get_int64_le [BatString]

get_int64_le b i is b's little-endian 64-bit integer starting at character index i.

get_int64_le [BatBytes]

get_int64_le b i is b's little-endian 64-bit integer starting at byte index i.

get_int64_ne [BatString]

get_int64_ne b i is b's native-endian 64-bit integer starting at character index i.

get_int64_ne [BatBytes]

get_int64_ne b i is b's native-endian 64-bit integer starting at byte index i.

get_int8 [BatString]

get_int8 b i is b's signed 8-bit integer starting at character index i.

get_int8 [BatBytes]

get_int8 b i is b's signed 8-bit integer starting at byte index i.

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_minor_free [BatGc]

Return the current size of the free space inside the minor heap.

get_ok [BatResult]

get_ok r is v if r is Ok v and

get_print_tags [BatFormat]
get_raw_backtrace [BatPrintexc]

Printexc.get_raw_backtrace () returns the same exception backtrace that Printexc.print_backtrace would print, but in a raw format.

get_raw_backtrace_next_slot [BatPrintexc]

get_raw_backtrace_next_slot slot returns the next slot inlined, if any.

get_raw_backtrace_slot [BatPrintexc]

get_raw_backtrace_slot bckt pos returns the slot in position pos in the backtrace bckt.

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_temp_dir_name [BatFilename]

The name of the temporary directory: Under Unix, the value of the TMPDIR environment variable, or "/tmp" if the variable is not set.

get_uint16_be [BatString]

get_uint16_be b i is b's big-endian unsigned 16-bit integer starting at character index i.

get_uint16_be [BatBytes]

get_uint16_be b i is b's big-endian unsigned 16-bit integer starting at byte index i.

get_uint16_le [BatString]

get_uint16_le b i is b's little-endian unsigned 16-bit integer starting at character index i.

get_uint16_le [BatBytes]

get_uint16_le b i is b's little-endian unsigned 16-bit integer starting at byte index i.

get_uint16_ne [BatString]

get_uint16_ne b i is b's native-endian unsigned 16-bit integer starting at character index i.

get_uint16_ne [BatBytes]

get_uint16_ne b i is b's native-endian unsigned 16-bit integer starting at byte index i.

get_uint8 [BatString]

get_uint8 b i is b's unsigned 8-bit integer starting at character index i.

get_uint8 [BatBytes]

get_uint8 b i is b's unsigned 8-bit integer starting at byte index i.

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.

getenv_opt [BatSys]

Return the value associated to a variable in the process environment or None if the variable is unbound.

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_consecutive [BatList]

The group_consecutive function takes a list and returns a list of lists such that the concatenation of the result is equal to the argument.

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.

has_symlink [BatUnix]

Returns true if the user is able to create symbolic links.

hash [BatInnerWeaktbl.HashedType]
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]
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]

Returns the first element of the list, or

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 [BatDynArray]

Alias for BatDynArray.left

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)

huge_fallback_count [BatGc]

Return the number of times we tried to map huge pages and had to fall back to small pages.

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.

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 Error 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]
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]
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]

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 occurrence 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 [BatBytes]

index s c returns the index of the first occurrence of byte c in s.

index_after_n [BatString]

index_after_n chr n str returns the index of the character that comes immediately after the n-th occurrence of chr in str.

index_from [BatText]

index_from r i c returns the character number of the first occurrence of character c in rope r after position i.

index_from [BatSubstring]

index_from sus i c returns the index of the first occurrence 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 or at position i.

index_from [BatBytes]

index_from s i c returns the index of the first occurrence of byte c in s after position i.

index_from_opt [BatString]

String.index_from_opt s i c returns the index of the first occurrence of character c in string s after position i or None if c does not occur in s after position i.

index_from_opt [BatBytes]

index_from _opts i c returns the index of the first occurrence of byte c in s after position i or None if c does not occur in 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]

Alias for BatDynArray.findi

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

index_opt [BatString]

String.index_opt s c returns the index of the first occurrence of character c in string s, or None if c does not occur in s.

index_opt [BatBytes]

index_opt s c returns the index of the first occurrence of byte c in s or None if c does not occur in s.

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.

init [BatVect.Make.Labels]
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.Labels]
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 [BatBytes]

Bytes.init n f returns a fresh byte sequence of length n, with character i initialized to the result of f i (in increasing index order).

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_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 byte sequence 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 len reads up to len bytes from the given input, storing them in byte sequence s, starting at position p.

input [BatIO]

input i s p len reads up to len characters from the given input, storing them in byte sequence 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.Labels]
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.Labels]
insert [BatVect]

insert n r u returns a copy of the u vect where r has been inserted between the elements with index n - 1 and n in the original vect; after insertion, the first element of r (if any) is at index n.

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.

int32_of_big_int_opt [BatBig_int]

Convert a big integer to a 32-bit integer.

int32_set [BatteriesPrint]
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.

int64_of_big_int_opt [BatBig_int]

Convert a big integer to a 64-bit integer.

int64_set [BatteriesPrint]
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_big_int_opt [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_size [BatSys]

Size of an int.

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.

interleave [BatEnum]

interleave enums creates a new enumeration from an array of enumerations.

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_ascii [BatUChar]

true if the char is a regular ascii char, i.e.

is_bad [BatResult]

Same as is_error.

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]

is_empty (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 true iff dq has no elements.

is_empty [BatAvlTree]
is_error [BatResult]

is_error r is true iff r is Error _.

is_exn [BatResult]

is_exn e1 r is true iff r is Error e2 with e1=e2

is_finite [BatFloat]

is_finite f returns true if f is not nan or +/- infinity, false otherwise.

is_implicit [BatFilename]

Return true if the file name is relative and does not start with an explicit reference to the current directory (./ or ../ in Unix), false if it starts with an explicit reference to the root directory or the current directory.

is_inet6_addr [BatUnix]

Whether the given inet_addr is an IPv6 address.

is_inline [BatPrintexc.Slot]

is_inline slot is true when slot refers to a call that got inlined by the compiler, and false when it comes from any other context.

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_left [BatEither]

is_left (Left v) is true, is_left (Right v) is false.

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_raise [BatPrintexc.Slot]

is_raise slot is true when slot refers to a raising point in the code, and false when it comes from a simple function call.

is_relative [BatPathGen.PathType]
is_relative [BatFilename]

Return true if the file name is relative to the current directory, false if it is absolute (i.e.

is_right [BatEither]

is_right (Left v) is false, is_right (Right v) is true.

is_set [BatOptParse.Opt]

Find out if the option has a value (either by default or from the command line).

is_singleton [BatSet.PSet]

Test if the set is a singleton.

is_singleton [BatSet.S]

Test if the set is a singleton.

is_singleton [BatSet]

Test if the set is a singleton.

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.Labels]
iter [BatVect.Make]

iter f r applies f to all the elements in the r vect, in order.

iter [BatVect.Labels]
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 [BatResult]

iter f r is f v if r is Ok v and () otherwise.

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 [a0; a1; ...; an] applies function f in turn to a0; a1; ...; an.

iter [BatLazyList.Labels]
iter [BatLazyList]

Eager iteration

iter [BatInnerWeaktbl.S]
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]
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 [BatEither]

iter ~left ~right (Left v) is left v, and iter ~left ~right (Right v) is right v.

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 [BatBytes]

iter f s applies function f in turn to all the bytes of s.

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 [BatSeq]

iter2 f s1 s2 iterates on elements of s1 and s2 pairwise, and stops when it meets the end of s1 or s2

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 [BatDynArray]

iter2 f [a0, a1, ..., an] [b0, b1, ..., bn] performs calls f a0 b0, f a1 b1, ..., f an bn in that order.

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 [BatList]

List.iter2i f [a0; a1; ...; an] [b0; b1; ...; bn] calls in turn f 0 a0 b0; f 1 a1 b1; ...; f n an bn.

iter2i [BatEnum.Labels]
iter2i [BatEnum]
iter2i [BatDynArray]

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.

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_error [BatResult]

iter_error f r is f e if r is Error e and () otherwise.

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.Labels]
iteri [BatVect.Make]

Operates like iter, but also passes the index of the character to the given function.

iteri [BatVect.Labels]
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 [BatSubstring]

Same as BatSubstring.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 [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 [BatSeq]

iteri f s is the same as iter f s, but f is given the index of each element (starting at 0).

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]

iteri 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 [BatBytes]

Same as Bytes.iter, but the function is applied to the index of the byte as first argument and the byte itself as second argument.

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 [BatResult]

join rr is r if rr is Ok r and rr if rr is Error _.

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
kahan_sum [BatList]

kahan_sum l returns a numerically-accurate sum of the floats of l.

kahan_sum [BatEnum]

kahan_sum l returns a numerically-accurate sum of the floats of l.

kahan_sum [BatDynArray]

kahan_sum l returns a numerically-accurate sum of the floats of l.

kahan_sum [BatArray]

kahan_sum l returns a numerically-accurate sum of the floats of l.

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]
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.Array0]

Return the kind of the given big array.

kind [BatBigarray.Genarray]

Return the kind of the given big array.

kind_size_in_bytes [BatBigarray]

kind_size_in_bytes k is the number of bytes used to store an element of type k.

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.Array0]

Return the layout of the given big array.

layout [BatBigarray.Genarray]

Return the layout of the given big array.

lazy_fold_right [BatLazyList]

Lazy fold_right lazy_fold_right f (Cons (a0, Cons (a1, Cons (a2, nil)))) b is lazy (f a0 (lazy (f a1 (lazy (f a2 b))))).

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 [BatEither]

left v is Left v.

left [BatDynArray]

left r len returns the array 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.S]
length [BatInnerWeaktbl]

Weaktbl.length tbl returns the number of bindings in tbl.

length [BatHashtbl.Cap]
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 [BatBytes]

Return the length (number of t) of the argument.

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]

lines_of name reads the contents of file name as an enumeration of lines.

lines_of2 [BatIO]

Buffered version of BatIO.lines_of, for performance.

link [BatUnix]

link ?follow 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.

location [BatPrintexc.Slot]

location slot returns the location information of the slot, if available, and None otherwise.

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.

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 [BatBytes]

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_ascii [BatString]

Return a copy of the argument, with all uppercase letters translated to lowercase, using the US-ASCII character set.

lowercase_ascii [BatChar]

Convert the given character to its equivalent lowercase character, using the US-ASCII character set.

lowercase_ascii [BatBytes]

Return a copy of the argument, with all uppercase letters translated to lowercase, using the US-ASCII character set.

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 [BatTuple.Tuple5]
make [BatTuple.Tuple4]
make [BatTuple.Tuple3]
make [BatTuple.Tuple2]
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 [BatBytes]

make n c returns a new byte sequence of length n, filled with the byte c.

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_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_float [BatArray.Cap]

Array.make_float n returns a fresh float array of length n, with uninitialized data.

make_float [BatArray]

Array.make_float n returns a fresh float array of length n, with uninitialized data.

make_formatter [BatFormat]
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.Labels]
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.Labels]
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 [BatResult]

map f r is Ok (f v) if r is Ok v and r if r is Error _.

map [BatRefList]

Apply a function to all elements and return the ref list constructed with the function returned values

map [BatQueue]

map f q applies function f to each element of the queue and returns a new queue q' with the results returned by f.

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 vcompgen 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 [BatEither]

map ~left ~right (Left v) is Left (left v), map ~left ~right (Right v) is Right (right v).

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 replaced with f x.

map [BatBytes]

map f s applies function f in turn to all the bytes of s (in increasing index order) and stores the resulting bytes in a new sequence that is returned as the result.

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 [BatSeq]

map2 f s1 s2 returns a sequence of elements, resulting from combininig elements of s1 and s2 at the same index using f.

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]

map2 f [^ a0; a1; ...^] [^ b0; b1; ... ^] is [^ f a0 b0; f a1
    b1; ... ^]
.

map2 [BatDynArray]

As BatDynArray.map but on two arrays.

map2 [BatBounded.S]

map2 f x y applies f to x and y.

map2 [BatArray]

As Array.map but on two arrays.

map2_exn [BatBounded.S]

map2_exn f x y applies f to x and y.

map2i [BatList]

List.map2i f [a0; a1; ...; an] [b0; b1; ...; bn] is [f 0 a0 b0; f 1 a1 b1; ...; f n an bn].

map2i [BatDynArray]

As BatDynArray.mapi but on two arrays.

map3 [BatTuple.Tuple5]
map3 [BatTuple.Tuple4]
map3 [BatTuple.Tuple3]
map4 [BatTuple.Tuple5]
map4 [BatTuple.Tuple4]
map5 [BatTuple.Tuple5]
map_both [BatResult]

map_both f g (Ok x) returns Ok (f x) and map_both f g (Error e) returns Error (g e).

map_comp [BatOrd]
map_default [BatResult]

map_default d f r evaluates to d if r is Error 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_default_delayed [BatOption]

Like BatOption.map_default, but the default value is passed as a thunk that is only computed if needed.

map_endo [BatSet.PSet]

map f x creates a new set with elements f a0, f a1...

map_endo [BatSet]

map_endo f x creates a new set with elements f a0, f a1...

map_eq [BatOrd]
map_error [BatResult]

map_error f r is Error (f e) if r is Error e and r if r is Ok _.

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 [BatUnix]

Memory mapping of a file as a big array.

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_inplace [BatHashtbl.Cap.Labels]
map_inplace [BatHashtbl.Cap]
map_inplace [BatHashtbl.S.Labels]
map_inplace [BatHashtbl.S]
map_inplace [BatHashtbl.Labels]
map_inplace [BatHashtbl]

map_inplace f x replace all values currently bound in x by f applied to each value.

map_left [BatEither]

map_left f e is Left (f v) if e is Left v and e if e is Right _.

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_right [BatEither]

map_right f e is Right (f v) if e is Right v and e if e is Left _.

map_to_set [BatIMap]

map_to_set p t returns the set of keys of t where p evaluates as true

mapi [BatVect.Make.Labels]
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.Labels]
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 [BatString.Cap]
mapi [BatString]

String.mapi f s calls f with each character of s and its index (in increasing index order) and stores the results in a new string that is returned.

mapi [BatSeq]

mapi f s lazily maps elements of s into a new sequence, using f.

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]

mapi f dq returns a deque where every element x of dq has been replaced with f n x, where n is the position of x from the front of dq.

mapi [BatBytes]

mapi f s calls f with each character of s and its index (in increasing index order) and stores the resulting bytes in a new sequence that is returned as the result.

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 [BatNativeint]

Return the greater of the two.

max [BatList.Exceptionless]

max l returns either Some x where x is the largest value of the list as judged by Pervasives.compare (by default) or None is the list is empty.

max [BatList]

max l returns the largest value in l as judged by Pervasives.compare (by default).

max [BatInt64]

Return the greater of the two.

max [BatInt32]

Return the greater of the two.

max [BatInt]

The maximum of two integers.

max [BatFloat]
max [BatDynArray]

max a returns the largest value in a as judged by Pervasives.compare

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]

Return the (key, value) pair with the largest key.

max_binding_opt [BatMap.PMap]

Return Some (key, value) for the key, value pair with the largest key, or None if the map is empty.

max_binding_opt [BatMap.S]

Return Some (key, value) for the key, value pair with the largest key, or None if the map is empty.

max_binding_opt [BatMap]

Return Some (key, value) for the key, value pair with the largest key, or None if the map is empty.

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_elt_opt [BatSet.PSet]

Same as Set.S.min_elt_opt, but for the largest element of the given set.

max_elt_opt [BatSet.S]

Same as Set.S.min_elt_opt, but for the largest element of the given set.

max_elt_opt [BatSet]

Same as Set.S.min_elt_opt, but for the largest element of the given set.

max_floatarray_length [BatSys]

Maximum length of a floatarray.

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.Labels]
mem [BatVect.Make]

mem m a is true if and only if m is equal to an element of a.

mem [BatVect.Labels]
mem [BatVect]

mem a v is true if and only if a is equal to an element of v.

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.S]
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 [BatDynArray]

mem m a is true if and only if m is equal to an element of a.

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.

mem_cmp [BatList]

Same as List.mem, but the comparator function is explicitly provided.

memq [BatVect.Make.Labels]
memq [BatVect.Make]

Same as Vect.mem but uses physical equality instead of structural equality to compare vect elements.

memq [BatVect.Labels]
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 [BatDynArray]

Same as BatDynArray.mem but uses physical equality instead of structural equality to compare array elements.

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 containing all the elements of l1 and l2.

merge [BatIMap]
merge [BatHeap.H]
merge [BatHeap]

Merge two heaps.

merge [BatHashtbl.Cap.Labels]
merge [BatHashtbl.Cap]
merge [BatHashtbl.S.Labels]
merge [BatHashtbl.S]
merge [BatHashtbl.Labels]
merge [BatHashtbl]

merge f a b returns a new Hashtbl which is build from the bindings of a and b according to the function f, that is given all defined keys one by one, along with the value from a (if defined) and the value from b (if defined), and has to return the (optional) resulting value.

merge [BatEnum]

merge test a b merge the elements from a and b into a single enumeration.

merge_all [BatHashtbl.Cap.Labels]
merge_all [BatHashtbl.Cap]
merge_all [BatHashtbl.S.Labels]
merge_all [BatHashtbl.S]
merge_all [BatHashtbl.Labels]
merge_all [BatHashtbl]

merge_all f a b is similar to merge, but passes to f all bindings for a key (most recent first, as returned by find_all).

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 [BatNativeint]

Return the smaller of the two.

min [BatList.Exceptionless]

min l returns either Some x where x is the smallest value of the list as judged by Pervasives.compare or None is the list is empty.

min [BatList]

min l returns the smallest value in l as judged by Pervasives.compare (by default).

min [BatInt64]

Return the smaller of the two.

min [BatInt32]

Return the smaller of the two.

min [BatInt]

The minimum of two integers.

min [BatFloat]
min [BatDynArray]

min a returns the smallest value in a as judged by Pervasives.compare

min [BatArray]

min a returns the smallest value in a as judged by Pervasives.compare

min_big_int [BatBig_int]

Return the smaller of its two arguments.

min_binding [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_binding_opt [BatMap.PMap]

Return Some (key, value) for the key, value pair with the smallest key, or None if the map is empty.

min_binding_opt [BatMap.S]

Return Some (key, value) for the key, value pair with the smallest key, or None if the map is empty.

min_binding_opt [BatMap]

Return Some (key, value) for the key, value pair with the smallest key, or None if the map is empty.

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_elt_opt [BatSet.PSet]

Return Some e for the smallest element e of the given set (with respect to the Ord.compare ordering).

min_elt_opt [BatSet.S]

Return Some e for the smallest element e of the given set (with respect to the Ord.compare ordering).

min_elt_opt [BatSet]

Return Some e for the smallest element e of the given set (with respect to the Ord.compare ordering).

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_max [BatList.Exceptionless]

min_max l returns either Some(s, l) where s and l are respectively the smallest and biggest element of l as judged by Pervasives.compare (by default) or None if l is empty.

min_max [BatList]

min_max l returns the pair (smallest, largest) from l as judged by Pervasives.compare (by default).

min_max [BatDynArray]

min_max a returns the (smallest, largest) pair of values from a as judged by Pervasives.compare

min_max [BatArray]

min_max a returns the (smallest, largest) pair of values from a as judged by Pervasives.compare

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.

minor_words [BatGc]

Number of words allocated in the minor heap since the program was started.

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.

mkdir [BatSys]

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.Labels]
modify [BatVect.Make]

modify v n f is equivalent to set v n (f (get v n)), but more efficient.

modify [BatVect.Labels]
modify [BatVect]

modify v n f is equivalent to set v n (f (get v n)), but more efficient.

modify [BatMultiPMap]

modify x f m replaces the binding for x with f applied to these values.

modify [BatMultiMap]

modify x f m replaces the binding for x with f applied to these values.

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 [BatList]

modify a f l returns the same list as l but with value b associated to key a replaced with f b.

modify [BatIMap]

modify x f t replaces the y that is bound to x in t by f y.

modify [BatHashtbl.Cap.Exceptionless]
modify [BatHashtbl.S.Labels]
modify [BatHashtbl.S.Exceptionless]
modify [BatHashtbl.S]
modify [BatHashtbl.Labels]
modify [BatHashtbl.Exceptionless]
modify [BatHashtbl]

Hashtbl.modify k f tbl replaces the first binding for k in tbl with f applied to that value.

modify [BatDynArray]

modify f a replaces every element x of a with f x.

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_at [BatList]

modify_at n f l returns the same list as l but with nth-value a replaced with f a.

modify_def [BatMultiPMap]

modify_def dfl x f m performs as modify x f m but it adds f dfl in m instead of raising Not_found if x was unbound.

modify_def [BatMultiMap]

modify_def dfl x f m performs as modify x f m but it adds f dfl in m instead of raising Not_found if x was unbound.

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.

modify_def [BatList]

modify_def dfl a f l performs as modify a f l except that it add an association from a to f dfl instead of raising Not_found.

modify_def [BatIMap]

modify_def dft x f t does the same as modify x f t but binds x to f dft if x was not bound.

modify_def [BatHashtbl.S.Labels]
modify_def [BatHashtbl.S]
modify_def [BatHashtbl.Labels]
modify_def [BatHashtbl]

Hashtbl.modify_def v k f tbl does the same as Hashtbl.modify k f tbl but f v is inserted in tbl if k was unbound.

modify_opt [BatMultiPMap]

modify_opt x f m allows to modify the bindings for k in m or absence thereof.

modify_opt [BatMultiMap]

modify_opt x f m allows to modify the bindings for k in m or absence thereof.

modify_opt [BatMap.PMap]

modify_opt k f m allow to modify the binding for k in m or absence thereof.

modify_opt [BatMap.S]

modify_opt k f m allows to modify the binding for k in m or absence thereof.

modify_opt [BatMap]

modify_opt k f m allow to modify the binding for k in m or absence thereof.

modify_opt [BatList]

modify_opt a f l allows to modify the binding for a in l or absence thereof.

modify_opt [BatIMap]

modify_opt x f t allows to modify the binding for x in t or absence thereof.

modify_opt [BatHashtbl.S.Labels]
modify_opt [BatHashtbl.S]
modify_opt [BatHashtbl.Labels]
modify_opt [BatHashtbl]

Hashtbl.modify_opt k f tbl allows to remove, modify or add a binding for k in tbl.

modify_opt_at [BatList]

modify_opt_at n f l returns the same list as l but with nth-value a removed if f a is None, and replaced by v if it is Some v.

modifyi [BatDynArray]

Same as BatDynArray.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.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 [BatPrintexc.Slot]

name slot returns the name of the function or definition enclosing the location referred to by the slot.

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.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.

nat_of_num [BatNum]

Coercions between numerical types

natint_set [BatteriesPrint]
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.

nativeint_of_big_int_opt [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.

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]

Compute and return the first node from the list as a Cons.

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).

nsplit [BatList]

nsplit, applied to a predicate p and a list xs, returns a list of lists.

ntake [BatList]

ntake n l cuts l into lists of size at most n.

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.

nth_opt [BatList]

Return the n-th element of the given list.

null [BatFilename]

null is "/dev/null" on POSIX and "NUL" on Windows.

null_formatter [BatLogger]

null_formatter is a formatter that does not output any events, but simply discards them.

null_tracker [BatGc.Memprof]

Default callbacks simply return None or ()

num_bits_big_int [BatBig_int]

Return the number of significant bits in the absolute value of the given big integer.

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.

nwrite_bytes [BatInnerIO]

Write a byte sequence to an output.

O
ocaml_version [BatSys]

ocaml_version is the version of OCaml.

of_abstr [BatConcreteQueue]
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 [BatSet.PSet]

builds a set from the given array and comparison function

of_array [BatSet.S]

builds a set from the given array.

of_array [BatSet]

builds a set from the given array, using the default comparison function

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_backwards 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_bytes [BatString.Cap]

Adopt a regular byte sequence.

of_bytes [BatString]

Return a new string that contains the same bytes as the given byte sequence.

of_bytes [BatStream]

Return the stream of the characters of the bytes parameter.

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 [BatText]

converts the enumeration into a rope

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 [BatIMap]

of_enum e returns the set of given ranges

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 [BatBigarray.Array1]

Array1.of_enum kind layout enum returns a new one-dimensional big array of kind kind and layout layout, with elements taken from the enumeration enum in order.

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_float_string [BatNum]

Convert a simple floating point literal to a num.

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.S]

builds a set from the given list.

of_list [BatSet]

builds a set from the given list, using the default comparison function

of_list [BatSeq]

Convenience function to build a seq from a list.

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 [BatHashtbl.Cap]
of_list [BatHashtbl.S]
of_list [BatHashtbl]

Create a hashtable from a list of (key,value) pairs.

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_seq [BatString]

Create a string from the generator

of_seq [BatSet.PSet]

build a set from the given elements

of_seq [BatSet.S]

build a set from the given elements

of_seq [BatSet]

build a set from the given elements

of_seq [BatQueue]

Create a queue from the generator

of_seq [BatMap.PMap]

build a map from the given bindings

of_seq [BatMap.S]

build a map from the given bindings

of_seq [BatMap]

build a map from the given bindings

of_seq [BatList]

Create a list from the iterator

of_seq [BatBytes]

Create a string from the generator

of_seq [BatBuffer]

Create a buffer from the generator

of_seq [BatArray]
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 byte sequence.

of_string [BatStream]

Return the stream of the characters of the string parameter.

of_string [BatSeq]

Create a sequence by parsing a string.

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 [BatBytes]

Return a new byte sequence that contains the same bytes as the given string.

of_string [BatBool]

Convert the given string to a boolean.

of_string [BatBig_int]
of_string_opt [BatNativeint]

Same as of_string, but return None instead of raising.

of_string_opt [BatInt64]

Same as of_string, but return None instead of raising.

of_string_opt [BatInt32]

Same as of_string, but return None instead of raising.

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.

of_value [BatBigarray.Array0]

Build a zero-dimensional big array initialized from the given value.

oget_exn [BatRef]

Get a value from an option ref;

ok [BatResult]

ok v is Ok v.

ok [BatPervasives]

f x |> ok unwraps the Ok result of f x and returns it, or throws the exception contained if Error 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_map [BatSet.Incubator]

Order Preserving map; as map, but f must be order preserving; i.e.

op_start [BatGenlex.Languages.Definition]
opaque_identity [BatSys]

For the purposes of optimization, opaque_identity behaves like an unknown (and thus possibly side-effecting) function.

opaque_identity [BatOpaqueInnerSys]
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_gen 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_args [BatUnix]

Same as Unix.open_process_args_out, but redirects both the standard input and standard output of the command to pipes connected to the two returned channels.

open_process_args_full [BatUnix]

Similar to Unix.open_process_args, but the third argument specifies the environment passed to the command.

open_process_args_in [BatUnix]

High-level pipe and process management.

open_process_args_out [BatUnix]

Same as Unix.open_process_args_in, but redirect the standard input of the command to a pipe.

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_temp_file [BatFilename]

Same as Filename.temp_file, but returns both the name of a fresh temporary file, and an output channel opened (atomically) on this file.

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 [BatInt32]
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 [BatOption]

Comparison between optional values

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 integer.

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 byte sequence 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]

Set this ref to the output you want logging messages to go to.

output [BatLog]

This ref holds the output channel for simple logging.

output [BatInnerIO]

output o s p len writes up to len characters from byte sequence len, starting at offset p.

output [BatIO]

output o s p len writes up to len characters from byte sequence 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_substring [BatPervasives]

output_substring oc buf pos len writes len characters from string buf, starting at offset pos, to the given output channel oc.

output_substring [BatInnerIO]

like output above, but outputs from a substring instead of a subsequence of bytes

output_substring [BatIO]

like output above, but outputs from a substring instead of a subsequence of bytes

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 s off i writes the little endian bit representation of i into byte sequence s at offset off

pack_big [BatInt32]

pack_big s off i writes the big endian bit representation of i into byte sequence s at offset off

parent [BatPathGen.PathType]

Returns parent path, i.e.

parent_dir_name [BatFilename]

The conventional name for the parent of the current directory (e.g.

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.Labels]
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.Labels]
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 [BatDynArray]

partition p a returns a pair of arrays (a1, a2), where a1 is the array of all the elements of a that satisfy the predicate p, and a2 is the array of all the elements of a that do not satisfy p.

partition [BatArray.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.

partition_map [BatList.Labels]
partition_map [BatList]

partition_map f l returns a pair of lists (l1, l2) such that, for each element x of the input list l: if f x is Left y1, then y1 is in l1, and, if f x is Right y2, then y2 is in l2. The output elements are included in l1 and l2 in the same relative order as the corresponding input elements in l. In particular, partition_map (fun x -> if f x then Left x else Right x) l is equivalent to partition f l.

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.

peek_opt [BatQueue]

peek_opt q returns the first element in queue q, without removing it from the queue, or returns None if the queue is empty.

perm [BatFile]

Join permissions

permutations [BatLazyList]

permutations l yields a lazy list of all permutations of the list l.

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 output.

pipe [BatIO]

Create a pipe between an input and an output.

pivot_split [BatArray.Cap]
pivot_split [BatArray]

pivot_split cmp arr x assumes that arr is sorted w.r.t cmp.

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.

pop_max [BatSet.PSet]

Returns the biggest element of the given set along with the rest of the set.

pop_max [BatSet.S]

Returns the biggest element of the given set along with the rest of the set.

pop_max [BatSet]

Returns the biggest element of the given set along with the rest of the set.

pop_max_binding [BatMap.PMap]

Return the binding with the largest key along with the rest of the map.

pop_max_binding [BatMap.S]

Return the (key, value) pair with the largest key along with the rest of the map.

pop_max_binding [BatMap]

Returns the binding with the largest key along with the rest of the map.

pop_min [BatSet.PSet]

Returns the smallest element of the given set along with the rest of the set.

pop_min [BatSet.S]

Returns the smallest element of the given set along with the rest of the set.

pop_min [BatSet]

Returns the smallest element of the given set along with the rest of the set.

pop_min_binding [BatMap.PMap]

Return the binding with the smallest key along with the rest of the map.

pop_min_binding [BatMap.S]

Return the (key, value) pair with the smallest key along with the rest of the map.

pop_min_binding [BatMap]

Returns the binding with the smallest key along with the rest of the map.

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]
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_list [BatFormat]

pp_print_list ?pp_sep pp_v ppf l prints the list l.

pp_print_newline [BatFormat]
pp_print_space [BatFormat]
pp_print_string [BatFormat]
pp_print_tab [BatFormat]
pp_print_tbreak [BatFormat]
pp_print_text [BatFormat]

pp_print_text ppf s prints s with spaces and newlines respectively printed with BatFormat.pp_print_space and BatFormat.pp_force_newline.

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]

Subtract 1. from a floating number.

pred [BatFloat]

Subtract 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]

prepend_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 Error(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]

prints as decimal string

print [BatInt32]

prints as decimal string

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 preceding 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_at_most [BatEnum]

print_at_most pp limit out enum consumes enum to print its elements into out (using pp to print individual elements).

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 [BatInt32]

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_raw_backtrace [BatPrintexc]

Print a raw backtrace in the same format Printexc.print_backtrace uses.

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_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]
process_full_pid [BatUnix]

Return the pid of a process opened via Unix.open_process_full or Unix.open_process_args_full.

process_in_pid [BatUnix]

Return the pid of a process opened via Unix.open_process_in or Unix.open_process_args_in.

process_out_pid [BatUnix]

Return the pid of a process opened via Unix.open_process_out or Unix.open_process_args_out.

process_pid [BatUnix]

Return the pid of a process opened via Unix.open_process or Unix.open_process_args.

progress_in [BatIO]

progress_in inp f create an input that calls f () whenever some content is successfully read from it.

progress_out [BatIO]

progress_out out f create an output that calls f () whenever some content is successfully written to it.

promote [BatDllist]

promote n Swaps n with next n.

protect [BatRef]

Assign a reference temporarily.

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.

quote [BatFilename]

Return a quoted version of a file name, suitable for use as one argument in a command line, escaping all meta-characters.

quote_command [BatFilename]

quote_command cmd args returns a quoted command line, suitable for use as an argument to Sys.command, Unix.system, and the Unix.open_process functions.

R
raise_with_backtrace [BatPrintexc]

Reraise the exception using the given raw_backtrace for the origin of the exception

range [BatParserCo]

Accept any element from a given range.

range [BatList]

range 1 `To 3 = [1; 2; 3].

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 [BatDynArray]

range a returns an enumeration of all valid indices of the given array, that is, range a = 0 --^ ((length a) -1 )

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]

range_iter 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.Labels]
rangeiter [BatVect.Make]

rangeiter f m n r applies f to all the elements whose indices k satisfy m <= k < m + n.

rangeiter [BatVect.Labels]
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]
raw_backtrace_entries [BatPrintexc]
raw_backtrace_length [BatPrintexc]

raw_backtrace_length bckt returns the number of slots in the backtrace bckt.

raw_backtrace_to_string [BatPrintexc]

Return a string from a raw backtrace, in the same format Printexc.get_backtrace uses.

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 (included).

rcontains_from [BatString.Cap]
rcontains_from [BatString]

String.rcontains_from s stop c tests if character c appears in s before position stop+1.

rcontains_from [BatBytes]

rcontains_from s stop c tests if byte 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 byte sequence buf, starting at character number pos.

really_input [BatInnerIO]

really_input i s p len reads exactly len characters from the given input, storing them in the byte sequence s, starting at position p.

really_input [BatIO]

really_input ic s p len reads exactly len characters from the input ic, 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 len writes exactly len characters from byte sequence s onto the the output, starting with the character at offset p.

really_output [BatIO]

really_output o s p len writes exactly len characters from byte sequence s onto the the output, starting with the character at offset p.

really_output_substring [BatInnerIO]

like really_output above, but outputs from a substring instead of a subsequence of bytes

really_output_substring [BatIO]

like really_output above, but outputs from a substring instead of a subsequence of bytes

realpath [BatUnix]

realpath p is an absolute pathname for p obtained by resolving all extra / characters, relative path segments and symbolic links.

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_exn 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.Labels]
reduce [BatVect.Make]

as fold_left, but no initial value - just applies reducing function to elements from left to right.

reduce [BatVect.Labels]
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.Exceptionless]

reduce f h::t is Some (fold_left f h t) and reduce f [] is None.

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 [BatDynArray]

reduce f a is fold_left f a0 [a1, ... aN].

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.Labels]
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.Labels]
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.S]
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_such f l is similar to remove but removes all elements that satisfy the predicate f 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_at [BatList]

remove_at i l returns the list l without the element at index i.

remove_at [BatDynArray]

Alias for delete with parameter order that follows Array.remove_at.

remove_at [BatArray]

remove_at i a returns the array a without the element at index i.

remove_exn [BatSet.PSet]

remove_exn x s behaves like remove x s except that it raises an exception if x is not in s.

remove_exn [BatSet.S]

remove_exn x s behaves like remove x s except that it raises an exception if x is not in s.

remove_exn [BatSet]

remove_exn x s behaves like remove x s except that it raises an exception if x is not in s.

remove_exn [BatMap.PMap]

remove_exn x m behaves like remove x m except that it raises an exception if x is unbound in m.

remove_exn [BatMap.S]

remove_exn x m behaves like remove x m except that it raises an exception if x is unbound in m.

remove_exn [BatMap]

remove_exn x m behaves like remove x m except that it raises an exception if x is unbound in m.

remove_extension [BatFilename]

Return the given file name without its extension, as defined in Filename.extension.

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.S]
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 [BatInnerWeaktbl.S]
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_0 [BatBigarray]

Specialized version of Bigarray.reshape for reshaping to zero-dimensional arrays.

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 [BatSeq]

the singleton sequence, containing only the given element

return [BatReturn]

Return to a label.

return [BatResult.Monad]

Monadic return, just encapsulates the given value with Ok

return [BatParserCo]

A parser which always succeeds

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 [BatString]

rev s returns the reverse of string s

rev [BatRefList]

Reverses the ref list - O(n)

rev [BatOrd]

Reverse a given ordering.

rev [BatList]

List reversal.

rev [BatLazyList]

Eager list reversal.

rev [BatDynArray]

Array 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 [BatString]

rev_in_place s mutates the byte sequence 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".

rev_in_place [BatDynArray]

In-place array reversal.

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]

rfind_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]

rfindi 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]

rfindi 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]

right r len returns the string containing the len last characters of r.

right [BatEither]

right v is Right v.

right [BatDynArray]

right r len returns the array 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 occurrence 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 [BatBytes]

rindex s c returns the index of the last occurrence of byte c in s.

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 occurrence 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_from [BatBytes]

rindex_from s i c returns the index of the last occurrence of byte c in s before position i+1.

rindex_from_opt [BatString]

String.rindex_from_opt s i c returns the index of the last occurrence of character c in string s before position i+1 or None if c does not occur in s before position i+1.

rindex_from_opt [BatBytes]

rindex_from_opt s i c returns the index of the last occurrence of byte c in s before position i+1 or None if c does not occur in 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

rindex_opt [BatString]

String.rindex_opt s c returns the index of the last occurrence of character c in string s, or None if c does not occur in s.

rindex_opt [BatBytes]

rindex_opt s c returns the index of the last occurrence of byte c in s or None if c does not occur in s.

rmdir [BatUnix]

Remove an empty directory.

rmdir [BatSys]

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]
rotate_backward [BatDeque]

A cyclic shift of deque elements from front to rear by one position.

rotate_forward [BatDeque]

A cyclic shift of deque elements from rear to front by one position.

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 occurrence (excluded).

run [BatParserCo]

run p s executes parser p on source s.

run_and_read [BatUnix]

(stat, output) = run_and_read cmd run the command cmd (via Unix.system) then return its exit status stat and output string output as read from its standard output (which was redirected to a temporary file).

runtime_parameters [BatSys]

Return the value of the runtime parameters, in the same format as the contents of the OCAMLRUNPARAM environment variable.

runtime_variant [BatSys]

Return the name of the runtime variant the program is running on.

runtime_warnings_enabled [BatSys]

Return whether runtime warnings are currently enabled.

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_substring [BatUnix]

Same as send, but take the data from a string instead of a byte sequence.

sendto [BatUnix]

Send data over an unconnected socket.

sendto_substring [BatUnix]

Same as sendto, but take the data from a string instead of a byte sequence.

seq [BatLazyList]

seq data next cond creates a lazy list from the successive results of applying next to data, then to the result, etc.

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 'BatEnum.t m.

set [BatVect.RANDOMACCESS]
set [BatVect.Make.Labels]
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.Labels]
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 [BatBytes]

set s n c modifies s in place, replacing the byte at index n with c.

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.Array0]

Array0.set a x v stores the value v 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_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_filename [BatLexing]

Set filename in the initial tracked position to file in lexbuf.

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_tag_functions [BatFormat]
set_full_state [BatParserCo.Source]
set_int16_be [BatBytes]

set_int16_be b i v sets b's big-endian signed 16-bit integer starting at byte index i to v.

set_int16_le [BatBytes]

set_int16_le b i v sets b's little-endian signed 16-bit integer starting at byte index i to v.

set_int16_ne [BatBytes]

set_int16_ne b i v sets b's native-endian signed 16-bit integer starting at byte index i to v.

set_int32_be [BatBytes]

set_int32_be b i v sets b's big-endian 32-bit integer starting at byte index i to v.

set_int32_le [BatBytes]

set_int32_le b i v sets b's little-endian 32-bit integer starting at byte index i to v.

set_int32_ne [BatBytes]

set_int32_ne b i v sets b's native-endian 32-bit integer starting at byte index i to v.

set_int64_be [BatBytes]

set_int64_be b i v sets b's big-endian 64-bit integer starting at byte index i to v.

set_int64_le [BatBytes]

set_int64_le b i v sets b's little-endian 64-bit integer starting at byte index i to v.

set_int64_ne [BatBytes]

set_int64_ne b i v sets b's native-endian 64-bit integer starting at byte index i to v.

set_int8 [BatBytes]

set_int8 b i v sets b's signed 8-bit integer starting at byte index i to v.

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_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_nonblock [BatUnix]

Set the ``non-blocking'' flag on the given descriptor.

set_permissions [BatFile]

Set the permissions on a file.

set_position [BatLexing]

Set the initial tracked input position for lexbuf to a custom value.

set_print_tags [BatFormat]

set_print_tags b turns on or off the printing of tags.

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_temp_dir_name [BatFilename]

Change the temporary directory returned by Filename.get_temp_dir_name and used by Filename.temp_file and Filename.open_temp_file.

set_to_map [BatIMap]

set_to_map s x returns a map where every element of s is bound to x.

set_uint16_be [BatBytes]

set_uint16_be b i v sets b's big-endian unsigned 16-bit integer starting at byte index i to v.

set_uint16_le [BatBytes]

set_uint16_le b i v sets b's little-endian unsigned 16-bit integer starting at byte index i to v.

set_uint16_ne [BatBytes]

set_uint16_ne b i v sets b's native-endian unsigned 16-bit integer starting at byte index i to v.

set_uint8 [BatBytes]

set_uint8 b i v sets b's unsigned 8-bit integer starting at byte index i to v.

set_uncaught_exception_handler [BatPrintexc]

Printexc.set_uncaught_exception_handler fn registers fn as the handler for uncaught exceptions.

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.

shuffle [BatList]

shuffle ~state:rs l randomly shuffles the elements of l.

shuffle [BatArray]

shuffle ~state:rs a randomly shuffles in place the elements of a.

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

sigbus [BatSys]

Bus error

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

sigpoll [BatSys]

Pollable event

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.

sigsys [BatSys]

Bad argument to routine

sigterm [BatSys]

Termination

sigtrap [BatSys]

Trace/breakpoint trap

sigtstp [BatSys]

Interactive stop

sigttin [BatSys]

Terminal read from background process

sigttou [BatSys]

Terminal write from background process

sigurg [BatSys]

Urgent condition on socket

sigusr1 [BatSys]

Application-defined signal 1

sigusr2 [BatSys]

Application-defined signal 2

sigvtalrm [BatSys]

Timeout in virtual time

sigxcpu [BatSys]

Timeout in cpu time

sigxfsz [BatSys]

File size limit exceeded

sin [BatFloat.Safe_float]
sin [BatFloat]
single_write [BatUnix]

Same as write, but attempts to write only once.

single_write_substring [BatUnix]

Same as single_write, but take the data from a string instead of a byte sequence.

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 [BatList]

Create a list consisting of exactly one element.

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 of exactly one element.

singleton [BatDynArray]

Create an array consisting of exactly one element.

singleton [BatArray]

Create an array consisting of 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_in_bytes [BatBigarray.Array3]

size_in_bytes a is the number of elements in a multiplied by a's BatBigarray.kind_size_in_bytes.

size_in_bytes [BatBigarray.Array2]

size_in_bytes a is the number of elements in a multiplied by a's BatBigarray.kind_size_in_bytes.

size_in_bytes [BatBigarray.Array1]

size_in_bytes a is the number of elements in a multiplied by a's BatBigarray.kind_size_in_bytes.

size_in_bytes [BatBigarray.Array0]

size_in_bytes a is a's BatBigarray.kind_size_in_bytes.

size_in_bytes [BatBigarray.Genarray]

size_in_bytes a is the number of elements in a multiplied by a's BatBigarray.kind_size_in_bytes.

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.

sleepf [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 [BatBigarray.Array1]

Extract a scalar (zero-dimensional slice) of the given one-dimensional big array.

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.

some [BatOption]

some x returns Some x.

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_uniq [BatList]

sort_uniq cmp l returns the list l sorted and without any duplicate element.

sort_unique [BatList]

synonym for sort_uniq

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 [BatList]

span, applied to a predicate p and a list xs, returns a tuple where first element is longest prefix (possibly empty) of xs of elements that satisfy p and second element is the remainder of the list.

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 occurrence (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 satisfies p, and t2 is the rest of t.

split [BatDynArray]

split a converts the array of pairs a into a pair of arrays.

split [BatArray.Cap]
split [BatArray]

Array.split a converts the array of pairs a into a pair of arrays.

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_extension [BatFilename]

split_extension s returns both the filename s without its extension and its extension in two distinct strings.

split_le [BatSet.PSet]

split_le x s returns a pair of sets (l, r), such that l is the subset of s with elements <= x; r is the subset of s with elements > x.

split_le [BatSet.S]

split_le x s returns a pair of sets (l, r), such that l is the subset of s with elements <= x; r is the subset of s with elements > x.

split_le [BatSet]

split_le x s returns a pair of sets (l, r), such that l is the subset of s with elements <= x; r is the subset of s with elements > x.

split_leftmost [BatAvlTree]
split_lt [BatSet.PSet]

split_lt x s returns a pair of sets (l, r), such that l is the subset of s with elements < x; r is the subset of s with elements >= x.

split_lt [BatSet.S]

split_lt x s returns a pair of sets (l, r), such that l is the subset of s with elements < x; r is the subset of s with elements >= x.

split_lt [BatSet]

split_lt x s returns a pair of sets (l, r), such that l is the subset of s with elements < x; r is the subset of s with elements >= x.

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_char [BatString]

String.split_on_char sep s returns the list of all (possibly empty) substrings of s that are delimited by the sep character.

split_on_char [BatBytes]

split_on_char sep s returns the list of all (possibly empty) subsequences of s that are delimited by the sep character.

split_on_comma [BatSubstring]
split_on_dot [BatSubstring]
split_on_pipe [BatSubstring]
split_on_slash [BatSubstring]
split_on_string [BatString]

split_on_string sep s splits the string s into a list of strings which are separated by sep (excluded).

split_opt [BatSet.PSet]

split_opt x s returns a triple (l, maybe_v, 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; maybe_v is None if s contains no element equal to x, or Some v if s contains an element v that compares equal to x.

split_opt [BatSet.S]

split_opt x s returns a triple (l, maybe_v, 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; maybe_v is None if s contains no element equal to x, or Some v if s contains an element v that compares equal to x.

split_opt [BatSet]

split_opt x s returns a triple (l, maybe_v, 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; maybe_v is None if s contains no element equal to x, or Some v if s contains an element v that compares equal to x.

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

start [BatGc.Memprof]

Start the sampling with the given parameters.

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.

starts_with [BatBytes]

starts_with ~prefix s is true if and only if s starts with prefix.

starts_with_stdlib [BatString]

Equivalent to starts_with but the prefix is a labelled parameter.

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 [BatInnerWeaktbl.S]
stats [BatHashtbl.Cap]
stats [BatHashtbl.S]
stats [BatHashtbl]

Hashtbl.stats tbl returns statistics about the table tbl: number of buckets, size of the biggest bucket, distribution of buckets by size.

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.

stop [BatGc.Memprof]

Stop the sampling.

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_init [BatBytesCompat]
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_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.Labels]
sub [BatVect.Make]

sub r m n returns a sub-vect of r containing all the elements whose indexes range from m to m + n - 1 (included).

sub [BatVect.Labels]
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]

Subtraction.

sub [BatInt]

Subtraction.

sub [BatFloat.Safe_float]
sub [BatFloat]
sub [BatDynArray]

sub a start len returns an array holding the subset of len elements from a starting with the element at index idx.

sub [BatComplex]

Subtraction

sub [BatBytes]

sub s start len returns a new byte sequence of length len, containing the subsequence of s that starts at position start and has length len.

sub [BatBuffer]

Buffer.sub b off len returns a copy of len bytes from the current contents of the buffer b, starting at offset off.

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.

sub_string [BatBytes]

Same as sub but return a string instead of a byte sequence.

subbytes [BatDigest]

Digest.subbytes s ofs len returns the digest of the subsequence of s starting at index ofs and containing len bytes.

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 [BatList.Labels]
subset [BatList]

subset cmp l l' check if all elements of the list l is contained in the list l' by applying cmp as comparator.

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 [BatDynArray]

sum l returns the sum of the integers of l.

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]

Symbolic links

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 [BatDynArray]

tail r pos returns the array containing all but the pos first characters of r.

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_opt [BatQueue]

take_opt q removes and returns the first element in queue q, or returns None if the queue is empty.

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

takedrop [BatList]

takedrop n l is equivalent to (take n l, drop n l) but is done in one pass.

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.

temp_dir_name [BatFilename]

The name of the initial temporary directory: Under Unix, the value of the TMPDIR environment variable, or "/tmp" if the variable is not set.

temp_file [BatFilename]

temp_file prefix suffix returns the name of a fresh temporary file in the temporary directory.

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_abstr [BatConcreteQueue]
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 [BatSet.PSet]

Same as to_list but with an array instead of a list.

to_array [BatSet.S]

Same as to_list but with an array instead of a list.

to_array [BatSet]

Same as to_list but with an array instead of a list.

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 [BatSeq]

Convert a sequence to a string in the given buffer; eager.

to_buffer [BatMarshal]

Marshal.to_buffer buff ofs len v flags marshals the value v, storing its byte representation in the sequence buff, starting at index ofs, and writing at most len bytes.

to_byte [BatInt32]
to_bytes [BatString.Cap]

Return a capability string as a regular byte sequence.

to_bytes [BatString]

Return a new byte sequence that contains the same bytes as the given string.

to_bytes [BatMarshal]

Marshal.to_bytes v flags returns a byte sequence containing the representation of v.

to_bytes [BatBuffer]

Return a copy of the current contents of the buffer.

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 [BatSet.PSet]

Alias for elements.

to_list [BatSet.S]

Alias for elements.

to_list [BatSet]

Alias for elements.

to_list [BatResult]

to_list r is [v] if r is Ok v and [] otherwise.

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 [BatHashtbl.Cap]
to_list [BatHashtbl.S]
to_list [BatHashtbl]

Return the list of (key,value) pairs.

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]

to_option r is r as an option, mapping Ok v to Some v and Error _ to None.

to_rev_seq [BatSet.PSet]

Iterate on the whole set, in descending order.

to_rev_seq [BatSet.S]

Iterate on the whole set, in descending order.

to_rev_seq [BatSet]

Iterate on the whole set, in descending order.

to_rev_seq [BatMap.PMap]

Iterate on the whole map, in descending order of keys.

to_rev_seq [BatMap.S]

Iterate on the whole map, in descending order of keys.

to_rev_seq [BatMap]

Iterate on the whole map, in descending order of keys.

to_seq [BatString]

Iterate on the string, in increasing index order.

to_seq [BatSet.PSet]

Iterate on the whole set, in ascending order.

to_seq [BatSet.S]

Iterate on the whole set, in ascending order.

to_seq [BatSet]

Iterate on the whole set, in ascending order.

to_seq [BatResult]

to_seq r is r as a sequence.

to_seq [BatQueue]

Iterate on the queue, in front-to-back order.

to_seq [BatMap.PMap]

Iterate on the whole map, in ascending order of keys.

to_seq [BatMap.S]

Iterate on the whole map, in ascending order of keys.

to_seq [BatMap]

Iterate on the whole map, in ascending order of keys.

to_seq [BatList]

Iterate on the list

to_seq [BatBytes]

Iterate on the string, in increasing index order.

to_seq [BatBuffer]

Iterate on the buffer, in increasing order.

to_seq [BatArray]
to_seq_from [BatSet.PSet]

to_seq_from x s iterates on a subset of the elements in s, namely those greater or equal to x, in ascending order.

to_seq_from [BatSet.S]

to_seq_from x s iterates on a subset of the elements in s, namely those greater or equal to x, in ascending order.

to_seq_from [BatSet]

to_seq_from x s iterates on a subset of the elements in s, namely those greater or equal to x, in ascending order.

to_seq_from [BatMap.PMap]

to_seq_from k m iterates on a subset of the bindings in m, namely those bindings greater or equal to k, in ascending order.

to_seq_from [BatMap.S]

to_seq_from k m iterates on a subset of the bindings in m, namely those bindings greater or equal to k, in ascending order.

to_seq_from [BatMap]

to_seq_from k m iterates on a subset of the bindings in m, namely those bindings greater or equal to k, in ascending order.

to_seqi [BatString]

Iterate on the string, in increasing order, yielding indices along chars

to_seqi [BatBytes]

Iterate on the string, in increasing order, yielding indices along chars

to_seqi [BatBuffer]

Iterate on the buffer, in increasing order, yielding indices along chars.

to_seqi [BatArray]
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 byte sequence.

to_string [BatStream]

convert stream of chars to string, using buffer

to_string [BatSeq]

Convert the sequence to a string; eager.

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]

Same as to_bytes but return the result as a string instead of a byte sequence.

to_string [BatLog.Level_sig]

Convert each level to a string

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 [BatBytes]

Return a new string that contains the same bytes as the given byte sequence.

to_string [BatBool]
to_string [BatBig_int]
to_string_default [BatPrintexc]

Printexc.to_string_default e returns a string representation of the exception e, ignoring all registered exception printers.

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 (according to BatChar.is_whitespace).

trim [BatBytes]

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.

truncate [BatBuffer]

truncate b len truncates the length of b to len Note: the internal byte sequence is not shortened.

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.

uncapitalize [BatBytes]

Return a copy of the argument, with the first byte set to lowercase.

uncapitalize_ascii [BatString]

Return a copy of the argument, with the first character set to lowercase, using the US-ASCII character set.

uncapitalize_ascii [BatBytes]

Return a copy of the argument, with the first character set to lowercase, using the US-ASCII character set.

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 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 [BatSeq]

Build a sequence from a step function and an initial value.

unfold [BatList]

unfold init f creates a list by repeatedly applying f to the second element of its own result, starting from the initial value init.

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.

unfold_exc [BatList]

Alias for unfold_exn.

unfold_exn [BatList]

Creates a list containing the results of sequential calls to f().

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.S]

union f m1 m2 computes a map whose keys are a subset of the keys of m1 and of m2.

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.

union_stdlib [BatMap.PMap]

union f m1 m2 computes a map whose keys are a subset of the keys of m1 and of m2.

union_stdlib [BatMap]

union_stdlib f m1 m2 computes a map whose keys are a subset of the keys of m1 and of m2.

uniq [BatEnum.Labels]
uniq [BatEnum]

uniq e returns a duplicate of e with repeated values omitted (similar to unix's uniq command).

uniq_by [BatEnum]

uniq_by cmp e behaves as uniq e except it allows to specify a comparison function.

uniqq [BatEnum]

uniqq e behaves as uniq e except it uses physical equality to compare consecutive elements.

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 [BatSys]

True if Sys.os_type = "Unix".

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 s off reads 4 bytes from byte sequence str starting at offset off as a little-endian int32

unpack_big [BatInt32]

unpack s off reads 4 bytes from byte sequence str starting at offset off as a big-endian int32

unregister_formatter [BatLogger]

unregister_formatter name unregisters a named log formatter.

unsafe_environment [BatUnix]

Return the process environment, as an array of strings with the format ``variable=value''.

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_getenv [BatUnix]

Return the value associated to a variable in the process environment.

unsafe_of_string [BatBytes]

Unsafely convert a shared string to a byte sequence that should not be mutated.

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.

unsafe_substring [BatSubstring]

unsafe_substring behaves like substring, but does not perform any sanity check on the position and length.

unsafe_to_string [BatBytes]

Unsafely convert a byte sequence into a string.

unsafe_upd [BatDynArray]
unset [BatBitSet]

unset s n sets the nth-bit in the bitset s to false.

unsigned_compare [BatNativeint]

Same as BatNativeint.compare, except that arguments are interpreted as unsigned native integers.

unsigned_compare [BatInt64]

Same as BatInt64.compare, except that arguments are interpreted as unsigned 64-bit integers.

unsigned_compare [BatInt32]

Same as BatInt32.compare, except that arguments are interpreted as unsigned 32-bit integers.

unsigned_div [BatNativeint]

Same as BatNativeint.div, except that arguments and result are interpreted as unsigned native integers.

unsigned_div [BatInt64]

Same as BatInt64.div, except that arguments and result are interpreted as unsigned 64-bit integers.

unsigned_div [BatInt32]

Same as BatInt32.div, except that arguments and result are interpreted as unsigned 32-bit integers.

unsigned_rem [BatNativeint]

Same as BatNativeint.rem, except that arguments and result are interpreted as unsigned native integers.

unsigned_rem [BatInt64]

Same as BatInt64.rem, except that arguments and result are interpreted as unsigned 64-bit integers.

unsigned_rem [BatInt32]

Same as BatInt32.rem, except that arguments and result are interpreted as unsigned 32-bit integers.

unsigned_to_int [BatNativeint]

Same as BatNativeint.to_int, but interprets the argument as an unsigned integer.

unsigned_to_int [BatInt64]

Same as BatInt64.to_int, but interprets the argument as an unsigned integer.

unsigned_to_int [BatInt32]

Same as BatInt32.to_int, but interprets the argument as an unsigned integer.

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

upd [BatDynArray]

upd darr idx f sets the element of darr at index idx to value f (get darr idx)).

update [BatSet.PSet]

update x y s replace x by y in s.

update [BatSet.S]

update x y s replace x by y in s.

update [BatSet]

update x y s replace x by y in s.

update [BatMap.PMap]

update k1 k2 v2 m replace the previous binding of k1 in m by k2 associated to v2.

update [BatMap.S]

update k1 k2 v2 m replace the previous binding of k1 in m by k2 associated to v2.

update [BatMap]

update k1 k2 v2 m replace the previous binding of k1 in m by k2 associated to v2.

update [BatFingerTree]

update t i f returns t where the i-th element is now f (get i t).

update_stdlib [BatMap.PMap]

update_stdlib k f m returns a map containing the same bindings as m, except k has a new binding as determined by f: First, calculate y as f (find_opt k m).

update_stdlib [BatMap.S]

update_stdlib k f m returns a map containing the same bindings as m, except k has a new binding as determined by f: First, calculate y as f (find_opt k m).

update_stdlib [BatMap]

update_stdlib k f m returns a map containing the same bindings as m, except k has a new binding as determined by f: First, calculate y as f (find_opt k m).

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 [BatBytes]

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_ascii [BatString]

Return a copy of the argument, with all lowercase letters translated to uppercase, using the US-ASCII character set.

uppercase_ascii [BatChar]

Convert the given character to its equivalent uppercase character, using the US-ASCII character set.

uppercase_ascii [BatBytes]

Return a copy of the argument, with all lowercase letters translated to uppercase, using the US-ASCII character set.

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.

use_printers [BatPrintexc]

Printexc.use_printers e returns None if there are no registered printers and Some s with else as the resulting string otherwise.

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 [BatResult]

value r ~default is v if r is Ok v and default otherwise.

value_option [BatOptParse.Opt]

Make an option which takes a single argument.

values [BatMap.PMap]

Return an enumeration of all the values of a map.

values [BatMap.S]

Return an enumeration of all the values of a map.

values [BatMap]

Return an enumeration of all 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]
win32 [BatSys]

True if Sys.os_type = "Win32".

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_locked_file [BatUnix]

with_locked_file ~kind filename f puts a lock (using lockf) on the whole file named filename, calls f with the file descriptor, and returns its result after the file is unlocked.

with_log [BatLogger]

with_log logger level event_fun ?result body logs an event before and after calling body ().

with_positions [BatLexing]

Tell whether the lexer buffer keeps track of position fields lex_curr_p / lex_start_p, as determined by the corresponding optional argument for functions that create lexer buffers (whose default value is true).

with_temp_file [BatFilename]

with_temp_file prfx sfx f will execute f tmp_fn where tmp_fn = temp_file prfx sfx; tmp_fn will be removed prior to returning the result of f.

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 Error 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_substring [BatUnix]

Same as write, but take the data from a string instead of a byte sequence.

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.