# Index of values

( * ) [BatNum] |
( * ) [BatNativeint] |
( * ) [BatInt.Safe_int] | Multiplication.
( * ) [BatInt] | Multiplication.
( * ) [BatFloat.Safe_float] |
( * ) [BatFloat] |
( * ) [BatComplex] |
( * ) [BatBool] |
( * ) [BatNumber.Infix] |
( * ) [BatBig_int] |
( ** ) [BatNum] |
( ** ) [BatNativeint] |
( ** ) [BatInt.Safe_int] | `a ** b` computes ab
( ** ) [BatInt] | `a ** b` computes ab
( ** ) [BatFloat.Safe_float] |
( ** ) [BatFloat] |
( ** ) [BatComplex] |
( ** ) [BatBool] |
( ** ) [BatNumber.Infix] |
( ** ) [BatBig_int] |
( *** ) [BatStd] | Function pairing.
( *** ) [BatPervasives] | Function pairing.
( **/ ) [BatNum.Infix] |
( **> ) [BatPervasives] | Function application.
( */ ) [BatNum.Infix] |
( ~* ) [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`.
(&&&) [BatStd] | Applying two functions to the same argument.
(&&&) [BatPervasives] | Applying two functions to the same argument.
(&&) [BatBool] | The boolean ``and''.
(+) [BatNum] |
(+) [BatNativeint] |
(+) [BatInt.Safe_int] | Addition.
(+) [BatInt] | Addition.
(+) [BatFloat.Safe_float] |
(+) [BatFloat] |
(+) [BatComplex] |
(+) [BatBool] |
(+) [BatNumber.Infix] |
(+) [BatBig_int] |
(+/) [BatNum.Infix] |
(-) [BatNum] |
(-) [BatNativeint] |
(-) [BatInt.Safe_int] | Substraction.
(-) [BatInt] | Subtraction.
(-) [BatFloat.Safe_float] |
(-) [BatFloat] |
(-) [BatComplex] |
(-) [BatBool] |
(-) [BatNumber.Infix] |
(-) [BatBig_int] |
(--) [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] |
(---) [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] |
(--.) [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] |
(-->) [BatPMap.Infix] |
(-->) [BatMultiPMap.Infix] | `map-->key` returns the current binding of `key` in `map`.
(-->) [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`.
(-->) [BatIMap.Infix] | `map-->key` returns the current binding of `key` in `map`, or raises `Not_found` if no such binding exists.
(-->) [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.
(--^) [BatPervasives] | Enumerate numbers, without the right endpoint
(--^) [BatEnum.Infix] | As `(--)` but without the right endpoint
(--^) [BatEnum] |
(--~) [BatPervasives] | As ( -- ), but for characters.
(--~) [BatEnum.Infix] | As ( -- ), but for characters.
(--~) [BatEnum] |
(-/) [BatNum.Infix] |
(-|) [BatStd] | Function composition.
(-|) [BatPervasives] | Function composition.
(/) [BatNum] |
(/) [BatNativeint] |
(/) [BatInt.Safe_int] | Integer division.
(/) [BatInt] | Integer division.
(/) [BatFloat.Safe_float] |
(/) [BatFloat] |
(/) [BatComplex] |
(/) [BatBool] |
(/) [BatNumber.Infix] |
(/) [BatBig_int] |
(//) [BatPervasives] | Filtering (pronounce this operator name "such that").
(//) [BatNum.Infix] |
(//) [BatEnum.Infix] | Filtering (pronounce this operator name "such that").
(//) [BatEnum] |
(//@) [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`.
(/@) [BatPervasives] |
(/@) [BatEnum.Infix] |
(/@) [BatEnum] |
(:=) [BatRef] | `r := a` stores the value of `a` in reference `r`.
(<) [BatNum] |
(<) [BatNativeint] |
(<) [BatInt.Safe_int] | Comparaison: `a < b` is true if and only if `a` is strictly smaller than `b`.
(<) [BatInt] |
(<) [BatFloat.Safe_float] |
(<) [BatFloat] |
(<) [BatComplex] |
(<) [BatBool] |
(<) [BatNumber.Compare] |
(<) [BatBig_int] |
(<--) [BatPMap.Infix] |
(<--) [BatMultiPMap.Infix] | `map<--(key, value)` returns a map containing the same bindings as `map`, plus a binding of `key` to `value`.
(<--) [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`.
(<--) [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] |
(<=) [BatNum] |
(<=) [BatNativeint] |
(<=) [BatInt.Safe_int] | Comparaison: `a <= b` is true if and only if `a` is smaller or equalto `b`.
(<=) [BatInt] |
(<=) [BatFloat.Safe_float] |
(<=) [BatFloat] |
(<=) [BatComplex] |
(<=) [BatBool] |
(<=) [BatNumber.Compare] |
(<=) [BatBig_int] |
(<=/) [BatNum.Infix] |
(<=/) [BatNum] |
(<>) [BatNum] |
(<>) [BatNativeint] |
(<>) [BatInt.Safe_int] | Comparaison: `a <> b` is true if and only if `a` and `b` have different values.
(<>) [BatInt] |
(<>) [BatFloat.Safe_float] |
(<>) [BatFloat] |
(<>) [BatComplex] |
(<>) [BatBool] |
(<>) [BatNumber.Compare] |
(<>) [BatBig_int] |
(<>/) [BatNum.Infix] |
(<>/) [BatNum] |
(<|) [BatStd] | Function application.
(<|>) [BatParserCo.Infix] |
(<|>) [BatParserCo] | Accept one of two parsers
(=) [BatNum] |
(=) [BatNativeint] |
(=) [BatInt.Safe_int] | Comparaison: `a = b` if and only if `a` and `b` have the same value.
(=) [BatInt] |
(=) [BatFloat.Safe_float] |
(=) [BatFloat] |
(=) [BatComplex] |
(=) [BatBool] |
(=) [BatNumber.Compare] |
(=) [BatBig_int] |
(=/) [BatNum.Infix] |
(=/) [BatNum] |
(>) [BatNum] |
(>) [BatNativeint] |
(>) [BatInt.Safe_int] | Comparaison: `a > b` is true if and only if `a` is strictly greater than `b`.
(>) [BatInt] |
(>) [BatFloat.Safe_float] |
(>) [BatFloat] |
(>) [BatComplex] |
(>) [BatBool] |
(>) [BatNumber.Compare] |
(>) [BatBig_int] |
(>/) [BatNum.Infix] |
(>/) [BatNum] |
(>::) [BatParserCo.Infix] |
(>::) [BatParserCo] | As `cons`
(>=) [BatNum] |
(>=) [BatNativeint] |
(>=) [BatInt.Safe_int] | Comparaison: `a >= b` is true if and only if `a` is greater or equal to `b`.
(>=) [BatInt] |
(>=) [BatFloat.Safe_float] |
(>=) [BatFloat] |
(>=) [BatComplex] |
(>=) [BatBool] |
(>=) [BatNumber.Compare] |
(>=) [BatBig_int] |
(>=/) [BatNum.Infix] |
(>=/) [BatNum] |
(>>=) [BatResult.Infix] |
(>>=) [BatResult] | as `bind`
(>>=) [BatParserCo.Infix] |
(>>=) [BatParserCo] | As `bind`
(>>>) [BatParserCo.Infix] |
(>>>) [BatParserCo] | As `bind`, but ignoring the result
(@) [BatPervasives] | List concatenation.
(@) [BatList.Infix] |
(@) [BatList] | the new implementation for ( @ ) operator, see `List.append`.
(@/) [BatPervasives] | Mapping operators.
(@/) [BatEnum.Infix] | Mapping operators.
(@/) [BatEnum] |
(@//) [BatPervasives] | Map combined with filter.
(@//) [BatEnum.Infix] | Map combined with filter.
(@//) [BatEnum] |
(^:^) [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`
(^^^) [BatRope.Infix] |
(^^^) [BatRope] | As `BatRope.append`
(|-) [BatStd] | Function composition.
(|-) [BatPervasives] | Function composition.
(|>) [Batteries_print] |
(|>) [BatStd] | Function application.
(|>) [BatPervasives] | Function application.
(||) [BatBool] | The boolean ``or''.
(~+) [BatParserCo.Infix] |
(~+) [BatParserCo] | As `one_plus`
(~?) [BatParserCo.Infix] |
(~?) [BatParserCo] | As `maybe`
A
abs [BatNumber.Numeric] |
abs [BatNum] |
abs [BatNativeint] | Return the absolute value of its argument.
abs [BatInt64] | Return the absolute value of its argument.
abs [BatInt32] | Return the absolute value of its argument.
abs [BatInt.Safe_int] | Return the absolute value of its argument.
abs [BatInt] | Return the absolute value of its argument.
abs [BatFloat.Safe_float] | The absolute value of a floating point number.
abs [BatFloat] | The absolute value of a floating point number.
abs [BatComplex] | `abs c` returns the module of this complex number, i.e.
abs [BatBool] |
abs [BatBig_int] |
acos [BatFloat.Safe_float] | See `BatFloat.Safe_float.atan2`.
acos [BatFloat] | See `BatFloat.atan2`.
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 [BatPSet] |
add [BatPMap] |
add [BatOptParse.OptParser] | Add an option to the option parser.
add [BatNumber.Numeric] |
add [BatNum] |
add [BatNativeint] | Addition.
add [BatMultiPMap] | `add x y m` returns a map containing the same bindings as `m`, plus a binding of `x` to `y`.
add [BatMap.S.Labels] |
add [BatMap.S] | `add x y m` returns a map containing the same bindings as `m`, plus a binding of `x` to `y`.
add [BatMap] | `add x y m` returns a map containing the same bindings as `m`, plus a binding of `x` to `y`.
add [BatInt64] | Addition.
add [BatInt32] | Addition.
add [BatInt.Safe_int] | Addition.
add [BatInt] | Addition.
add [BatInnerWeaktbl] | `Weaktbl.add tbl x y` adds a binding of `x` to `y` in table `tbl`.
add [BatISet] |
add [BatIMap] |
add [BatHeap.H] | See `BatHeap.insert`.
add [BatHeap] | `add x h` is the same as `insert h x`.
add [BatHashtbl.Cap.Labels] |
add [BatHashtbl.Cap] |
add [BatHashtbl.S.Labels] |
add [BatHashtbl.S] |
add [BatHashtbl.Labels] |
add [BatHashtbl] | `Hashtbl.add tbl x y` adds a binding of `x` to `y` in table `tbl`.
add [BatFloat.Safe_float] |
add [BatFloat] |
add [BatDynArray] | `add darr v` appends `v` onto `darr`.
add [BatDllist] | `add n a` Creates a new node containing data `a` and inserts it into the list after node `n`.
add [BatComplex] | Addition
add [BatBool] |
add [BatBig_int] |
add_buffer [BatUTF8.Buf] | `add_buffer b1 b2` adds the contents of `b2` to `b1`.
add_carry [BatPMap] |
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_group [BatOptParse.OptParser] | Add a group to the option parser.
add_initializer [BatOo.Oo.Internal] |
add_input [BatBuffer] | `add_input b ic n` reads exactly `n` character from the input `ic` and stores them at the end of buffer `b`.
add_int_big_int [BatBig_int] | Addition of a small integer to a big integer.
add_range [BatISet] |
add_range [BatIMap] |
add_sort [BatRefList] | Adds an element in a sorted list, using optional comparator or 'compare' as default.
add_string [BatUTF8.Buf] | Add the UTF-8 string to the buffer.
adopt [BatUTF8] | Adopt a string without copying.
advance [BatUCharParser] | Advance by one char.
advance [BatCharParser] | Advance by one char.
after [BatISet] |
after [BatIMap] |
all [BatSubstring] | `all s` is the substring `(s, 0, size s)`.
any [BatParserCo] | Accept any singleton value.
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 [BatUTF8] | Concatenate two UTF8 strings
append [BatSeq] | `append s1 s2` returns the sequence which first returns all elements of `s1` then all elements of `s2`.
append [BatRope] | `append r u` concatenates the `r` and `u` ropes.
append [BatPathGen.PathType] | Alternative name for `BatPathGen.PathType.Operators.(/:)`
append [BatList] | Catenate two lists.
append [BatLazyList] | Lazy append
append [BatEnum] | `append e1 e2` returns an enumeration that will enumerate over all elements of `e1` followed by all elements of `e2`.
append [BatDynArray] | `append src dst` adds all elements of `src` to the end of `dst`.
append [BatDllist] | `append n a` Creates a new node containing data `a` and inserts it into the list after node `n`.
append [BatDeque] | `append dq1 dq2` represents the concatenateion of `dq1` and `dq2`.
append [BatArray.Cap] |
append_char [BatRope] | `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.
approx [BatNum] | `approx n` return the integer closest to `n`
approx_num_exp [BatNum] | Approximate a number by a decimal.
approx_num_fix [BatNum] | See `Num.approx_num_exp`.
arg [BatComplex] | Argument.
arg_max [BatEnum] | `arg_min f xs` returns the `x` in `xs` for which `f x` is minimum.
arg_min [BatEnum] |
args [BatStd] | An enumeration of the arguments passed to this program through the command line.
args [BatPervasives] | An enumeration of the arguments passed to this program through the command line.
array1_of_genarray [BatBigarray] | Return the one-dimensional big array corresponding to the given generic big array.
array2_of_genarray [BatBigarray] | Return the two-dimensional big array corresponding to the given generic big array.
array3_of_genarray [BatBigarray] | Return the three-dimensional big array corresponding to the given generic big array.
as_encoded [BatCharEncodings] | `as_encoded x enc` returns an element of type `t` used to mark that `x` is encoded with encoding `enc`.
asin [BatFloat.Safe_float] | See `BatFloat.Safe_float.atan2`.
asin [BatFloat] | See `BatFloat.atan2`.
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 [BatLazyList.Labels.Exceptionless] |
assoc [BatLazyList.Exceptionless] | `assoc a l` returns `Some b` where `b` is the value associated with key `a` in the list of pairs `l`.
assoc [BatLazyList] | `assoc a l` returns the value associated with key `a` in the list of pairs `l`.
assoc_inv [BatList.Labels.LExceptionless] |
assoc_inv [BatList.Exceptionless] | `assoc_inv b l` returns `Some a` where `a` is the key associated with value `b` in the list of pairs `l`.
assoc_inv [BatList] | `assoc_inv b l` returns the key associated with value `b` in the list of pairs `l`.
assq [BatList.Labels.LExceptionless] |
assq [BatList.Exceptionless] | As `BatList.Exceptionless.assoc` but with physical equality.
assq [BatLazyList.Labels.Exceptionless] |
assq [BatLazyList.Exceptionless] | As `BatLazyList.Exceptionless.assoc` but with physical equality
assq [BatLazyList] | As `BatLazyList.assoc` but with physical equality
at [BatVect] | as `get`
at [BatSeq.Exceptionless] |
at [BatSeq] | `at l n` returns the 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 raise `Invalid_index` is the index is outside of `l` bounds.
at [BatLazyList.Labels.Exceptionless] |
at [BatLazyList.Exceptionless] | If `n` is inside the bounds of `l`, `at l n` returns ``Ok x`, where `x` is the n-th element of the list `l`.
at [BatLazyList] | `at l n` returns the element at index `n` (starting from `0`) in the list `l` or raise `Invalid_index` is the index is outside of `l` bounds.
at [BatDeque] | `at ~backwards dq k` returns the `k`th element of `dq`, from the front if `backwards` is false, and from the rear if `backwards` is true.
at_end [BatUTF8.Byte] |
at_index [BatRefList.Index] | Return the element of ref list at the specified index raise `Invalid_index` if the index is outside `0 ; length-1`
atan [BatFloat.Safe_float] | See `BatFloat.Safe_float.atan2`.
atan [BatFloat] | See `BatFloat.atan2`.
atan2 [BatFloat.Safe_float] | The usual trigonometric functions.
atan2 [BatFloat] | The usual trigonometric functions.
B
backwards [BatVect.RANDOMACCESS] |
backwards [BatVect] | Returns an enumeration of the elements of a vector, from last to first.
backwards [BatUTF8] | As `String.backwards`
backwards [BatString] | Returns an enumeration of the characters of a string, from last to first.
backwards [BatSet.S] | Return an enumeration of all elements of the given set.
backwards [BatRope] | Returns an enumeration of the characters of a rope, from last to first.
backwards [BatRefList] | Returns an enumeration of current elements in the ref list, going from last to first
backwards [BatPMap] |
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 [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 [BatRope] | `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)`.
before [BatISet] |
before [BatIMap] |
beginning_of_input [BatScanf.Scanning] | `Scanning.beginning_of_input ib` tests the beginning of input condition of the given scanning buffer.
belongs [BatPathGen.PathType] | `belongs base sub` is `true` when `sub` descends from `base`, i.e.
big_int_of_int [BatBig_int] | Convert a small integer to a big integer.
big_int_of_num [BatNum] |
big_int_of_string [BatBig_int] | Convert a string to a big integer, in decimal.
bind [BatResult] | Monadic composition.
bind [BatParserCo] | Monadic-style combination:
bind [BatOption.Monad] | `bind m f` combines the calculation result `m` with the function `f`.
bind [BatOption] | `bind f (Some x)` returns `f x` and `bind f None` returns `None`.
bind [BatMonad.S] | Monadic binding.
bind [BatEnum.Monad] | `bind m f` takes the result of the monadic computation m, puts the f function in the monadic context passing it the result of m and then returning a monadic result.
bindings [BatPMap] |
bindings [BatMap.S] | Return the list of all bindings of the given map.
bindings [BatMap] | Return the list of all bindings of the given map.
bits [BatRandom.State] |
bits [BatRandom] | Return 30 random bits in a nonnegative integer.
bits_of [BatIO] | Read an enumeration of bits
bits_of_float [BatInt64] | Return the internal representation of the given float according to the IEEE 754 floating-point ``double format'' bit layout.
bits_of_float [BatInt32] | Return the internal representation of the given float according to the IEEE 754 floating-point ``single format'' bit layout.
blit [BatRope] | `blit src srcoff dst dstoff len` returns a copy of `dst` in which `len` characters have been copied from rope `src`, starting at character number `srcoff`, to rope `dst`, starting at character number `dstoff`.
blit [BatDynArray] | `blit src srcidx dst dstidx len` copies `len` elements from `src` starting with index `srcidx` to `dst` starting at `dstidx`.
blit [BatBuffer] | `Buffer.blit b srcoff dst dstoff len` copies `len` characters from the current contents of the buffer `b` starting at offset `off`, starting at character number `srcoff`, to string `dst`, starting at character number `dstoff`.
blit [BatBigarray.Array3] | Copy the first big array to the second big array.
blit [BatBigarray.Array2] | Copy the first big array to the second big array.
blit [BatBigarray.Array1] | Copy the first big array to the second big array.
blit [BatBigarray.Genarray] | Copy all elements of a big array in another big array.
blit [BatArray.Cap.Labels] |
blit [BatArray.Cap] |
blit [BatArray.Labels] |
bool [BatRandom.State] |
bool [BatRandom] | `Random.bool ()` returns `true` or `false` with probability 0.5 each.
bprintf [BatPrintf] | As `BatPrintf.fprintf`, but with buffers instead of outputs.
bprintf [BatPrint] | This function behaves as `BatPrint.fprintf` but prints into a buffer rather than into an `output`.
bprintf [BatInnerIO.Printf] | As `BatInnerIO.Printf.fprintf`, but with buffers instead of outputs.
bprintf2 [BatPrintf] | As `BatPrintf.printf` but writes to a buffer instead of printing to the output.
bprintf2 [BatInnerIO.Printf] | As `BatInnerIO.Printf.printf` but writes to a buffer instead of printing to the output.
break [BatEnum] | Negated span.
browse [Batteries_config] | `browse s` opens the platform's default www browser to browse url `s`.
bscanf [BatScanf] | `bscanf ib fmt r1 ... rN f` reads arguments for the function `f`, from the scanning buffer `ib`, according to the format string `fmt`, and applies `f` to these values.
bscanf_format [BatScanf] | `bscanf_format ib fmt f` reads a format string token from the scannning buffer `ib`, according to the given format string `fmt`, and applies `f` to the resulting format string value.
bulk_enum [BatRope] | Returns an enumeration of the UTF-8 encoded strings of a rope.
bulk_filter_map [BatRope] | `bulk_filter_map f l` calls `(f a0) (f a1).... (f an)` where `a0..an` are the UTF-encoded strings of `l`.
bulk_fold [BatRope] | As `BatRope.fold` but over larger chunks of data.
bulk_iter [BatRope] | as iter but over larger chunks of data
bulk_iteri [BatRope] | as iteri but over larger chunks of data.
bulk_map [BatRope] | `map f s` returns a rope where all ropes `c` in `s` have been replaced by `f c`.
bytes_of [BatIO] | Read an enumeration of unsigned 8-bit integers.
C
c_layout [BatBigarray] |
callback_option [BatOptParse.Opt] | Make a callback option which takes a single argument.
capitalize [BatRope] | Return a copy of the argument, with the first character set to uppercase.
cardinal [BatSet.S] | Return the number of elements of a set.
cardinal [BatSet] | Return the number of elements of a set.
cardinal [BatPSet] |
cardinal [BatPMap] |
cardinal [BatMap.S] | Return the number of bindings of a map.
cardinal [BatMap] | Return the number of bindings of a map.
cardinal [BatISet] |
cartesian_product [BatList] | Different from `List.combine`, this returns every pair of elements formed out of the two lists.
case_char [BatUCharParser] | As `char`, but case-insensitive
case_char [BatCharParser] | As `char`, but case-insensitive
case_rope [BatUCharParser] | As `rope`, but case-insensitive
case_sensitive [BatGenlex.Languages.Definition] | `true` if the language is case-sensitive, `false` otherwise.
case_string [BatUCharParser] | As `string`, but case-insensitive
case_string [BatCharParser] | As `case_string`, but case-insensitive
case_ustring [BatUCharParser] | As `ustring`, but case-insensitive
casefold [BatUTF8] | Do the case folding transform to the input text (for doing case-insensitive comparison)
cast_output [BatInnerIO] | You can safely transform any output to an unit output in a safe way by using this function.
cast_output [BatIO] | You can safely transform any output to an unit output in a safe way by using this function.
catch [BatResult] | Execute a function and catch any exception as a `!result`
category [BatUChar] | Determine to which category the character belongs.
ceil [BatNum] |
ceil [BatFloat.Safe_float] | See `BatFloat.Safe_float.floor`.
ceil [BatFloat] | See `BatFloat.floor`.
channel [BatDigest] | If `len` is nonnegative, `Digest.channel ic len` reads `len` characters from channel `ic` and returns their digest, or raises `End_of_file` if end-of-file is reached before `len` characters are read.
char [BatUCharParser] | Recognize exactly one char
char [BatRandom.State] |
char [BatRandom] | Return a random Latin-1 character.
char [BatGenlex.Languages.Make] | Low-level API
char [BatCharParser] | Recognize exactly one char
char [BatBigarray] | As shown by the types of the values above, big arrays of kind `float32_elt` and `float64_elt` are accessed using the Caml type `float`.
char_dynarray [Batteries_print] |
char_enum [Batteries_print] |
char_literal [BatGenlex.Languages.Make] | Accepts a character literal, i.e.
char_pset [Batteries_print] |
char_set [Batteries_print] |
chars_of [BatIO] | Read an enumeration of Latin-1 characters.
chmod [BatFile] | As `BatFile.set_permissions`
choice [BatRandom] | `choice e` returns a randomly-chosen element of `e`.
choose [BatSet.S.Exceptionless] |
choose [BatSet.S] | Return one element of the given set, or raise `Not_found` if the set is empty.
choose [BatSet] | returns an arbitrary (but deterministic) element of the given set.
choose [BatPSet] |
choose [BatPMap] |
choose [BatMap.S] | Return one binding of the given map, or raise `Not_found` if the map is empty.
choose [BatMap] | Return one binding of the given map, or raise `Not_found` if the map is empty.
choose [BatISet] |
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 [BatRefList] | Removes all elements
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.
clone [BatEnum] | `clone e` creates a new enumeration that is copy of `e`.
clone [BatBitSet] | Same as `copy`
close_all [BatInnerIO] | Close all outputs.
close_in [BatPervasives] | Close the given channel.
close_in [BatInnerIO] | Close the input.
close_in [BatIO] | Close the input.
close_in_noerr [BatPervasives] | Same as `close_in`, but ignore all errors.
close_out [BatPervasives] | Close the given channel, flushing all buffered write operations.
close_out [BatInnerIO] | Close the output and return its accumulator data.
close_out [BatIO] | Close the output and return its accumulator data.
close_out_noerr [BatPervasives] | Same as `close_out`, but ignore all errors.
close_process [BatUnix] | Close `input`/`output` opened by `Unix.open_process`, wait for the associated command to terminate, and return its termination status.
close_process_full [BatUnix] | Close i/o opened by `Unix.open_process_full`, wait for the associated command to terminate, and return its termination status.
close_process_in [BatUnix] | Close `input` opened by `Unix.open_process_in`, wait for the associated command to terminate, and return its termination status.
close_process_out [BatUnix] | Close `output` opened by `Unix.open_process_out`, wait for the associated command to terminate, and return its termination status.
clump [BatEnum] | `clump size add get e` runs `add` on `size` (or less at the end) elements of `e` and then runs `get` to produce value for the result enumeration.
comb [BatStream] | `comb` transform a pair of stream into a stream of pairs of corresponding elements.
combine [BatSeq.Exceptionless] |
combine [BatSeq] | Transform a pair of sequences into a sequence of pairs.
combine [BatList] | Transform a pair of lists into a list of pairs: `combine [a0; a1; ...; an] [b0; b1; ...; bn]` is `[(a0,b0); (a1,b1); ...; (an,bn)]`.
combine [BatLazyList] | Transform a pair of lists into a list of pairs: `combine [^ a0; a1; ... ^] [^ b0; b1; ... ^]` is `[^ (a0, b0); (a1, b1); ... ^]`.
combine [BatIO] | `combine (a,b)` creates a new `output` `c` such that writing to `c` will actually write to both `a` and `b`
combine [BatEnum] | `combine` transform a pair of stream into a stream of pairs of corresponding elements.
command [BatArg] | Construct a new command, i.e.
comment [BatGenlex.Languages.Make] |
comment_delimiters [BatGenlex.Languages.Definition] |
compact [BatDynArray] | `compact darr` ensures that the space allocated by the array is minimal.
compare [BatUnit] | Compare two units.
compare [BatUTF8] | Code point comparison by lexicographic order.
compare [BatTuple.Tuple5] |
compare [BatTuple.Tuple4] |
compare [BatTuple.Tuple3] |
compare [BatTuple.Tuple2] |
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] | The comparison function for strings, with the same specification as `Pervasives.compare`.
compare [BatSet.S] | Total ordering between sets.
compare [BatRope] | The comparison function for ropes, with the same specification as `Pervasives.compare`.
compare [BatPathGen.StringType] | Usual comparison function.
compare [BatPair] | Compare two pairs in lexicographic order, possibly using custom comparators for the two fields
compare [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.S.Labels] |
compare [BatMap.S] | Total ordering between maps.
compare [BatInterfaces.OrderedType] | A total ordering function This is a two-argument function `f` such that `f e1 e2` is zero if the values `e1` and `e2` are equal, `f e1 e2` is strictly negative if `e1` is smaller than `e2`, and `f e1 e2` is strictly positive if `e1` is greater than `e2`.
compare [BatInt64] | The comparison function for 64-bit integers, with the same specification as `Pervasives.compare`.
compare [BatInt32] | The comparison function for 32-bit integers, with the same specification as `Pervasives.compare`.
compare [BatInt.Safe_int] | The comparison function for integers, with the same specification as `Pervasives.compare`.
compare [BatInt] | The comparison function for integers, with the same specification as `Pervasives.compare`.
compare [BatInnerIO.Output] | A total order on outputs
compare [BatInnerIO.Input] | A total order on inputs
compare [BatISet] |
compare [BatHashcons] | Comparison on the tags
compare [BatFloat.Safe_float] |
compare [BatFloat] |
compare [BatEnum.Labels] |
compare [BatEnum] | `compare cmp a b` compares enumerations `a` and `b` by lexicographical order using comparison `cmp`.
compare [BatComplex] |
compare [BatBool] |
compare [BatBitSet] | `compare s1 s2` compares two bitsets.
compare [BatBig_int] |
compare_big_int [BatBig_int] | `compare_big_int a b` returns `0` if `a` and `b` are equal, `1` if `a` is greater than `b`, and `-1` if `a` is smaller than `b`.
compare_index [BatUTF8] | `compare_index s i1 i2` returns a value < 0 if `i1` is the position located before `i2`, 0 if `i1` and `i2` points the same location, a value > 0 if `i1` is the position located after `i2`.
compare_subset [BatSet.S] | Partial ordering between sets as generated by `subset`
compl [BatISet] |
complex32 [BatBigarray] | See `Bigarray.char`.
complex64 [BatBigarray] | See `Bigarray.char`.
compose [BatConcurrent] | Compose two lock systems into a third lock system.
concat [BatVect.RANDOMACCESS] |
concat [BatVect.Make] | `concat r u` concatenates the `r` and `u` vects.
concat [BatVect] | `concat r u` concatenates the `r` and `u` vects.
concat [BatUTF8] | `concat sep [a;b;c...]` returns the concatenation of `a`, `sep`, `b`, `sep`, `c`, `sep`...
concat [BatSubstring] | `concat suss` returns a string consisting of the concatenation of the substrings.
concat [BatStream] | concatenate a stream of streams
concat [BatSeq] | `concat s` returns the sequence which returns all the elements of all the elements of `s`, in the same order.
concat [BatRope] | `concat sep sl` concatenates the list of ropes `sl`, inserting the separator rope `sep` between each.
concat [BatPervasives] | `concat e` returns an enumeration over all elements of all enumerations of `e`.
concat [BatPathGen.PathType] | Alternative name for `BatPathGen.PathType.Operators.(//@)`
concat [BatList] | Concatenate a list of lists.
concat [BatLazyList] | Lazy concatenation of a lazy list of lazy lists
concat [BatEnum] | `concat e` returns an enumeration over all elements of all enumerations of `e`.
concat [BatAvlTree] |
concat [BatArray.Cap] |
concat_with_separators [BatPathGen.StringType] | `concat_with_separators sep lst` catenates all n elements of `lst` inserting (n-1) copies of `sep` in between.
conj [BatComplex] | Conjugate: given the complex `x + i.y`, returns `x - i.y`.
cons [BatStream] | `cons x stream` equals `[<'x; stream>]`.
cons [BatSeq] | `cons e s = fun () -> Cons(e, s)`
cons [BatParserCo] | `cons p q` applies parser `p` then parser `q` and conses the results into a list.
cons [BatList] | `cons h t` returns the list starting with `h` and continuing as `t`
cons [BatLazyList] | Build a list from a head and a tail.
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 [BatStd] | Ignore its second argument.
const [BatPervasives] | Ignore its second argument.
contains [BatUTF8] | As `String.contains`
contains [BatRope] | `contains s c` tests if character `c` appears in the rope `s`.
contains_from [BatUTF8] |
contains_from [BatRope] | `contains_from s start c` tests if character `c` appears in the subrope of `s` starting from `start` to the end of `s`.
contents [BatUTF8.Buf] | `contents buf` returns the contents of the buffer.
copy [BatVect.RANDOMACCESS] |
copy [BatRefList] | Makes a copy of a ref list - O(1)
copy [BatRef] | `copy r` returns a new reference with the same initial content as `r`.
copy [BatRandom.State] | Return a copy of the given state.
copy [BatOo.Oo.Internal] |
copy [BatOo.Oo] | `Oo.copy o` returns a copy of object `o`, that is a fresh object with the same methods and instance variables as `o`
copy [BatInnerWeaktbl] | Return a copy of the given hashtable.
copy [BatIO] | Read everything from an input and copy it to an output.
copy [BatHashtbl.Cap] |
copy [BatHashtbl.S] |
copy [BatHashtbl] | Return a copy of the given hashtable.
copy [BatDynArray] | `copy src` returns a fresh copy of `src`, such that no modification of `src` affects the copy, or vice versa (all new memory is allocated for the copy).
copy [BatDllist] | Copy the list attached to the given node and return the copy of the given node.
copy [BatBitSet] | Copy a bitset : further modifications of first one will not affect the copy.
copy [BatArray.Cap] |
copy_enum [BatRefList] | Makes a copy of a enum.
copy_list [BatRefList] | Makes a copy of a list - O(1)
cos [BatFloat.Safe_float] | See `BatFloat.Safe_float.atan2`.
cos [BatFloat] | See `BatFloat.atan2`.
cosh [BatFloat.Safe_float] | See `BatFloat.Safe_float.tanh`.
cosh [BatFloat] | See `BatFloat.tanh`.
count [BatEnum] | `count e` returns the number of remaining elements in `e` without consuming the enumeration.
count [BatBitSet] | `count s` returns the number of bits set in the bitset `s`.
count_option [BatOptParse.StdOpt] | Create a counting option which increments its value each time the option is encountered on the command line.
create [BatUTF8.Buf] | `create n` creates the buffer with the initial size `n`-bytes.
create [BatSubstring] |
create [BatSet] | Creates a new empty set, using the provided function for key comparison.
create [BatRMutex] | Return a new mutex.
create [BatPSet] |
create [BatPMap] |
create [BatMutex.Mutex] | Return a new mutex.
create [BatMultiPMap] | creates a new empty map, using the provided function for key comparison.
create [BatMap] | creates a new empty map, using the provided function for key comparison.
create [BatInnerWeaktbl] | `Weaktbl.create n` creates a new, empty hash table, with initial size `n`.
create [BatHashtbl.Cap] |
create [BatHashtbl.S] |
create [BatHashtbl] | `Hashtbl.create n` creates a new, empty hash table, with initial size `n`.
create [BatHashcons.Table] | `create n` creates a table with at least `n` cells.
create [BatDynArray] | `create()` returns a new empty dynamic array.
create [BatDllist] | Creates a node.
create [BatConcurrent.BaseLock] |
create [BatConcurrent.Lock] |
create [BatConcurrent] | Create a lock from a pair of locking/unlocking functions
create [BatBitSet] | Create an empty bitset with an initial size (in number of bits).
create [BatBigarray.Array3] | `Array3.create kind layout dim1 dim2 dim3` returns a new bigarray of three dimension, whose size is `dim1` in the first dimension, `dim2` in the second dimension, and `dim3` in the third.
create [BatBigarray.Array2] | `Array2.create kind layout dim1 dim2` returns a new bigarray of two dimension, whose size is `dim1` in the first dimension and `dim2` in the second dimension.
create [BatBigarray.Array1] | `Array1.create kind layout dim` returns a new bigarray of one dimension, whose size is `dim`.
create [BatBigarray.Genarray] | `Genarray.create kind layout dimensions` returns a new big array whose element kind is determined by the parameter `kind` (one of `float32`, `float64`, `int8_signed`, etc) and whose layout is determined by the parameter `layout` (one of `c_layout` or `fortran_layout`).
create [BatArray.Cap.Labels] |
create [BatArray.Cap] |
create [BatArray.Labels] |
create_full [BatBitSet] | Create a full bitset with an initial size (in number of bits).
create_in [BatInnerIO] | Fully create an input by giving all the needed functions.
create_in [BatIO] | Fully create an input by giving all the needed functions.
create_matrix [BatArray.Cap.Labels] |
create_matrix [BatArray.Cap] |
create_matrix [BatArray.Labels] |
create_object [BatOo.Oo.Internal] |
create_object_and_run_initializers [BatOo.Oo.Internal] |
create_object_opt [BatOo.Oo.Internal] |
create_out [BatInnerIO] | Fully create an output by giving all the needed functions.
create_out [BatIO] | Fully create an output by giving all the needed functions.
create_table [BatOo.Oo.Internal] |
curry [BatTuple.Tuple5] |
curry [BatTuple.Tuple4] |
curry [BatTuple.Tuple3] |
curry [BatTuple.Tuple2] |
curry [BatStd] | Turn a function that takes a pair into a function that takes its arguments one at a time.
curry [BatPervasives] | Convert a function which accepts a pair of arguments into a function which accepts two arguments.
cycle [BatEnum] | `cycle` is similar to `repeat`, except that the content to fill is a subenum rather than a single element.
D
dbg_formatter [BatLogger] | `dbg_formatter` is a debug formatter that outputs log events to stderr using the same format as `make_dbg_formatter`.
debug_mode [BatParserCo] | If set to `true`, debugging information will be printed to the standard error.
decode [BatBase64] | Generic base64 decoding over an input.
decorate_fast_sort [BatArray] | As `Array.decorate_sort`, but uses fast_sort internally.
decorate_stable_sort [BatArray] | `decorate_sort f a` returns a sorted copy of `a` such that if `f x < f y` then `x` is earlier in the result than `y`.
decr_option [BatOptParse.StdOpt] | Exactly identical to `count_option ~dest:dest ~increment:(-1) ()`.
default [BatOption] | `default x (Some v)` returns `v` and `default x None` returns `x`.
default_buffer_size [BatInnerIO] | The default size of buffers.
default_buffer_size [BatIO] | The default size for internal buffers.
default_permission [BatFile] | Default permissions.
default_resizer [BatDynArray] | The default resizer function the library is using - in this version of DynArray, this is the `exponential_resizer` but should change in next versions.
default_validator [BatPathGen.PathType] | Forward slash and code zero are considered invalid.
del_min [BatHeap.H] | See `BatHeap.del_min`.
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_last [BatDynArray] | `delete_last darr` deletes the last element of `darr`.
delete_range [BatDynArray] | `delete_range darr p len` deletes `len` elements starting at index `p`.
demote [BatDllist] | `demote n` Swaps `n` with `prev n`.
descr_of_in_channel [BatUnix] |
descr_of_input [BatUnix] | Return the descriptor corresponding to an input.
descr_of_out_channel [BatUnix] |
descr_of_output [BatUnix] | Return the descriptor corresponding to an output.
destructive_set [BatVect] | `destructive_set n e v` sets the element of index `n` in the `v` vect to `e`.
diff [BatSet.S] | Set difference.
diff [BatSet] | `diff s t` returns the set of all elements in `s` but not in `t`.
diff [BatPSet] |
diff [BatPMap] |
diff [BatMap] | `diff m1 m2` removes all bindings of keys found in `m2` from `m1`, using the comparison function of `m1`.
diff [BatISet] |
diff [BatBitSet] | `diff s t` returns `s`-`t`.
differentiate [BatBitSet] | `differentiate s t` removes the elements of `t` from `s`.
differentiate_sym [BatBitSet] | `differentiate_sym s t` sets `s` to the symmetrical difference of the sets `s` and `t`.
digit [BatUCharParser] | Recognizes one decimal digit
digit [BatCharParser] | Recognizes one decimal digit
dim [BatBigarray.Array1] | Return the size (dimension) of the given one-dimensional big array.
dim1 [BatBigarray.Array3] | Return the first dimension of the given three-dimensional big array.
dim1 [BatBigarray.Array2] | Return the first dimension of the given two-dimensional big array.
dim2 [BatBigarray.Array3] | Return the second dimension of the given three-dimensional big array.
dim2 [BatBigarray.Array2] | Return the second dimension of the given two-dimensional big array.
dim3 [BatBigarray.Array3] | Return the third dimension of the given three-dimensional big array.
dims [BatBigarray.Genarray] | `Genarray.dims a` returns all dimensions of the big array `a`, as an array of integers of length `Genarray.num_dims a`.
div [BatNumber.Numeric] |
div [BatNum] |
div [BatNativeint] | Integer division.
div [BatInt64] | Integer division.
div [BatInt32] | Integer division.
div [BatInt.Safe_int] | Integer division.
div [BatInt] | Integer division.
div [BatFloat.Safe_float] |
div [BatFloat] |
div [BatComplex] | Division
div [BatBool] |
div [BatBig_int] |
documentation_root [Batteries_config] | A path to the root of the documentation.
domain [BatIMap] |
doubles_of [BatIO.BigEndian] | Read an enumeration of IEEE double precision floating point values.
doubles_of [BatIO] | Read an enumeration of IEEE double precision floating point values.
dq_printer [BatDeque] | See `BatValue_printer`.
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] | `dropwhile f xs` returns the list `xs` with the first elements satisfying the predicate `f` dropped.
drop_while [BatLazyList.Labels] |
drop_while [BatLazyList] | `drop_while f xs` returns the list `xs` with the first elements satisfying the predicate `f` dropped.
drop_while [BatEnum.Labels] |
drop_while [BatEnum] | `drop_while p e` produces a new enumeration in which only all the first elements such that `f e` have been junked.
dropl [BatSubstring] | `dropl p sus` drops the longest prefix (left substring) of `sus` all of whose characters satisfy predicate `p`.
dropr [BatSubstring] | `dropr p sus` drops the longest suffix (right substring) of sus all of whose characters satisfy predicate `p`.
dropwhile [BatList] | obsolete, as `BatList.drop_while`
dummy_class [BatOo.Oo.Internal] |
dummy_table [BatOo.Oo.Internal] |
dump [BatStd] | represent a runtime value as a string.
dump [BatPervasives] | Attempt to convert a value to a string.
dup [BatStream] | `dup stream` returns a pair of streams which are identical to `stream`.
dup [BatEnum] | `dup stream` returns a pair of streams which are identical to `stream`.
E
eager_append [BatLazyList] | Evaluate a list and append another list after this one.
eager_of_list [BatLazyList] | Eager conversion from lists.
either [BatParserCo] | Accept one of several parsers.
elements [BatSet.S] | Return the list of all elements of the given set.
elements [BatISet] |
elems [BatHeap.H] |
elems [BatHeap] |
empty [BatVect.RANDOMACCESS] |
empty [BatVect.Make] | The empty vect.
empty [BatVect] | The empty vect.
empty [BatUTF8] | The empty UTF8 string
empty [BatSubstring] |
empty [BatSet.S] | The empty set.
empty [BatSet] | The empty set, using `compare` as comparison function
empty [BatRope] | The empty rope.
empty [BatRefList] | Returns a new empty ref list
empty [BatPSet] |
empty [BatPMap] |
empty [BatMultiPMap] | 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] |
empty [BatIMap] |
empty [BatHeap.H] | See `BatHeap.empty`.
empty [BatHeap] | The empty heap.
empty [BatGlobal] | Returns an new named empty global.
empty [BatEnum] | The empty enumeration : contains no element
empty [BatDynArray] | Return true if the number of elements in the array is 0.
empty [BatDeque] | The empty dequeue.
empty [BatBitSet] | Create an empty bitset of size 0, the bitset will automatically expand when needed.
empty [BatAvlTree] |
encode [BatBase64] | Generic base64 encoding over an output.
encoded_as [BatCharEncodings] | `encoded_as t` returns the `x` such that `t = as_encoded x enc`.
encoding_of_t [BatCharEncodings] | Return the encoding of a `t`.
end_of_input [BatScanf.Scanning] | `Scanning.end_of_input ib` tests the end-of-input condition of the given scanning buffer.
ends_with [BatString] | `ends_with s x` returns `true` if the string `s` is ending with `x`, `false` otherwise.
ends_with [BatRope] | `ends_with s x` returns `true` if the rope `s` is ending with `x`, `false` otherwise.
enum [BatVect.RANDOMACCESS] |
enum [BatVect] | Returns an enumeration of the elements of the vector.
enum [BatUTF8] | As `String.enum`
enum [BatTuple.Tuple5] |
enum [BatTuple.Tuple4] |
enum [BatTuple.Tuple3] |
enum [BatTuple.Tuple2] |
enum [BatString] | Conversions
enum [BatStream] | Convert a stream to an enumeration.
enum [BatStack] | `enum s` returns a destructive enumeration of the elements of stack `s`, from the most recently entered to the least recently entered.
enum [BatSet.S] | Return an enumeration of all elements of the given set.
enum [BatSet] | Return an enumeration of all elements of the given set.
enum [BatSeq] | `enum s` returns the enumeration of all element of `s`.
enum [BatRope] | Returns an enumeration of the characters of a rope.
enum [BatRefList] | Returns an enumeration of current elements in the ref list
enum [BatQueue] | `enum q` returns a destructive enumeration of the elements of queue `q`, from the least recently entered to the most recently entered.
enum [BatPair] | builds a two-element enum of a pair
enum [BatPSet] |
enum [BatPMap] |
enum [BatOption] | `enum (Some x)` returns the singleton `x`, while `enum None` returns the empty enumeration
enum [BatMultiPMap] | creates an enumeration for this map.
enum [BatMap.S] | Return an enumeration of (key, value) pairs of a map.
enum [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] |
enum [BatIMap] |
enum [BatHeap.H] | See `BatHeap.enum`.
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 [BatEnum.Enumerable] | Return an enumeration of the elements of the data structure
enum [BatEnum] | identity : added for consistency with the other data structures
enum [BatDynArray] | `enum darr` returns the enumeration of `darr` elements.
enum [BatDllist] | Create an enum of the list.
enum [BatDeque] | `enum dq` is an enumeration of the elements of `dq` from the front to the rear.
enum [BatChar] | Produce the enumeration of all characters
enum [BatBuffer] | Returns an enumeration of the characters of a buffer.
enum [BatBitSet] | `enum s` returns an enumeration of bits which are set in the bitset `s`.
enum [BatBigarray.Array3] | `enum e` returns an enumeration on the elements of `e`.
enum [BatBigarray.Array2] | `enum e` returns an enumeration on the elements of `e`.
enum [BatBigarray.Array1] | `enum e` returns an enumeration on the elements of `e`.
enum [BatBigarray.Genarray] | `enum e` returns an enumeration on the elements of `e`.
enum [BatAvlTree] |
enum [BatArray.Cap] |
enum [BatArray] | Returns an enumeration of the elements of an array.
enum_bits [BatRandom.State] |
enum_bits [BatRandom] |
enum_bool [BatRandom.State] |
enum_bool [BatRandom] |
enum_char [BatRandom.State] |
enum_char [BatRandom] |
enum_float [BatRandom.State] |
enum_float [BatRandom] |
enum_int [BatRandom.State] |
enum_int [BatRandom] |
enum_int32 [BatRandom.State] |
enum_int32 [BatRandom] |
enum_int64 [BatRandom.State] |
enum_int64 [BatRandom] |
enum_nativeint [BatRandom.State] |
enum_nativeint [BatRandom] |
enum_print [Batteries_print] |
eof [BatParserCo] | Accept the end of an enumeration.
eprintf [BatPrintf] | The usual `eprintf` function, prints to the standard error output `stderr`, used to display warnings and errors.
eprintf [BatPrint] | `eprintf fmt args` behaves as `printf fmt args` but prints the result on the error out put `BatIO.stderr` rather on the screen.
eprintf [BatInnerIO.Printf] | The usual `eprintf` function, prints to the standard error output `BatInnerIO.stderr`, used to display warnings and errors.
epsilon [BatFloat.Safe_float] | The smallest positive float `x` such that `1.0 +. x <> 1.0`.
epsilon [BatFloat] | The smallest positive float `x` such that `1.0 +. x <> 1.0`.
eq [BatOption] | Test for equality between option types, possibly using a custom equality predicate.
eq_big_int [BatBig_int] |
eq_num [BatNum] |
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.unite`d.
equal [BatSet.S] | `equal s1 s2` tests whether the sets `s1` and `s2` are equal, that is, contain equal elements.
equal [BatMap.S.Labels] |
equal [BatMap.S] | `equal cmp m1 m2` tests whether the maps `m1` and `m2` are equal, that is, contain equal keys and associate them with equal data.
equal [BatInnerIO.Output] |
equal [BatInnerIO.Input] |
equal [BatISet] |
equal [BatHashtbl.HashedType] | The equality predicate used to compare keys.
equals [BatBitSet] | `equals s1 s2` returns true if, and only if, all bits values in s1 are the same as in s2.
err_formatter [BatFormat] | A formatter to use with formatting functions below for output to standard error.
error [BatOptParse.OptParser] | Display an error message and exit the program.
escaped [BatUTF8] |
escaped [BatRope] | Return a copy of the argument, with special characters represented by escape sequences, following the lexical conventions of Objective Caml.
establish_server [BatUnix] | Establish a server on the given address.
eternity [BatLazyList] | An infinite list of nothing
exactly [BatParserCo] | Accept exactly one singleton.
exe [BatStd] | The name of the current executable.
exe [BatPervasives] | The name of the current executable.
exists [BatVect] | `exists p [a0; a1; ...; an]` checks if at least one element of the array satisfies the predicate `p`.
exists [BatString] | `exists str sub` returns true if `sub` is a substring of `str` or false otherwise.
exists [BatSet.S.Labels] |
exists [BatSet.S] | `exists p s` checks if at least one element of the set satisfies the predicate `p`.
exists [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 [BatRope] | `exists str sub` returns true if `sub` is a subrope of `str` or false otherwise.
exists [BatRefList] | Return `true` if an element matches the specified predicate
exists [BatPervasives] | `exists f e` returns `true` if there is some `x` in `e` such that `f x`
exists [BatPSet] |
exists [BatPMap] |
exists [BatMap.S] | `exists p m` checks if at least one binding of the map satisfy the predicate `p`.
exists [BatMap] | same as `mem`.
exists [BatList.Labels] |
exists [BatLazyList.Labels] |
exists [BatLazyList] | Eager existential.
exists [BatISet] |
exists [BatEnum.Labels] |
exists [BatEnum] | `exists f e` returns `true` if there is some `x` in `e` such that `f x`
exists [BatDllist] | Test whether there exists an element of the given list for which the predicate returns true.
exists [BatArray.Cap.Labels] |
exists [BatArray.Cap] |
exists [BatArray.Labels] |
exists [BatArray] | `exists p [|a0; a1; ...; an|]` checks if at least one element of the array satisfies the predicate `p`.
exists2 [BatList.Labels] |
exists2 [BatList] | Same as `List.exists`, but for a two-argument predicate.
exists2 [BatLazyList.Labels] |
exists2 [BatLazyList] | Same as `BatLazyList.exists`, but for a two-argument predicate.
exists2 [BatArray] | As `Array.exists` but on two arrays.
exists_f [BatPMap] |
exists_f [BatMap] | Tests whether some key value pair satisfies some predicate function
exp [BatFloat.Safe_float] | Exponential.
exp [BatFloat] | Exponential.
exp [BatComplex] | Exponentiation.
explode [BatSubstring] | `explode sus` returns the list of characters of sus, that is, `s(i), s(i+1), ..., s(i+n-1)` where `sus = (s, i, n)`.
explode [BatString] | `explode s` returns the list of characters in the string `s`.
explode [BatRope] | `explode s` returns the list of characters in the rope `s`.
exponential_resizer [BatDynArray] | The exponential resizer- The default resizer except when the resizer is being copied from some other darray.
ext [BatPathGen.PathType] | Returns extension of the name of the object the pathname points to.
extract [BatSubstring] | `extract s i None` creates the substring (s, i, size s-i) consisting of the tail of s starting at i.
extract [BatPMap] |
extract [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`.
F
fail [BatParserCo] | Always fail, without consuming anything.
fast_count [BatEnum] | For users worried about the speed of `count` you can call the `fast_count` function that will give an hint about `count` implementation.
fast_sort [BatList.Labels] |
fast_sort [BatArray.Cap.Labels] |
fast_sort [BatArray.Cap] |
fast_sort [BatArray.Labels] |
fatal [BatParserCo] |
feed [BatGenlex.Languages.Make] | Drop comments, present reserved operators and reserved names as `Kwd`, operators and identifiers as `Ident`, integer numbers as `Int`, floating-point numbers as `Float` and characters as `Char`.
fields [BatSubstring] | `fields p sus` returns the list of fields in `sus`, from left to right, where a field is a (possibly empty) maximal substring of `sus` not containing any delimiter, and a delimiter is a character satisfying `p`.
fifth [BatTuple.Tuple5] |
files_of [BatSys] | As `readdir` but the results are presented as an enumeration of names.
fill [BatRope] | `fill s start len c` returns the rope in which characters number `start` to `start + len - 1` of `s` has been replaced by `c`.
fill [BatOptParse.Formatter] | See `OptParse.Formatter.wrap`.
fill [BatBigarray.Array3] | Fill the given big array with the given value.
fill [BatBigarray.Array2] | Fill the given big array with the given value.
fill [BatBigarray.Array1] | Fill the given big array with the given value.
fill [BatBigarray.Genarray] | Set all elements of a big array to a given value.
fill [BatArray.Cap.Labels] |
fill [BatArray.Cap] |
fill [BatArray.Labels] |
filter [BatVect.Make] | `filter f v` returns a vect with the elements `x` from `v` such that `f x` returns `true`.
filter [BatVect] | `filter f v` returns a vect with the elements `x` from `v` such that `f x` returns `true`.
filter [BatUTF8] | As `String.filter`
filter [BatString] | `filter f s` returns a copy of string `s` in which only characters `c` such that `f c = true` remain.
filter [BatStream.StreamLabels] |
filter [BatStream] | `filter test stream` picks all the elements satisfying `test` from `stream` and return the results in the same order as a stream.
filter [BatSet.S.Labels] |
filter [BatSet.S] | `filter p s` returns the set of all elements in `s` that satisfy predicate `p`.
filter [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 [BatRope] | `filter f s` returns a copy of rope `s` in which only characters `c` such that `f c = true` remain.
filter [BatRefList] | Remove all elements that do not match the specified predicate
filter [BatPervasives] | `filter f e` returns an enumeration over all elements `x` of `e` such as `f x` returns `true`.
filter [BatParserCo] | `filter f p` is only accepts values `x` such that `p` accepts `x` and `f (p x)` is `true`
filter [BatPSet] |
filter [BatPMap] |
filter [BatMap.S.Labels] |
filter [BatMap.S] | `filter f m` returns a map where only the values `a` of `m` such that `f a = true` remain.
filter [BatMap] | `filter f m` returns a map where only the values `a` of `m` such that `f a = true` remain.
filter [BatList.Labels] |
filter [BatList] | `filter p l` returns all the elements of the list `l` that satisfy the predicate `p`.
filter [BatLazyList.Labels] |
filter [BatLazyList] | Lazy filtering.
filter [BatISet] |
filter [BatHashtbl.Cap] |
filter [BatHashtbl.S.Labels] |
filter [BatHashtbl.S] |
filter [BatHashtbl.Labels] |
filter [BatHashtbl] | `filter f m` returns a new hashtable where only the values `a` of `m` such that `f a = true` remain.
filter [BatEnum.Labels] |
filter [BatEnum] | `filter f e` returns an enumeration over all elements `x` of `e` such as `f x` returns `true`.
filter [BatDynArray] | `filter p a` returns all the elements of the array `a` that satisfy the predicate `p`.
filter [BatDllist] | `filter p l` returns a new list, with entirely new nodes, whose values are all the elements of the list `l` that satisfy the predicate `p`.
filter [BatArray.Cap.Labels] |
filter [BatArray.Cap] |
filter [BatArray.Labels] |
filter [BatArray] | `filter p a` returns all the elements of the array `a` that satisfy the predicate `p`.
filter_map [BatVect.Make] | `filter_map f e` returns a vect consisting in all elements `x` such that `f y` returns `Some x` , where `y` is an element of `e`.
filter_map [BatVect] | `filter_map f e` returns a vect consisting in all elements `x` such that `f y` returns `Some x` , where `y` is an element of `e`.
filter_map [BatUTF8] | As `String.filter_map`
filter_map [BatString] | `filter_map f s` calls `(f a0) (f a1).... (f an)` where `a0..an` are the characters of `s`.
filter_map [BatSet.S.Labels] |
filter_map [BatSet.S] | `filter_map f m` combines the features of `filter` and `map`.
filter_map [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 [BatRope] | `filter_map f l` calls `(f a0) (f a1).... (f an)` where `a0..an` are the characters of `l`.
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 [BatPSet] |
filter_map [BatPMap] |
filter_map [BatMap.S] | `filter_map f m` combines the features of `filteri` and `map`.
filter_map [BatMap] | `filter_map f m` combines the features of `filteri` and `map`.
filter_map [BatList.Labels] |
filter_map [BatList] | `filter_map f l` calls `(f a0) (f a1).... (f an)` where `a0,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] |
filter_map [BatHashtbl.S.Labels] |
filter_map [BatHashtbl.S] |
filter_map [BatHashtbl.Labels] |
filter_map [BatHashtbl] | `filter_map f m` combines the features of `filteri` and `map`.
filter_map [BatEnum.Labels] |
filter_map [BatEnum] | `filter_map f e` returns an enumeration over all elements `x` such as `f y` returns `Some x` , where `y` is an element of `e`.
filter_map [BatDynArray] | `filter_map f e` returns an array consisting in all elements `x` such that `f y` returns `Some x` , where `y` is an element of `e`.
filter_map [BatDllist] | `filter_map f l` calls `(f a0) (f a1) ... (f an)` where `a0,a1...an` are the elements of `l`.
filter_map [BatArray.Cap.Labels] |
filter_map [BatArray.Cap] |
filter_map [BatArray.Labels] |
filter_map [BatArray] | `filter_map f e` returns an array consisting in all elements `x` such that `f y` returns `Some x` , where `y` is an element of `e`.
filteri [BatPMap] |
filteri [BatMap.S.Labels] |
filteri [BatMap.S] | `filter f m` returns a map where only the key, values pairs `key`, `a` of `m` such that `f key a = true` remain.
filteri [BatMap] | `filter f m` returns a map where only the (key, value) pairs `key`, `a` of `m` such that `f key a = true` remain.
filteri [BatHashtbl.Cap] |
filteri [BatHashtbl.S.Labels] |
filteri [BatHashtbl.S] |
filteri [BatHashtbl.Labels] |
filteri [BatHashtbl] | `filter f m` returns a map where only the key, values pairs `key`, `a` of `m` such that `f key a = true` remain.
filteri [BatArray] | As `filter` but with the index passed to the predicate.
finally [BatStd] | `finally fend f x` calls `f x` and then `fend()` even if `f x` raised an exception.
finally [BatPervasives] | `finally fend f x` calls `f x` and then `fend()` even if `f x` raised an exception.
find [BatVect] | `find p a` returns the first element of array `a` that satisfies the predicate `p`.
find [BatString] | `find s x` returns the starting index of the first occurrence of string `x` within string `s`.
find [BatSeq] | `find p s` returns the first element of `s` such as `p e` returns `true`, if any.
find [BatRope] | `find s x` returns the starting index of the first occurrence of rope `x` within rope `s`.
find [BatRefList] | Find the first element matching the specified predicate raise `Not_found` if no element is found
find [BatPervasives] | `find f e` returns the first element `x` of `e` such that `f x` returns `true`, consuming the enumeration up to and including the found element, or, raises `Not_found` if no such element exists in the enumeration, consuming the whole enumeration in the search.
find [BatPMap.Exceptionless] |
find [BatPMap] |
find [BatMultiPMap] | `find x m` returns the current binding of `x` in `m`
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 [BatLazyList.Labels.Exceptionless] |
find [BatLazyList.Labels] |
find [BatLazyList.Exceptionless] | `rfind p l` returns `Some x` where `x` is the first element of `l` such that `p x` returns `true` or `None` if such element as not been found.
find [BatLazyList] | `find p l` returns the first element of `l` such as `p x` returns `true` or raises `Not_found` if such an element has not been found.
find [BatInnerWeaktbl] | `Weaktbl.find tbl x` returns the current binding of `x` in `tbl`, or raises `Not_found` if no such binding exists.
find [BatIMap] |
find [BatHashtbl.Cap.Exceptionless] |
find [BatHashtbl.Cap] |
find [BatHashtbl.S.Exceptionless] |
find [BatHashtbl.S] |
find [BatHashtbl.Exceptionless] |
find [BatHashtbl] | `Hashtbl.find tbl x` returns the current binding of `x` in `tbl`, or raises `Not_found` if no such binding exists.
find [BatEnum.Labels.LExceptionless] |
find [BatEnum.Labels] |
find [BatEnum.Exceptionless] | `find f e` returns `Some x` where `x` is the first element `x` of `e` such that `f x` returns `true`, consuming the enumeration up to and including the found element, or `None` if no such element exists in the enumeration, consuming the whole enumeration in the search.
find [BatEnum] | `find f e` returns the first element `x` of `e` such that `f x` returns `true`, consuming the enumeration up to and including the found element, or, raises `Not_found` if no such element exists in the enumeration, consuming the whole enumeration in the search.
find [BatDllist] | `find p l` returns the first element, `l` or after, for which `p` returns true.
find [BatDeque] | `find ~backwards f dq` returns `Some (n, x)` if `x` at position `n` is such that `f x` is true, or `None` if there is no such element.
find [BatArray.Cap.Labels] |
find [BatArray.Cap.Exceptionless] |
find [BatArray.Cap] |
find [BatArray.Labels.LExceptionless] |
find [BatArray.Labels] |
find [BatArray.Exceptionless] | `find p a` returns `Some x`, where `x` is the first element of array `a` that satisfies the predicate `p`, or `None` if there is no such element.
find [BatArray] | `find p a` returns the first element of array `a` that satisfies the predicate `p`.
find_all [BatVect.Make] | `find_all` is another name for `Array.filter`.
find_all [BatVect] | `find_all` is another name for `Array.filter`.
find_all [BatList.Labels] |
find_all [BatList] | `find_all` is another name for `List.filter`.
find_all [BatInnerWeaktbl] | `Weaktbl.find_all tbl x` returns the list of all data associated with `x` in `tbl`.
find_all [BatHashtbl.Cap] |
find_all [BatHashtbl.S] |
find_all [BatHashtbl] | `Hashtbl.find_all tbl x` returns the list of all data associated with `x` in `tbl`.
find_all [BatArray.Cap] |
find_all [BatArray] | `find_all` is another name for `Array.filter`.
find_default [BatHashtbl.Cap] |
find_default [BatHashtbl.S] |
find_default [BatHashtbl] | Find a binding for the key, and return a default value if not found
find_exc [BatRefList] | Same as find but takes an exception to be raised when no element is found as additional parameter
find_exn [BatList.Labels] |
find_exn [BatList] | `find_exn p e l` returns the first element of `l` such as `p x` returns `true` or raises `e` if such an element has not been found.
find_exn [BatLazyList.Labels] |
find_exn [BatLazyList] | `find_exn p e l` returns the first element of `l` such as `p x` returns `true` or raises `e` if such an element has not been found.
find_from [BatString] | `find_from s ofs x` behaves as `find s x` but starts searching at offset `ofs`.
find_from [BatRope] | `find_from s ofs x` behaves as `find s x` but starts searching at offset `ofs`.
find_map [BatSeq] | `find_map p s` finds the first element of `s` for which `p e` returns `Some r`, if any.
find_map [BatList.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_min [BatHeap.H] | See `BatHeap.find_min`.
find_min [BatHeap] | Find the minimal element of the heap.
find_option [BatHashtbl.Cap] |
find_option [BatHashtbl.S] |
find_option [BatHashtbl] | Find a binding for the key, or return `None` if no value is found
findi [BatVect] | `findi p a` returns the index of the first element of array `a` that satisfies the predicate `p`.
findi [BatList.Labels.LExceptionless] |
findi [BatList.Labels] |
findi [BatList.Exceptionless] | `findi p e l` returns `Some (i, ai)` where `ai` and `i` are respectively the first element of `l` and its index, such that `p i ai` is true, or `None` if no such element has been found.
findi [BatList] | `findi p e l` returns the first element `ai` of `l` along with its index `i` such that `p i ai` is true, or raises `Not_found` if no such element has been found.
findi [BatLazyList.Labels.Exceptionless] |
findi [BatLazyList.Labels] |
findi [BatLazyList.Exceptionless] | `findi p e l` returns `Some (i, ai)` where `ai` and `i` are respectively the first element of `l` and its index, such that `p i ai` is true, or `None` if no such element has been found.
findi [BatLazyList] | `findi p e l` returns the first element `ai` of `l` along with its index `i` such that `p i ai` is true, or raises `Not_found` if no such element has been found.
findi [BatArray.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] | Convenience Functions
first [BatUTF8.Byte] |
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 [BatStd] | Projection of a pair to its first element.
first [BatSeq.Exceptionless] |
first [BatSeq] | Same as `BatSeq.hd`
first [BatRefList] | Returns the first element or raises `Empty_list` if the ref list is empty
first [BatPervasives] | Apply a function to the first element of a pair.
first [BatList] | Returns the first element of the list, or raise `Empty_list` if the list is empty (similar to `hd`).
first [BatLazyList] | As `hd`
flatten [BatSeq] | Same as `BatSeq.concat`.
flatten [BatList] | Same as `concat`.
flatten [BatLazyList] | Lazy concatenation of a list of lazy lists
flatten [BatEnum] | Synonym of `BatEnum.concat`
flip [BatStd] | Argument flipping.
flip [BatPervasives] | Argument flipping.
float [BatRandom.State] |
float [BatRandom] | `Random.float bound` returns a random floating-point number between 0 (inclusive) and `bound` (exclusive).
float [BatGenlex.Languages.Make] | Parse a floating-point number.
float32 [BatBigarray] | See `Bigarray.char`.
float64 [BatBigarray] | See `Bigarray.char`.
float_callback [BatOptParse.StdOpt] | See `OptParse.StdOpt.int_callback`.
float_dynarray [Batteries_print] |
float_of_big_int [BatBig_int] | Returns a floating-point number approximating the given big integer.
float_of_bits [BatInt64] | Return the floating-point number whose internal representation, according to the IEEE 754 floating-point ``double format'' bit layout, is the given `int64`.
float_of_bits [BatInt32] | Return the floating-point number whose internal representation, according to the IEEE 754 floating-point ``single format'' bit layout, is the given `int32`.
float_of_num [BatNum] |
float_option [BatOptParse.StdOpt] | See `OptParse.StdOpt.int_option`.
floor [BatNum] |
floor [BatFloat.Safe_float] | Round the given float to an integer value.
floor [BatFloat] | Round the given float to an integer value.
flush [BatPervasives] | Flush the buffer associated with the given output, performing all pending writes on that channel.
flush [BatInnerIO] | Flush an output.
flush [BatIO] | Flush an output.
flush_all [BatPervasives] | Write all pending data to output channels, ignore all errors.
flush_all [BatInnerIO] | Flush all outputs.
flush_all [BatIO] | Flush all outputs, ignore errors.
flush_bits [BatIO] | Flush remaining unwritten bits, adding up to 7 bits which values 0.
fold [BatVect.Make] | as `fold_left`
fold [BatVect] | `fold f a r` computes `f (... (f (f a r0) r1)...) rN-1` where `rn = Vect.get n r` and `N = length r`.
fold [BatStream.StreamLabels] |
fold [BatStream] | `fold` is `foldl` without initialization value, where the first element of stream is taken as `init`.
fold [BatSet.S.Labels] |
fold [BatSet.S] | `fold f s a` computes `(f xN ... (f 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 [BatRope] | `Rope.fold f a r` computes `f (... (f (f a r0) r1)...) rN-1` where `rn = Rope.get n r` and `N = length r`.
fold [BatPervasives] | Transformation loop on an enumeration, used to build a single value from an enumeration.
fold [BatPSet] |
fold [BatPMap] |
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 [BatMap.S.Labels] |
fold [BatMap.S] | `fold f m a` computes `(f kN dN ... (f k1 d1 (f k0 d0 a))...)`, where `k0,k1..kN` are the keys of all bindings in `m` (in increasing order), and `d1 ... dN` are the associated data.
fold [BatMap] | `fold f m a` computes `(f kN dN ... (f k1 d1 (f k0 d0 a))...)`, where `k0,k1..kN` are the keys of all bindings in `m`, and `d0,d1..dN` are the associated data.
fold [BatInnerWeaktbl] | `Weaktbl.fold f tbl init` computes `(f kN dN ... (f k1 d1 init)...)`, where `k1 ... kN` are the keys of all bindings in `tbl`, and `d1 ... dN` are the associated values.
fold [BatISet] |
fold [BatIMap] |
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 [BatEnum.Labels] |
fold [BatEnum] | A general loop on an enumeration.
fold [BatAvlTree] |
fold2 [BatEnum.Labels] |
fold2 [BatEnum] | `fold2` is similar to `fold` but will fold over two enumerations at the same time until one of the two enumerations ends.
fold2_range [BatIMap] |
fold2i [BatEnum.Labels] |
fold2i [BatEnum] |
fold_left [BatVect.Make] | `fold_left f a r` computes `f (... (f (f a r0) r1)...) rN` where `r0,r1..rN` are the indexed elements of `r`.
fold_left [BatVect] | `fold_left f a r` computes `f (... (f (f a r0) r1)...) rN-1` where `rn = Vect.get n r` and `N = length r`.
fold_left [BatSubstring] | `foldl f e sus` folds `f` over `sus` from left to right.
fold_left [BatString] | `fold_left f a s` is `f (... (f (f a s.[0]) s.[1]) ...) s.[n-1]`
fold_left [BatSeq] | `fold_left f a (cons 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 [BatLazyList.Labels] |
fold_left [BatLazyList] | Eager fold_left
fold_left [BatDynArray] | `fold_left f x darr` computes `f ( ... ( f ( f a0 x) a1) ) ... ) aN`, where `a0,a1..aN` are the indexed elements of `darr`.
fold_left [BatDllist] | Accumulate a value over the entire list.
fold_left [BatDeque] | `fold_left f acc dq` is equivalent to `List.fold_left f acc (to_list dq)`, but more efficient.
fold_left [BatArray.Cap.Labels] |
fold_left [BatArray.Cap] |
fold_left [BatArray.Labels] |
fold_left2 [BatList.Labels] |
fold_left2 [BatList] | `List.fold_left2 f a [b0; b1; ...; bn] [c0; c1; ...; cn]` is `f (... (f (f a b0 c0) b1 c1) ...) bn cn`.
fold_left2 [BatLazyList] | `fold_left2 f a [^ b0; b1; ...; bn ^] [^ c0; c1; ...; cn ^]` is `f (... (f (f a b0 c0) b1 c1) ...) bn cn`.
fold_lefti [BatArray] | As `fold_left`, but with a counter
fold_monad [BatEnum.WithMonad] | `fold_monad f init e` does a folding of the enumeration `e` applying step by step the function `f` that gives back results in the `Mon` monad, with the `init` initial element.
fold_range [BatISet] |
fold_range [BatIMap] |
fold_right [BatVect.RANDOMACCESS] |
fold_right [BatVect.Make] | `fold_right f r a` computes `f (r0 (f r1 ... (f rN a) ...))` where `r0,r1..rN` are the indexed elements of `r`.
fold_right [BatVect] | `fold_right f r a` computes `f (r0 ... (f rN-2 (f rN-1 a)) ...))` where `rn = Vect.get n r` and `N = length r`.
fold_right [BatSubstring] | `foldr f e sus` folds `f` over `sus` from right to left.
fold_right [BatString] | `fold_right f s b` is `f s.[0] (f s.[1] (... (f s.[n-1] b) ...))`
fold_right [BatSeq] | `fold_right f (cons 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 [BatDynArray] | `fold_right f darr x` computes `f a0 (f a1 ( ... ( f aN x ) ... ) )` , where `a0,a1..aN` are the indexed elements of `darr`.
fold_right [BatDllist] | Accumulate a value over the entire list.
fold_right [BatDeque] | `fold_right f dq acc` is equivalent to `List.fold_right f (to_list dq) acc`, but more efficient.
fold_right [BatArray.Cap.Labels] |
fold_right [BatArray.Cap] |
fold_right [BatArray.Labels] |
fold_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) ...))`.
foldi [BatVect] | As `BatVect.fold`, but with the position of each value passed to the folding function
foldi [BatPMap] |
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 [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] | `for_all p [a0; a1; ...; an]` checks if all elements of the array satisfy the predicate `p`.
for_all [BatSet.S.Labels] |
for_all [BatSet.S] | `for_all p s` checks if all elements of the set satisfy the predicate `p`.
for_all [BatSet] | Returns whether the given predicate applies to all elements in the set
for_all [BatSeq] | `for_all p (cons a0 (cons a1 ...))` checks if all elements of the given sequence satisfy the predicate `p`.
for_all [BatRefList] | Return `true` if all elements match the specified predicate
for_all [BatPervasives] | `exists f e` returns `true` if for every `x` in `e`, `f x` is true
for_all [BatPSet] |
for_all [BatPMap] |
for_all [BatMap.S] | `for_all p m` checks if all the bindings of the map satisfy the predicate `p`.
for_all [BatMap] | Tests whether all key value pairs satisfy some predicate function
for_all [BatList.Labels] |
for_all [BatLazyList.Labels] |
for_all [BatLazyList] | Eager universal.
for_all [BatISet] |
for_all [BatEnum.Labels] |
for_all [BatEnum] | `for_all f e` returns `true` if for every `x` in `e`, `f x` is true
for_all [BatDllist] | Test whether a given predicate returns true for all members of the given list.
for_all [BatArray.Cap.Labels] |
for_all [BatArray.Cap] | Predicates
for_all [BatArray.Labels] |
for_all [BatArray] | `for_all p [|a0; a1; ...; an|]` checks if all elements of the array satisfy the predicate `p`.
for_all2 [BatList.Labels] |
for_all2 [BatList] | Same as `List.for_all`, but for a two-argument predicate.
for_all2 [BatLazyList.Labels] |
for_all2 [BatLazyList] | Same as `BatLazyList.for_all`, but for a two-argument predicate.
for_all2 [BatArray] | As `Array.for_all` but on two arrays.
forall2_range [BatIMap] |
force [BatEnum] | `force e` forces the application of all lazy functions and the enumeration of all elements, exhausting the enumeration.
foreach [BatPervasives] | Imperative loop on an enumeration.
forever [BatStd] | `forever f x` invokes `f` on `x` repeatedly (until an exception occurs).
format_from_string [BatScanf] | `format_from_string s fmt` converts a string argument to a format string, according to the given format string `fmt`.
format_timestamp [BatLogger] | `format_timestamp oc timestamp` prints an ISO-8601 formatted timestamp (extended to specify higher-resolution seconds) to the output channel, `oc`.
formatter_of_out_channel [BatFormat] | `formatter_of_out_channel oc` returns a new formatter that writes to the corresponding channel `oc`.
formatter_of_output [BatFormat] | `formatter_of_output out` returns a new formatter that writes to the corresponding output `out`.
fortran_layout [BatBigarray] |
fourth [BatTuple.Tuple5] |
fourth [BatTuple.Tuple4] |
fprintf [BatPrintf] | General function.
fprintf [BatPrint] | General formatting function.
fprintf [BatInnerIO.Printf] | General function.
frexp [BatFloat.Safe_float] | `frexp f` returns the pair of the significant and the exponent of `f`.
frexp [BatFloat] | `frexp f` returns the pair of the significant and the exponent of `f`.
from [BatLazyList] | `from next` creates a (possibly infinite) lazy list from the successive results of `next`.
from [BatISet] |
from [BatIMap] |
from [BatEnum.Labels] |
from [BatEnum] | `from next` creates an enumeration from the `next` function.
from_channel [BatScanf.Scanning] |
from_channel [BatMarshal] |
from_channel [BatLexing] |
from_file [BatScanf.Scanning] | Bufferized file reading in text mode.
from_file_bin [BatScanf.Scanning] | Bufferized file reading in binary mode.
from_function [BatScanf.Scanning] | `Scanning.from_function f` returns a scanning buffer with the given function as its reading method.
from_in_channel [BatIO] |
from_in_chars [BatIO] |
from_input [BatScanf.Scanning] | `Scanning.from_channel ic` returns a scanning buffer which reads from the input channel `ic`, starting at the current reading position.
from_input [BatLexing] | Create a lexer buffer on the given input `Lexing.from_input inp` returns a lexer buffer which reads from the input `inp`, at the current reading position.
from_loop [BatLazyList] | `from_loop data next` creates a (possibly infinite) lazy list from the successive results of applying `next` to `data`, then to the result, etc.
from_loop [BatEnum.Labels] |
from_loop [BatEnum] | `from_loop data next` creates a (possibly infinite) enumeration from the successive results of applying `next` to `data`, then to the result, etc.
from_out_channel [BatIO] |
from_out_chars [BatIO] |
from_string [BatScanf.Scanning] | `Scanning.from_string s` returns a scanning buffer which reads from the given string.
from_while [BatLazyList] | `from next` creates a (possibly infinite) lazy list from the successive results of `next`.
from_while [BatEnum.Labels] |
from_while [BatEnum] | `from_while next` creates an enumeration from the `next` function.
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.
fscanf [BatScanf] | Same as `Scanf.bscanf`, but reads from the given channel.
fsum [BatList] | `sum l` returns the sum of the elements of `l`
full_init [BatRandom] | Same as `Random.init` but takes more data as seed.
full_range [BatRandom] | `Random.full_range ()` returns the maximum entropy possible in a single int: 31 bits on 32-bit platforms and 63 bits on 64-bit platforms
G
ge_big_int [BatBig_int] |
ge_num [BatNum] |
genarray_of_array1 [BatBigarray] | Return the generic big array corresponding to the given one-dimensional big array.
genarray_of_array2 [BatBigarray] | Return the generic big array corresponding to the given two-dimensional big array.
genarray_of_array3 [BatBigarray] | Return the generic big array corresponding to the given three-dimensional big array.
get [BatVect.RANDOMACCESS] |
get [BatVect.Make] | `get n r` returns the element at index `n` (starting from 0) in the vect `r`.
get [BatVect] | `get v n` returns the (n+1)th element from the vect `v`; i.e.
get [BatUTF8] | `get s n` returns the `n`-th Unicode character of `s`.
get [BatSubstring] | `sub sus k` returns the k'th character of the substring; that is, s(i+k) where sus = (s, i, n).
get [BatRope] | `get r n` returns the (n+1)th character from the rope `r`; i.e.
get [BatRef] | As `!`
get [BatPervasives] | `get e` returns `None` if `e` is empty or `Some x` where `x` is the next element of `e`, in which case the element is removed from the enumeration.
get [BatPathGen.StringType] | Usual get function.
get [BatOption] | `get (Some x)` returns `x` and `get None` raises `No_value`.
get [BatOptParse.Opt] | Get the value of an option.
get [BatLazyList] | `get l` returns the head and tail of `l`, if `l` is not empty.
get [BatGlobal] | Get the global value contents - raise Global_not_initialized if not defined.
get [BatEnum] | `get e` returns `None` if `e` is empty or `Some x` where `x` is the next element of `e`, in which case the element is removed from the enumeration.
get [BatDynArray] | `get darr idx` gets the element in `darr` at index `idx`.
get [BatDllist] | Given a node, get the data associated with that node.
get [BatBigarray.Array3] | `Array3.get a x y z`, also written `a.{x,y,z}`, returns the element of `a` at coordinates (`x`, `y`, `z`).
get [BatBigarray.Array2] | `Array2.get a x y`, also written `a.{x,y}`, returns the element of `a` at coordinates (`x`, `y`).
get [BatBigarray.Array1] | `Array1.get a x`, or alternatively `a.{x}`, returns the element of `a` at index `x`.
get [BatBigarray.Genarray] | Read an element of a generic big array.
get [BatArray.Cap] |
get_exn [BatOption] | `get_exn (Some x) e` returns `x` and `get_exn None e` raises `e`.
get_method [BatOo.Oo.Internal] |
get_method_label [BatOo.Oo.Internal] |
get_method_labels [BatOo.Oo.Internal] |
get_public_method [BatOo.Oo.Internal] |
get_resizer [BatDynArray] | Get the current resizer function for a given array
get_state [BatRandom] | Return the current state of the generator used by the basic functions.
get_state [BatParserCo.Source] |
get_variable [BatOo.Oo.Internal] |
get_variables [BatOo.Oo.Internal] |
getc [BatSubstring] | `getc sus` returns `Some(c, rst)` where `c` is the first character and `rst` the remainder of `sus`, if `sus` is non-empty; otherwise returns `None`.
group [BatList] | `group cmp l` returns list of groups and each group consists of elements judged equal by comparison function `cmp`.
group [BatEnum] | `group test e` divides `e` into an enumeration of enumerations, where each sub-enumeration is the longest continuous enumeration of elements whose `test` results are the same.
group_by [BatEnum] | `group_by eq e` divides `e` into an enumeration of enumerations, where each sub-enumeration is the longest continuous enumeration of elements that are equal, as judged by `eq`
group_exec [BatFile] | Give the permission to execute the file to the group containing the user.
group_read [BatFile] | Give the permission to read the file to the group containing the user.
group_write [BatFile] | Give the permission to write the file to the group containing the user.
gt_big_int [BatBig_int] | Usual boolean comparisons between two big integers.
gt_num [BatNum] |
H
handle [BatArg] | `Arg.handle commands` parses the command-line and applies the specifications of `commands` and returns the list of anonymous arguments.
hard_count [BatEnum] | `hard_count` returns the number of remaining in elements in `e`, consuming the whole enumeration somewhere along the way.
hash [BatInnerIO.Output] | A hash function for outputs
hash [BatInnerIO.Input] | A hash function for inputs
hash [BatHashtbl.HashedType] | A hashing function on keys.
hash [BatHashtbl] | `Hashtbl.hash x` associates a positive integer to any value of any type.
hash_param [BatHashtbl] | `Hashtbl.hash_param n m x` computes a hash value for `x`, with the same properties as for `hash`.
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 `k`th constructor applied to the hashed object `ho`.
hc1_ [BatHashcons.H] | `hc1_ h k` corresponds to the hashcode of the `k`th 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 [BatLazyList] | Return the first element of the given list.
head [BatString] | as `BatString.left`
head [BatRope] | as `BatRope.left`
height [BatVect.Make] | Returns the height (depth) of the vect.
height [BatVect] | Returns the height (depth) of the vect.
height [BatRope] | Returns the height (depth) of the rope.
height [BatAvlTree] |
help_option [BatOptParse.StdOpt] | `help_option ()` returns the standard help option which displays a usage message and exits the program when encountered on the command line.
hex [BatUCharParser] | Recognizes one hexadecimal digit (case-insensitive)
hex [BatCharParser] | Recognizes one hexadecimal digit (case-insensitive)
I
i [BatComplex] | The complex number `i`.
i16s_of [BatIO.BigEndian] | Read an enumartion of signed 16-bit words.
i16s_of [BatIO] | Read an enumartion of signed 16-bit words.
i32s_of [BatIO.BigEndian] | Read an enumeration of signed 32-bit integers.
i32s_of [BatIO] | Read an enumeration of signed 32-bit integers.
i64s_of [BatIO.BigEndian] | Read an enumeration of signed 64-bit integers as OCaml `int64`s.
i64s_of [BatIO] | Read an enumeration of signed 64-bit integers as OCaml `int64`s.
icompare [BatUChar] | Compare two unicode characters, case-insensitive.
icompare [BatString] | Compare two strings, case-insensitive.
icompare [BatRope] | Compare two ropes, case-insensitive.
id [BatOo.Oo] | Return an integer identifying this object, unique for the current execution of the program.
ident [BatGenlex.Languages.Make] | Accepts any non-reserved identifier/operator.
ident_letter [BatGenlex.Languages.Definition] |
ident_start [BatGenlex.Languages.Definition] |
identifier [BatGenlex.Languages.Make] |
identity [BatStd] | the identity function.
identity [BatPervasives] | The identity function.
ifprintf [BatPrintf] | As `BatPrintf.fprintf` but doesn't actually print anything.
ifprintf [BatPrint] | As `BatPrint.fprintf` but doesn't actually print anything.
ifprintf [BatInnerIO.Printf] | As `BatInnerIO.Printf.fprintf` but doesn't actually print anything.
ignore_exceptions [BatStd] | `ignore_exceptions f x` invokes `f` on `x`, ignoring both the returned value and the exceptions that may be raised.
ignore_ok [BatStd] | `ignore_ok (f x)` ignores the result of `f x` if it's ok, but throws the exception contained if `Bad` is returned.
ignore_one_plus [BatParserCo] | Ignore a (non-empty) list of expressions.
ignore_zero_plus [BatParserCo] | Ignore a (possibly empty) list of expressions.
implode [BatString] | `implode cs` returns a string resulting from concatenating the characters in the list `cs`.
implode [BatRope] | `implode cs` returns a rope resulting from concatenating the characters in the list `cs`.
in_channel_of_descr [BatUnix] |
incr_option [BatOptParse.StdOpt] | Exactly identical to `count_option ~dest:dest ~increment:1 ()`.
indented_formatter [BatOptParse.Formatter] | Create an "indented" formatter with the given options.
index [BatUTF8] | As `String.index`
index [BatRope] | `Rope.index s c` returns the position of the leftmost occurrence of character `c` in rope `s`.
index [BatRefList.Index] | Return the index (position : 0 starting) of an element in a ref list, using the specified comparator raise `Not_found` if no element was found
index_from [BatRope] | Same as `Rope.index`, but start searching at the character position given as second argument.
index_of [BatRefList.Index] | Return the index (position : 0 starting) of an element in a ref list, using ( = ) for testing element equality raise `Not_found` if no element was found
index_of [BatList] | `index_of e l` returns the index of the first occurrence of `e` in `l`, or `None` if there is no occurrence of `e` in `l`
index_of [BatLazyList] | `index_of e l` returns the index of the first occurrence of `e` in `l`, or `None` if there is no occurrence of `e` in `l`
index_of [BatDynArray] | `index_of f darr` returns the index of the first element `x` in darr such as `f x` returns `true` or raise `Not_found` if not found.
index_ofq [BatList] | `index_ofq e l` behaves as `index_of e l` except it uses physical equality
index_ofq [BatLazyList] | `index_ofq e l` behaves as `index_of e l` except it uses physical equality
infinity [BatFloat.Safe_float] | Positive infinity.
infinity [BatFloat] | Positive infinity.
inherit_in [BatInnerIO] | Simplified and optimized version of `BatInnerIO.wrap_in` whenever only one input appears as dependency.
inherit_in [BatIO] | Simplified and optimized version of `BatIO.wrap_in` which may be used whenever only one input appears as dependency.
inherit_out [BatInnerIO] | Simplified and optimized version of `BatInnerIO.wrap_out` whenever only one output appears as dependency.
inherit_out [BatIO] | Simplified and optimized version of `BatIO.wrap_out` whenever only one output appears as dependency.
inherits [BatOo.Oo.Internal] |
init [BatVect] | `init n f` returns a fresh vect of length `n`, with element number `i` initialized to the result of `f i`.
init [BatUTF8] | `init len f` returns a new string which contains `len` Unicode characters.
init [BatString] | `init l f` returns the string of length `l` with the chars f 0 , f 1 , f 2 ...
init [BatSeq] | `init n f` returns the sequence returning the results of `f 0`, `f 1`....
init [BatRope] | `init l f` returns the rope of length `l` with the chars f 0 , f 1 , f 2 ...
init [BatRandom] | Initialize the generator, using the argument as a seed.
init [BatLogger] | `init name_level_list formatter` initializes the logging system enabling the specified levels for each named logger.
init [BatList.Labels] |
init [BatList] | Similar to `Array.init`, `init n f` returns the list containing the results of (f 0),(f 1)....
init [BatLazyList] | Similar to `Array.init`, `init n f` returns the lazy list containing the results of (f 0),(f 1)....
init [BatEnum.Labels] |
init [BatEnum] | `init n f` creates a new enumeration over elements `f 0, f 1, ..., f (n-1)`
init [BatDynArray] | `init n f` returns an array of `n` elements filled with values returned by `f 0 , f 1, ... f (n-1)`.
init [BatArray.Cap.Labels] |
init [BatArray.Cap] |
init [BatArray.Labels] |
init_class [BatOo.Oo.Internal] |
init_from_string [BatLogger] | `init_from_string name_level_string formatter` initializes the logging system enabling the specified levels for each named logger.
input [BatPervasives] | `input ic buf pos len` reads up to `len` characters from the given channel `ic`, storing them in string `buf`, starting at character number `pos`.
input [BatMarshal] | `input inp` reads from `inp` the byte representation of a structured value, as produced by one of the `Marshal.to_*` functions, and reconstructs and returns the corresponding value.
input [BatInnerIO] | `input i s p l` reads up to `l` characters from the given input, storing them in string `s`, starting at character number `p`.
input [BatIO] | `input i s p l` reads up to `l` characters from the given input, storing them in string `s`, starting at character number `p`.
input [BatDigest] | Read a digest from the given input.
input_binary_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_enum [BatIO] | Create an input that will read from an `enum`.
input_file [BatStd] | returns the data of a given filename.
input_line [BatPervasives] | Read characters from the given input channel, until a newline character is encountered.
input_of_descr [BatUnix] | Create an `input` reading from the given descriptor.
input_string [BatInnerIO] | Create an input that will read from a string.
input_string [BatIO] | Create an input that will read from a string.
input_value [BatPervasives] | Read the representation of a structured value, as produced by `BatPervasives.output_value`, and return the corresponding value.
insert [BatVect.Make] | `insert n r u` returns a copy of the `u` vect where `r` has been inserted between the elements with index `n` and `n + 1` in the original vect.
insert [BatVect] | `insert n r u` returns a copy of the `u` vect where `r` has been inserted between the elements with index `n` and `n + 1` in the original vect.
insert [BatRope] | `insert n r u` returns a copy of the `u` rope where `r` has been inserted between the characters with index `n` and `n + 1` in the original rope.
insert [BatHeap.H] | See `BatHeap.add`.
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.State] |
int [BatRandom] | `Random.int bound` returns a random integer between 0 (inclusive) and `bound` (exclusive).
int [BatBigarray] | See `Bigarray.char`.
int16_signed [BatBigarray] | See `Bigarray.char`.
int16_unsigned [BatBigarray] | See `Bigarray.char`.
int32 [BatRandom.State] |
int32 [BatRandom] | `Random.int32 bound` returns a random integer between 0 (inclusive) and `bound` (exclusive).
int32 [BatBigarray] | See `Bigarray.char`.
int64 [BatRandom.State] |
int64 [BatRandom] | `Random.int64 bound` returns a random integer between 0 (inclusive) and `bound` (exclusive).
int64 [BatBigarray] | See `Bigarray.char`.
int8_signed [BatBigarray] | See `Bigarray.char`.
int8_unsigned [BatBigarray] | See `Bigarray.char`.
int_callback [BatOptParse.StdOpt] | `int_callback ?metavar f` returns an option which takes a single integer argument and calls `f` with that argument when encountered on the command line.
int_dynarray [Batteries_print] |
int_enum [Batteries_print] |
int_of_big_int [BatBig_int] | Convert a big integer to a small integer (type `int`).
int_option [BatOptParse.StdOpt] | `int_option ?default ?metavar ()` returns an option which takes a single integer argument.
int_pset [Batteries_print] |
int_set [Batteries_print] |
integer [BatGenlex.Languages.Make] | Parse an integer.
inter [BatSet.S] | Set intersection.
inter [BatISet] |
inter [BatBitSet] | `inter s t` returns the intersection of sets `s` and `t`.
interleave [BatList] | `interleave ~first ~last sep [a0;a1;a2;...;an]` returns `first; a0; sep; a1; sep; a2; sep; ...; sep; an`
intersect [BatSet] | `intersect s t` returns a new set of those elements that are in both `s` and `t`.
intersect [BatPSet] |
intersect [BatPMap] |
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`).
irope_set [Batteries_print] |
is_absolute [BatPathGen.PathType] |
is_digit [BatChar] | Determine if a character represents a digit.
is_directory [BatUnix] | `is_directory filename` returns true if `filename` refers to a directory (or symlink of a directory)
is_empty [BatVect.Make] | Returns whether the vect is empty or not.
is_empty [BatVect] | Returns whether the vect is empty or not.
is_empty [BatSubstring] | `isEmpty (s, i, n)` true if the substring is empty (that is, `n = 0`).
is_empty [BatString] | `is_empty s` returns `true` if `s` is the empty string, `false` otherwise.
is_empty [BatStream] | `is_empty stream` tests whether `stream` is empty.
is_empty [BatSet.S] | Test whether a set is empty or not.
is_empty [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 [BatRope] | Returns whether the rope is empty or not.
is_empty [BatRefList] | Return `true` if a ref list is empty
is_empty [BatPSet] |
is_empty [BatPMap] |
is_empty [BatMultiPMap] | 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] |
is_empty [BatIMap] |
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 [BatEnum] | `is_empty e` returns true if `e` does not contains any element.
is_empty [BatDeque] | `is_empty dq` returns `false` iff `dq` has no elements.
is_empty [BatAvlTree] |
is_int_big_int [BatBig_int] | Test whether the given big integer is small enough to be representable as a small integer (type `int`) without loss of precision.
is_integer [BatNum] | `is_integer x` returns `true` if `x` represents an integer value, `false` otherwise
is_latin1 [BatChar] | Determine if a character is a Latin 1 letter.
is_letter [BatChar] | Determine if a character represents a ASCII letter.
is_lowercase [BatUChar] | Determine if a character is an lowercase character.
is_lowercase [BatChar] | Determine if a character is lowercase ASCII.
is_lowercase_latin1 [BatChar] | Determine if a character is lowercase Latin 1.
is_nan [BatFloat.Safe_float] | `is_nan f` returns `true` if `f` is `nan`, `false` otherwise.
is_nan [BatFloat] | `is_nan f` returns `true` if `f` is `nan`, `false` otherwise.
is_newline [BatUChar] | Determine if a character is a newline.
is_newline [BatChar] | Determine if a character is a newline.
is_none [BatOption] | `is_none None` returns `true` otherwise it returns `false`.
is_prefix [BatSubstring] | `is_prefix s1 s2` is true if `s1` is a prefix of `s2`.
is_relative [BatPathGen.PathType] |
is_set [BatOptParse.Opt] | Find out if the option has a value (either by default or from the command line).
is_set [BatBitSet] | `is_set s n` returns true if nth-bit in the bitset `s` is set, or false otherwise.
is_some [BatOption] | `is_some (Some x)` returns `true` otherwise it returns `false`.
is_symbol [BatChar] | Determine if a character represents a (OCaml-style) symbol.
is_uppercase [BatUChar] | Determine if a character is an uppercase character.
is_uppercase [BatChar] | Determine if a character is uppercase ASCII.
is_uppercase_latin1 [BatChar] | Determine if a character is uppercase Latin 1.
is_whitespace [BatUChar] | Determine if a character is a whitespace.
is_whitespace [BatChar] | Determine if a character is a whitespace.
isdef [BatGlobal] | Return `true` if the global value has been set.
istring_set [Batteries_print] |
iter [BatVect.RANDOMACCESS] |
iter [BatVect.Make] | `iter f r` applies `f` to all the elements in the `r` vect, in order.
iter [BatVect] | `iter f r` applies `f` to all the elements in the `r` vect, in order.
iter [BatUTF8] | `iter f s` applies `f` to all Unicode characters in `s`.
iter [BatSubstring] | `iter f sus` applies `f` to all characters of `sus`, from left to right.
iter [BatStream.StreamLabels] |
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 [BatRope] | `iter f r` applies `f` to all the characters in the `r` rope, in order.
iter [BatRefList] | Apply the given function to all elements of the ref list, in respect with the order of the list
iter [BatPervasives] | Imperative loop on an enumeration.
iter [BatPathGen.StringType] |
iter [BatPSet] |
iter [BatPMap] |
iter [BatMultiPMap] | `iter f m` applies `f` to all bindings in map `m`.
iter [BatMap.S.Labels] |
iter [BatMap.S] | `iter f m` applies `f` to all bindings in map `m`.
iter [BatMap] | `iter f m` applies `f` to all bindings in map `m`.
iter [BatList.Labels] |
iter [BatLazyList.Labels] |
iter [BatLazyList] | Eager iteration
iter [BatInnerWeaktbl] | `Weaktbl.iter f tbl` applies `f` to all bindings in table `tbl`.
iter [BatISet] |
iter [BatIMap] |
iter [BatHashtbl.Cap.Labels] |
iter [BatHashtbl.Cap] | Traversing
iter [BatHashtbl.S.Labels] |
iter [BatHashtbl.S] |
iter [BatHashtbl.Labels] |
iter [BatHashtbl] | `Hashtbl.iter f tbl` applies `f` to all bindings in table `tbl`.
iter [BatHashcons.Table] | `iter f tab` applied `f` to every live hashed object in the table `tab`.
iter [BatEnum.Labels] |
iter [BatEnum] | `iter f e` calls the function `f` with each elements of `e` in turn.
iter [BatDynArray] | `iter f darr` calls the function `f` on every element of `darr`.
iter [BatDllist] | `iter f n` Apply `f` to every element in the list, starting at `n`.
iter [BatDeque] | `iter f dq` calls `f x` on each element `x` of `dq`.
iter [BatBigarray.Genarray] | `iter f a` applies function `f` in turn to all the elements of `a`.
iter [BatAvlTree] |
iter [BatArray.Cap.Labels] |
iter [BatArray.Cap] | Iterators
iter [BatArray.Labels] |
iter2 [BatList.Labels] |
iter2 [BatList] | `List.iter2 f [a0; a1; ...; an] [b0; b1; ...; bn]` calls in turn `f a0 b0; f a1 b1; ...; f an bn`.
iter2 [BatLazyList.Labels] |
iter2 [BatLazyList] | `iter2 f [^ a0; ...; an ^] [^ b0; ...; bn ^]` calls in turn `f a0 b0; ...; f an bn`.
iter2 [BatEnum.Labels] |
iter2 [BatEnum] | `iter2 f e1 e2` calls the function `f` with the next elements of `e1` and `e2` repeatedly until one of the two enumerations ends.
iter2 [BatArray.Cap.Labels] |
iter2 [BatArray.Cap] | Operations on two arrays
iter2 [BatArray.Labels] |
iter2 [BatArray] | `Array.iter2 f [|a0; a1; ...; an|] [|b0; b1; ...; bn|]` performs calls `f a0 b0; f a1 b1; ...; f an bn` in that order.
iter2i [BatEnum.Labels] |
iter2i [BatEnum] |
iter2i [BatArray.Cap.Labels] |
iter2i [BatArray.Cap] |
iter2i [BatArray.Labels] |
iter2i [BatArray] | `Array.iter2i f [|a0; a1; ...; an|] [|b0; b1; ...; bn|]` performs calls `f 0 a0 b0; f 1 a1 b1; ...; f n an bn` in that order.
iter_range [BatISet] |
iter_range [BatIMap] |
iteri [BatVect.Make] | Operates like iter, but also passes the index of the character to the given function.
iteri [BatVect] | Operates like iter, but also passes the index of the character to the given function.
iteri [BatString] | `String.iteri f s` is equivalent to `f 0 s.[0]; f 1 s.[1]; ...; f len s.[len]` where `len` is length of string `s`.
iteri [BatRope] | Operates like `iter`, but also passes the index of the character to the given function.
iteri [BatPathGen.StringType] |
iteri [BatList.Labels] |
iteri [BatList] | `iteri f l` will call `(f 0 a0);(f 1 a1) ... (f n an)` where `a0..an` are the elements of the list `l`.
iteri [BatLazyList.Labels] |
iteri [BatLazyList] | Eager iteration, with indices
iteri [BatEnum.Labels] |
iteri [BatEnum] |
iteri [BatDynArray] | `iter f darr` calls the function `f` on every element of `darr`.
iteri [BatDeque] | `iteri f dq` calls `f n x` on each element `x` of `dq`.
iteri [BatBigarray.Genarray] | Same as `BatBigarray.Genarray.iter`, but the function is applied to the index of the element as the first argument, and the element itself as the second argument.
iteri [BatArray.Cap.Labels] |
iteri [BatArray.Cap] |
iteri [BatArray.Labels] |
J
join [BatUTF8] | as `concat`
join [BatString] | Same as `concat`
join [BatRope] | Same as `BatRope.concat`
join [BatPathGen.PathType] | Create a path from given components.
junk [BatPervasives] | `junk e` removes the first element from the enumeration, if any.
junk [BatEnum] | `junk e` removes the first element from the enumeration, if any.
K
kbprintf [BatPrintf] | Same as `bprintf`, but instead of returning immediately, passes the buffer to its first argument at the end of printing.
kbprintf [BatPrint] | `bprintf k buf fmt` prints into the buffer `buf`, then call `k` with `buf` as argument.
kbprintf [BatInnerIO.Printf] | Same as `bprintf`, but instead of returning immediately, passes the buffer to its first argument at the end of printing.
kbprintf2 [BatPrintf] | Same as `bprintf2`, but instead of returning immediately, passes the buffer to its first argument at the end of printing.
kbprintf2 [BatInnerIO.Printf] | Same as `bprintf2`, but instead of returning immediately, passes the buffer to its first argument at the end of printing.
keep [BatDynArray] | `keep p darr` removes in place all the element `x` of `darr` such that `p x = false`
keys [BatPMap] |
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 [BatPrint] | `kfprintf k oc fmt` prints on `oc` then call `k` with `oc` as argument
kfprintf [BatInnerIO.Printf] | Functions with continuations
kind [BatBigarray.Array3] | Return the kind of the given big array.
kind [BatBigarray.Array2] | Return the kind of the given big array.
kind [BatBigarray.Array1] | Return the kind of the given big array.
kind [BatBigarray.Genarray] | Return the kind of the given big array.
kprintf [BatPrintf] |
kprintf [BatInnerIO.Printf] |
krprintf [BatPrint] | `krprintf k fmt` creates a rope from the format and other arguments and pass it to `k`
kscanf [BatScanf] | Same as `Scanf.bscanf`, but takes an additional function argument `ef` that is called in case of error: if the scanning process or some conversion fails, the scanning function aborts and calls the error handling function `ef` with the scanning buffer and the exception that aborted the scanning process.
ksprintf [BatPrintf] | Same as `sprintf` above, but instead of returning the string, passes it to the first argument.
ksprintf [BatPrint] | `ksprintf k fmt` creates a string from the format and other arguments and pass it to `k`
ksprintf [BatInnerIO.Printf] | Same as `sprintf` above, but instead of returning the string, passes it to the first argument.
ksprintf2 [BatPrintf] | Same as `sprintf2` above, but instead of returning the string, passes it to the first argument.
ksprintf2 [BatInnerIO.Printf] | Same as `sprintf2` above, but instead of returning the string, passes it to the first argument.
kwd [BatGenlex.Languages.Make] | Accepts any identifier.
L
label [BatReturn] | `label f` creates a new label `x` and invokes `f x`.
label [BatParserCo] | Give a name to a parser, for debugging purposes.
last [BatVect] | These return the first and last values in the vector
last [BatUTF8.Byte] |
last [BatSeq.Exceptionless] |
last [BatSeq] | Returns the last element of the sequence, or raise `Invalid_argument` if the sequence is empty.
last [BatRefList] | Returns the last element - O(n) or raises Empty_list if the ref list is empty
last [BatList] | Returns the last element of the list, or raise `Empty_list` if the list is empty.
last [BatLazyList] | Returns the last element of the list, or raise `Empty_list` if the list is empty.
last [BatDynArray] | `last darr` returns the last element of `darr`.
latin1 [BatCharParser] | Recognizes one lower- or upper-case Latin1 character, including accentuated characters.
layout [BatBigarray.Array3] | Return the layout of the given big array.
layout [BatBigarray.Array2] | Return the layout of the given big array.
layout [BatBigarray.Array1] | Return the layout of the given big array.
layout [BatBigarray.Genarray] | Return the layout of the given big array.
lchop [BatString] | Returns the same string but without the first `n` characters.
lchop [BatRope] | Returns the same rope but without the first character.
ldexp [BatFloat.Safe_float] | `ldexp x n` returns `x *. 2 ** n`.
ldexp [BatFloat] | `ldexp x n` returns `x *. 2 ** n`.
le_big_int [BatBig_int] |
le_num [BatNum] |
left [BatString] | `left r len` returns the string containing the `len` first characters of `r`.
left [BatRope] | `left r len` returns the rope containing the `len` first characters of `r`
left_branch [BatAvlTree] |
length [BatVect.RANDOMACCESS] |
length [BatVect.Make] | Returns the length of the vect (`O(1)`).
length [BatVect] | Returns the length of the vect (`O(1)`).
length [BatUTF8] | `length s` returns the number of Unicode characters contained in s
length [BatSubstring] | Equivalent to `BatSubstring.size`.
length [BatSeq] | Return the number of elements of the given sequence.
length [BatRope] | Returns the length of the rope (`O(1)`).
length [BatRefList] | Returns the number of elements - O(n)
length [BatPathGen.StringType] | Length - number of indexing units
length [BatLazyList] | Return the length (number of elements) of the given list.
length [BatInnerWeaktbl] | `Weaktbl.length tbl` returns the number of bindings in `tbl`.
length [BatHashtbl.Cap] | Base operations
length [BatHashtbl.S] |
length [BatHashtbl] | `Hashtbl.length tbl` returns the number of bindings in `tbl`.
length [BatDynArray] | Return the number of elements in the array.
length [BatDllist] | Returns the length of the list.
length [BatArray.Cap] |
length0 [BatUTF8] | UTF8 encoding often calls for the encoding of a Unicode character with several bytes.
letter [BatUCharParser] | Recognizes one lower- or upper-case character.
letter [BatPathGen.StringType.Parse] |
letter [BatCharParser] | Recognizes one lower- or upper-case ASCII character, including accentuated characters.
level_of_name [BatLogger] | `level_of_name str` returns the `level` associated with `str`.
lift [BatPathGen.StringType] | Convert from UTF-8 string of primitive `string` type.
lift_char [BatPathGen.StringType] | Convert Latin-1 character to `tchar`.
line_comment [BatGenlex.Languages.Make] |
line_comment_start [BatGenlex.Languages.Definition] |
lines_of [BatIO] | Read an enumeration of LF or CRLF terminated strings.
lines_of [BatFile] | `line_of name` reads the contents of file `name` as an enumeration of lines.
literal [BatPrint] | `literal str` create a directive which do not take any argument from a literal string
lock [BatUnix] | A lock used to synchronize internal operations.
lock [BatStd] | A lock used to synchronize internal operations.
lock [BatRMutex] | Lock the given mutex.
lock [BatPervasives] | A lock used to synchronize internal operations.
lock [BatMutex.Mutex] | Lock the given mutex.
lock [BatIO] | A lock used to synchronize internal operations.
lock [BatConcurrent.BaseLock] |
lock [BatConcurrent.Lock] |
lock_factory [BatIO] | A factory used to create locks.
log [BatLogger] | `log logger level event_fun` raises a log event if if the specified level is currently enabled for the logger.
log [BatFloat.Safe_float] | Natural logarithm.
log [BatFloat] | Natural logarithm.
log [BatComplex] | Natural logarithm (in base `e`).
log10 [BatFloat.Safe_float] | Base 10 logarithm.
log10 [BatFloat] | Base 10 logarithm.
log_enable [BatLogger] | `log_enable logger level` enables a log level for a logger.
log_enabled [BatLogger] | `log_enabled logger level` returns true if the specified level is currently enabled for the logger.
log_level [BatLogger] | `log_level logger` returns the currently enabled level for a logger.
log_name [BatLogger] | `log_name logger` returns the name of the logger.
logand [BatNativeint] | Bitwise logical and.
logand [BatInt64] | Bitwise logical and.
logand [BatInt32] | Bitwise logical and.
lognot [BatNativeint] | Bitwise logical negation
lognot [BatInt64] | Bitwise logical negation
lognot [BatInt32] | Bitwise logical negation
logor [BatNativeint] | Bitwise logical or.
logor [BatInt64] | Bitwise logical or.
logor [BatInt32] | Bitwise logical or.
logxor [BatNativeint] | Bitwise logical exclusive or.
logxor [BatInt64] | Bitwise logical exclusive or.
logxor [BatInt32] | Bitwise logical exclusive or.
look [BatUTF8] | `look s i` returns the Unicode character of the location `i` in the string `s`.
lookahead [BatParserCo] | `lookahead p` behaves as `maybe p` but without consuming anything
lookup_tables [BatOo.Oo.Internal] |
lowercase [BatUTF8] | Return a copy of the argument, with all uppercase letters translated to lowercase.
lowercase [BatUCharParser] | Recognizes one lower-case character, including accentuated characters.
lowercase [BatUChar] | Convert the given character to its equivalent lowercase character.
lowercase [BatRope] | `lowercase s` returns a lowercase copy of rope `s`.
lowercase [BatPervasives] | Return a copy of the argument, with all uppercase letters translated to lowercase, including accented letters of the ISO Latin-1 (8859-1) character set.
lowercase [BatCharParser] | Recognizes one lower-case ASCII character, including accentuated characters.
lowercase_latin1 [BatCharParser] | Recognizes one lower-case Latin-1 character, including accentuated characters.
lru_cache [BatCache] |
lt_big_int [BatBig_int] |
lt_num [BatNum] |
M
make [BatVect.RANDOMACCESS] |
make [BatVect.Make] | `make i c` returns a vect of length `i` whose elements are all equal to `c`; it is similar to Array.make
make [BatVect] | `make i c` returns a vect of length `i` whose elements are all equal to `c`; it is similar to Array.make
make [BatUTF8] | As `String.make`
make [BatSubstring] |
make [BatSeq] | `make n e` returns the sequence of length `n` where all elements are `e`
make [BatRope] | `make i c` returns a rope of length `i` consisting of `c` chars; it is similar to String.make
make [BatRandom.State] | Create a new state and initialize it with the given seed.
make [BatRMutex] | Create a new abstract lock based on Reentrant Mutexes.
make [BatOptParse.OptParser] | Creates a new option parser with the given options.
make [BatMutex.Mutex] | Create a new abstract lock based on Mutexes.
make [BatList] | Similar to `String.make`, `make n x` returns a list containing `n` elements `x`.
make [BatLazyList] | Similar to `String.make`, `make n x` returns a list containing `n` elements `x`.
make [BatEnum] | This function creates a fully defined enumeration.
make [BatDynArray] | `make count` returns an array with some memory already allocated so up to `count` elements can be stored into it without resizing.
make [BatConcurrent.Lock] |
make [BatArray.Cap.Labels] |
make [BatArray.Cap] | Constructors
make_class [BatOo.Oo.Internal] |
make_class_store [BatOo.Oo.Internal] |
make_compare [BatList] | `make_compare c` generates the lexicographical order on lists induced by `c`
make_compare [BatArray.Cap] | Utilities
make_compare [BatArray] | `make_compare c` generates the lexicographical order on arrays induced by `c`.
make_dbg_formatter [BatLogger] | `make_dbg_formatter oc` constructs a debug formatter from an output channel.
make_decoding_table [BatBase64] | Create a valid decoding table from an encoding one.
make_ht [BatCache] |
make_log [BatLogger] | `make_log name` returns a new logger.
make_map [BatCache] | These functions build a cache with either a hashtbl or a map.
make_matrix [BatArray.Cap.Labels] |
make_matrix [BatArray.Cap] |
make_matrix [BatArray.Labels] |
make_self_init [BatRandom.State] | Create a new state and initialize it with a system-dependent low-entropy seed.
make_std_formatter [BatLogger] | `make_std_formatter oc` constructs a formatter from an output channel.
make_tree [BatAvlTree] |
map [BatVect.RANDOMACCESS] |
map [BatVect.Make] | `map f v` returns a vect isomorphic to `v` where each element of index `i` equals `f (get v i)`.
map [BatVect] | `map f v` returns a vect isomorphic to `v` where each element of index `i` equals `f (get v i)`.
map [BatUTF8] | As `String.map`
map [BatTuple.Tuple5] |
map [BatTuple.Tuple4] |
map [BatTuple.Tuple3] |
map [BatTuple.Tuple2] |
map [BatString] | `map f s` returns a string where all characters `c` in `s` have been replaced by `f c`.
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.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 [BatRope] | `map f s` returns a rope where all characters `c` in `s` have been replaced by `f c`.
map [BatRefList] | Apply a function to all elements and return the ref list constructed with the function returned values
map [BatPervasives] | Transformation loop on an enumeration, used to build an enumeration from another enumeration.
map [BatPathGen.PathType] | Map a path through a function that operates on separate components.
map [BatPair] | map a function across both values in a pair
map [BatPSet] |
map [BatPMap] |
map [BatOption.Labels] |
map [BatOption] | `map f (Some x)` returns `Some (f x)` and `map f None` returns `None`.
map [BatMultiPMap] | `map f m` returns a map with same domain as `m`, where the associated value `a` of all bindings of `m` has been replaced by the result of the application of `f` to `a`.
map [BatMap.S.Labels] |
map [BatMap.S] | `map f m` returns a map with same domain as `m`, where the associated value `a` of all bindings of `m` has been replaced by the result of the application of `f` to `a`.
map [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] |
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 [BatEnum.Labels] |
map [BatEnum] | `map f e` returns an enumeration over `(f a0, f a1, ...)` where `a0,a1...` are the elements of `e`.
map [BatDynArray] | `map f darr` applies the function `f` to every element of `darr` and creates a dynamic array from the results - similar to `List.map` or `Array.map`.
map [BatDllist] | Allocate a new list, with entirely new nodes, whose values are the transforms of the values of the original list.
map [BatDeque] | `map f dq` returns a deque where every element `x` of `dq` has been replaces with `f x`.
map [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] |
map1 [BatTuple.Tuple5] |
map1 [BatTuple.Tuple4] |
map1 [BatTuple.Tuple3] |
map1 [BatTuple.Tuple2] | Equivalent to `BatPervasives.first`.
map2 [BatTuple.Tuple5] |
map2 [BatTuple.Tuple4] |
map2 [BatTuple.Tuple3] |
map2 [BatTuple.Tuple2] | Equivalent to `BatPervasives.second`.
map2 [BatStream.StreamLabels] |
map2 [BatStream] | `map2 f streama streamb` applies `f` in turn to elements of corresponding positions from `streama` and `streamb`.
map2 [BatList.Labels] |
map2 [BatList] | `List.map2 f [a0; a1; ...; an] [b0; b1; ...; bn]` is `[f a0 b0; f a1 b1; ...; f an bn]`.
map2 [BatLazyList.Labels] |
map2 [BatLazyList] | Operations on two lists
map2 [BatArray] | As `Array.map` but on two arrays.
map3 [BatTuple.Tuple5] |
map3 [BatTuple.Tuple4] |
map3 [BatTuple.Tuple3] |
map4 [BatTuple.Tuple5] |
map4 [BatTuple.Tuple4] |
map5 [BatTuple.Tuple5] |
map_default [BatOption.Labels] |
map_default [BatOption] | `map_default f x (Some v)` returns `f v` and `map_default f x None` returns `x`.
map_ext [BatPathGen.PathType] | `map_ext fu path` returns `path` but with the name with extension given by `fu (``BatPathGen.PathType.ext` `path)`.
map_file [BatBigarray.Array3] | Memory mapping of a file as a three-dimensional big array.
map_file [BatBigarray.Array2] | Memory mapping of a file as a two-dimensional big array.
map_file [BatBigarray.Array1] | Memory mapping of a file as a one-dimensional big array.
map_file [BatBigarray.Genarray] | Memory mapping of a file as a big array.
map_list [BatRefList] | Apply a function to all elements and return the list constructed with the function returned values
map_name [BatPathGen.PathType] | `map_name fu path` returns `path` with the name replaced by `fu (``BatPathGen.PathType.name` `path)`.
map_to_set [BatIMap] |
mapi [BatVect.Make] | Same as `map`, but the function is applied to the index of the element as first argument, and the element itself as second argument.
mapi [BatVect] | Same as `BatVect.map`, but the function is applied to the index of the element as first argument, and the element itself as second argument.
mapi [BatPMap] |
mapi [BatMultiPMap] | Same as `map`, but the function receives as arguments both the key and the associated value for each binding of the map.
mapi [BatMap.S.Labels] |
mapi [BatMap.S] | Same as `Map.S.map`, but the function receives as arguments both the key and the associated value for each binding of the map.
mapi [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] |
mapi [BatEnum.Labels] |
mapi [BatEnum] | `mapi` is similar to `map` except that `f` is passed one extra argument which is the index of the element in the enumeration, starting from 0 : mapi f e returns an enumeration over `(f 0 a0, f 1 a1, ...)` where `a0,a1...` are the elements of `e`.
mapi [BatDynArray] | `mapi f darr` applies the function `f` to every element of `darr` and creates a dynamic array from the results - similar to `List.mapi` or `Array.mapi`.
mapi [BatDeque] | `map f dq` returns a deque where every element `x` of `dq` has been replaces with `f n x`, where `n` is the position of `x` from the front of `dq`.
mapi [BatBigarray.Array1] | Same as `Bigarray.Array1.map`, but the function is applied to the index of the element as the first argument, and the element itself as the second argument.
mapi [BatBigarray.Genarray] | Same as `BatBigarray.Genarray.map`, but the function is applied to the index of the coordinates as the first argument, and the element itself as the second argument.
mapi [BatArray.Cap.Labels] |
mapi [BatArray.Cap] |
mapi [BatArray.Labels] |
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] |
mapn [BatTuple.Tuple4] |
mapn [BatTuple.Tuple3] |
mapn [BatTuple.Tuple2] | Equivalent to `BatPervasives.( *** )`.
max [BatSeq.Exceptionless] |
max [BatSeq] | `max s` returns the largest value in `s` as judged by `Pervasives.compare`
max [BatList] | `max l` returns the largest value in `l` as judged by `Pervasives.compare`
max [BatArray] | `max a` returns the largest value in `a` as judged by `Pervasives.compare`
max_array_length [Batteries_config] | The maximal length of a normal array on this system.
max_big_int [BatBig_int] | Return the greater of its two arguments.
max_binding [BatPMap] |
max_binding [BatMap.S] | return the `(key,value)` pair with the largest key
max_binding [BatMap] | returns the binding with the largest key
max_elt [BatSet.S.Exceptionless] |
max_elt [BatSet.S] | Same as `Set.S.min_elt`, but returns the largest element of the given set.
max_elt [BatSet] | returns the largest element of the set.
max_elt [BatPSet] |
max_elt [BatISet] |
max_int [BatNativeint] | The greatest representable native integer, either 231 - 1 on a 32-bit platform, or 263 - 1 on a 64-bit platform.
max_int [BatInt64] | The greatest representable 64-bit integer, 263 - 1.
max_int [BatInt32] | The greatest representable 32-bit integer, 231 - 1.
max_length [BatVect.Make] | Maximum length of the vect.
max_length [BatVect] | Maximum length of the vect.
max_length [BatRope] | Maximum length of the rope (number of UTF-8 characters).
max_num [BatNumber.Bounded] |
max_num [BatNum] |
max_num [BatNativeint] |
max_num [BatInt32] |
max_num [BatInt.Safe_int] | The smallest representable integer, -230 or 262.
max_num [BatInt] | The smallest representable integer, -230 or 262.
max_num [BatFloat.Safe_float] |
max_num [BatFloat] |
max_num [BatBool] |
max_string_length [Batteries_config] | Maximum length of a string.
may [BatOption.Labels] |
may [BatOption] | `may f (Some x)` calls `f x` and `may f None` does nothing.
maybe [BatParserCo] | Accept an optional argument.
maybe_printer [BatOption] |
mem [BatVect] | `mem m a` is true if and only if `m` is equal to an element of `a`.
mem [BatSet.S] | `mem x s` tests whether `x` belongs to the set `s`.
mem [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 [BatPSet] |
mem [BatPMap] |
mem [BatMultiPMap] | `mem x m` returns `true` if `m` contains at least a binding for `x`, and `false` otherwise.
mem [BatMap.S] | `mem x m` returns `true` if `m` contains a binding for `x`, and `false` otherwise.
mem [BatMap] | `mem x m` returns `true` if `m` contains a binding for `x`, and `false` otherwise.
mem [BatLazyList] | `mem x l` determines if `x` is part of `l`.
mem [BatInnerWeaktbl] | `Weaktbl.mem tbl x` checks if `x` is bound in `tbl`.
mem [BatISet] |
mem [BatIMap] |
mem [BatHashtbl.Cap] |
mem [BatHashtbl.S] |
mem [BatHashtbl] | `Hashtbl.mem tbl x` checks if `x` is bound in `tbl`.
mem [BatArray.Cap] |
mem [BatArray] | `mem m a` is true if and only if `m` is equal to an element of `a`.
mem_assoc [BatLazyList] | As `BatLazyList.assoc` but simply returns `true` if a binding exists, `false` otherwise.
mem_assq [BatLazyList] | As `BatLazyList.mem_assoc` but with physical equality.
memq [BatVect] | Same as `Array.mem` but uses physical equality instead of structural equality to compare array elements.
memq [BatLazyList] | As `mem`, but with physical equality
memq [BatArray.Cap] |
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 [BatPMap] |
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 [BatHeap.H] | See `BatHeap.merge`.
merge [BatHeap] | Merge two heaps.
merge [BatEnum] | `merge test (a, b)` merge the elements from `a` and `b` into a single enumeration.
merge_unsafe [BatPMap] |
merge_unsafe [BatMap] | Same as merge, but assumes the comparison function of both maps are equal.
min [BatSeq.Exceptionless] |
min [BatSeq] | `min s` returns the smallest value in `s` as judged by `Pervasives.compare`
min [BatList] | `min l` returns the smallest value in `l` as judged by `Pervasives.compare`
min [BatArray] | `min a` returns the smallest value in `a` as judged by `Pervasives.compare`
min_big_int [BatBig_int] | Return the smaller of its two arguments.
min_binding [BatPMap] |
min_binding [BatMap.S] | return the (`key,value`) pair with the smallest key
min_binding [BatMap] | returns the binding with the smallest key
min_elt [BatSet.S.Exceptionless] |
min_elt [BatSet.S] | Return the smallest element of the given set (with respect to the `Ord.compare` ordering).
min_elt [BatSet] | returns the smallest element of the set.
min_elt [BatPSet] |
min_elt [BatISet] |
min_int [BatNativeint] | The greatest representable native integer, either -231 on a 32-bit platform, or -263 on a 64-bit platform.
min_int [BatInt64] | The smallest representable 64-bit integer, -263.
min_int [BatInt32] | The smallest representable 32-bit integer, -231.
min_num [BatNumber.Bounded] |
min_num [BatNum] |
min_num [BatNativeint] |
min_num [BatInt32] |
min_num [BatInt.Safe_int] | The greatest representable integer, which is either 230-1 or 262-1.
min_num [BatInt] | The greatest representable integer, which is either 230-1 or 262-1.
min_num [BatFloat.Safe_float] |
min_num [BatFloat] |
min_num [BatBool] |
minus_one [BatNativeint] | The native integer -1.
minus_one [BatInt64] | The 64-bit integer -1.
minus_one [BatInt32] | The 32-bit integer -1.
minus_one [BatInt.Safe_int] | The integer `-1`.
minus_one [BatInt] | The integer `-1`.
modf [BatFloat.Safe_float] | `modf f` returns the pair of the fractional and integral part of `f`.
modf [BatFloat] | `modf f` returns the pair of the fractional and integral part of `f`.
modify [BatVect] | `modify v n f` is equivalent to `set v n (f (get v n))`, but more efficient.
modify [BatPMap] |
modify [BatMap.S] | `modify k f m` replaces the previous binding for `k` with `f` applied to that value.
modify [BatMap] | `modify k f m` replaces the previous binding for `k` with `f` applied to that value.
modify [BatBigarray.Array3] | `modify f a` changes each element `x` in `a` to `f x` in-place.
modify [BatBigarray.Array2] | `modify f a` changes each element `x` in `a` to `f x` in-place.
modify [BatBigarray.Array1] | `modify f a` changes each element `x` in `a` to `f x` in-place.
modify [BatBigarray.Genarray] | `modify f a` changes each element `x` in `a` to `f x` in-place.
modify [BatArray.Cap.Labels] |
modify [BatArray.Cap] |
modify [BatArray.Labels] |
modify [BatArray] | `modify f a` replaces every element `x` of `a` with `f x`.
modify_def [BatPMap] |
modify_def [BatMap.S] | `modify_def v0 k f m` replaces the previous binding for `k` with `f` applied to that value.
modify_def [BatMap] | `modify_def v0 k f m` replaces the previous binding for `k` with `f` applied to that value.
modifyi [BatBigarray.Array1] | Same as `Bigarray.Array1.modify`, but the function is applied to the index of the element as the first argument, and the element itself as the second argument.
modifyi [BatBigarray.Genarray] | Same as `BatBigarray.Genarray.modify`, but the function is applied to the index of the coordinates as the first argument, and the element itself as the second argument.
modifyi [BatArray.Cap.Labels] |
modifyi [BatArray.Cap] |
modifyi [BatArray.Labels] |
modifyi [BatArray] | Same as `BatArray.modify`, but the function is applied to the index of the element as the first argument, and the element itself as the second argument.
modifyij [BatBigarray.Array2] | Same as `Bigarray.Array2.modify`, but the function is applied to the index of the element as the first two arguments, and the element itself as the third argument.
modifyijk [BatBigarray.Array3] | Same as `Bigarray.Array3.modify`, but the function is applied to the index of the coordinates as the first three arguments, and the element itself as the fourth argument.
modulo [BatNumber.Numeric] |
modulo [BatNum] |
modulo [BatNativeint] |
modulo [BatInt32] |
modulo [BatInt.Safe_int] | `modulo a b` computes the remainder of the integer division of `a` by `b`.
modulo [BatInt] | `modulo a b` computes the remainder of the integer division of `a` by `b`.
modulo [BatFloat.Safe_float] |
modulo [BatFloat] |
modulo [BatComplex] |
modulo [BatBool] |
modulo [BatBig_int] |
move [BatUTF8.Byte] |
move [BatUTF8] | `move s i n` returns `n`-th Unicode character after `i` if n >= 0, `n`-th Unicode character before `i` if n < 0.
mul [BatNumber.Numeric] |
mul [BatNum] |
mul [BatNativeint] | Multiplication.
mul [BatInt64] | Multiplication.
mul [BatInt32] | Multiplication.
mul [BatInt.Safe_int] | Multiplication.
mul [BatInt] | Multiplication.
mul [BatFloat.Safe_float] |
mul [BatFloat] |
mul [BatComplex] | Multiplication
mul [BatBool] |
mul [BatBig_int] |
multiline_comment [BatGenlex.Languages.Make] |
must [BatParserCo] | Prevent backtracking.
N
n_cartesian_product [BatList] | Given n lists, return the n-way cartesian product of these lists.
name [BatPathGen.PathType] | Returns name of the object the pathname points to, i.e.
name [BatGlobal] | Retrieve the name of a global.
name_core [BatPathGen.PathType] | Returns part of the name to the left of rightmost dot.
name_of_encoding [BatCharEncodings] | Return the name of the encoding.
name_of_input [BatScanf.Scanning] | `Scanning.file_name_of_input ib` returns the name of the character source for the scanning buffer `ib`.
name_of_level [BatLogger] | `name_of_level level` returns the name of the specified `level`.
nan [BatFloat.Safe_float] | A special floating-point value denoting the result of an undefined operation such as `0.0 /. 0.0`.
nan [BatFloat] | A special floating-point value denoting the result of an undefined operation such as `0.0 /. 0.0`.
narrow [BatOo.Oo.Internal] |
nat_of_num [BatNum] | Coercions between numerical types
nativeint [BatRandom.State] |
nativeint [BatRandom] | `Random.nativeint bound` returns a random integer between 0 (inclusive) and `bound` (exclusive).
nativeint [BatBigarray] | See `Bigarray.char`.
neg [BatNumber.Numeric] |
neg [BatNum] |
neg [BatNativeint] | Unary negation.
neg [BatInt64] | Unary negation.
neg [BatInt32] | Unary negation.
neg [BatInt.Safe_int] | Unary negation.
neg [BatInt] | Unary negation.
neg [BatFloat.Safe_float] |
neg [BatFloat] |
neg [BatComplex] | Unary negation.
neg [BatBool] |
neg [BatBig_int] |
neg_infinity [BatFloat.Safe_float] | Negative infinity.
neg_infinity [BatFloat] | Negative infinity.
nested_comments [BatGenlex.Languages.Definition] |
new_method [BatOo.Oo.Internal] |
new_methods_variables [BatOo.Oo.Internal] |
new_variable [BatOo.Oo.Internal] |
newline [BatUCharParser] | Recognizes a newline
newline [BatCharParser] | Recognizes a newline
next [BatUTF8.Byte] |
next [BatUTF8] | `next s i` returns the position of the head of the Unicode character located immediately after `i`.
next [BatStream] | Return the first element of the stream and remove it from the stream.
next [BatLazyList] | Common functions
next [BatDllist] | Given a node, get the next element in the list after the node.
nil [BatSeq] | `nil = fun () -> Nil`
nil [BatLazyList] | The empty list.
nolock [BatConcurrent] | A lock which does nothing.
none_of [BatUCharParser] | Accept any value not in a list As `ParserCo.none_of`, just with improved error message.
none_of [BatParserCo] | Accept any value not in a list Faster and more convenient than combining `satisfy` and `either`.
none_of [BatCharParser] | Accept any value not in a list As `ParserCo.none_of`, just with improved error message.
norm [BatComplex] | Norm: given `x + i.y`, returns `sqrt(x^2 + y^2)`.
norm2 [BatComplex] | Norm squared: given `x + i.y`, returns `x^2 + y^2`.
normalize [BatPathGen.PathType] | 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 [BatUCharParser] | Accept any value not a given char As `none_of`.
not_char [BatCharParser] | Accept any value not a given char As `none_of`.
npop [BatRefList] | Removes and returns the n first elements or raises `Empty_list` if the ref list does not contain enough elements
nread [BatInnerIO] | `nread i n` reads a string of size up to `n` from an input.
nread [BatIO] | `nread i n` reads a string of size up to `n` from an input.
nsplit [BatString] | `nsplit s sep` splits the string `s` into a list of strings which are separated by `sep` (excluded).
nsplit [BatRope] | `nsplit s sep` splits the rope `s` into a list of ropes which are separated by `sep`.
nth [BatList] | Obsolete.
nth [BatLazyList] | Obsolete.
nth_dim [BatBigarray.Genarray] | `Genarray.nth_dim a n` returns the `n`-th dimension of the big array `a`.
null_formatter [BatLogger] | `null_formatter` is a formatter that does not output any events, but simply discards them.
num_digits_big_int [BatBig_int] | Return the number of machine words used to store the given big integer.
num_dims [BatBigarray.Genarray] | Return the number of dimensions of the given big array.
num_of_big_int [BatNum] |
num_of_nat [BatNum] |
num_of_ratio [BatNum] |
number [BatGenlex.Languages.Make] | Parse either an integer or a floating-point number.
numeric_compare [BatString] | Compare two strings, sorting "abc32def" before "abc210abc".
nwrite [BatInnerIO] | Write a string to an output.
nwrite [BatIO] | Write a string to an output.
O
of_array [BatVect] | `of_array s` returns a vect corresponding to the array `s`.
of_array [BatLazyList] | Eager conversion from array
of_array [BatDynArray] | `of_array arr` returns an array with the elements of `arr` in it in order.
of_array [BatBigarray.Array3] | Build a three-dimensional big array initialized from the given array of arrays of arrays.
of_array [BatBigarray.Array2] | Build a two-dimensional big array initialized from the given array of arrays.
of_array [BatBigarray.Array1] | Build a one-dimensional big array initialized from the given array.
of_array [BatArray.Cap] | Adopt a regular array as a capability array, allowing to decrease capabilities if necessary.
of_backwards [BatVect.RANDOMACCESS] |
of_backwards [BatVect] | Build a vector from an enumeration, from last to first.
of_backwards [BatUTF8] | As `String.of_backwards`
of_backwards [BatString] | Build a string from an enumeration, starting with last character, ending with first.
of_backwards [BatRope] | Build a rope from an enumeration, starting with last character, ending with first.
of_backwards [BatRefList] | Creates a ref list from an enumeration, going from last to first
of_backwards [BatList] | Build a list from an enumeration.
of_backwards [BatArray.Cap] |
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_bulk_enum [BatRope] | Creates a rope from an enumeration of UTF-8 encoded strings.
of_byte [BatInt32] |
of_char [BatUTF8] | As `String.of_char`
of_char [BatString] | Returns a string containing one given character.
of_char [BatRope] | `of_char c` returns a rope containing exactly Latin-1 character `c`.
of_char_idx [BatUTF8.Byte] | `of_char_idx s n` returns the position of the `n`-th Unicode character.
of_container [BatVect.Make] | `of_array s` returns a vect corresponding to the container `s`.
of_digit [BatUChar] | Return the character representing a given digit.
of_digit [BatChar] | Return the character representing a given digit.
of_enum [BatVect.RANDOMACCESS] |
of_enum [BatVect] | Build a vector from an enumeration.
of_enum [BatUTF8] | As `String.of_enum`
of_enum [BatTuple.Tuple5] |
of_enum [BatTuple.Tuple4] |
of_enum [BatTuple.Tuple3] |
of_enum [BatTuple.Tuple2] |
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.S] |
of_enum [BatSet] |
of_enum [BatRope] | Creates a rope from a character enumeration.
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 [BatPair] | builds a pair out of the first two values of an enum.
of_enum [BatPSet] |
of_enum [BatPMap] |
of_enum [BatOption] | `of_enum e` consumes the first element of `e`, if it exists, and returns `Some e`.
of_enum [BatMultiPMap] | creates a map from an enumeration, using the specified function for key comparison or `compare` by default.
of_enum [BatMap.S] | Create a map from a (key, value) enumeration.
of_enum [BatMap] | creates a map from an enumeration, using the specified function for key comparison or `compare` by default.
of_enum [BatList] | Build a list from an enumeration.
of_enum [BatLazyList] | Lazy conversion from enum.
of_enum [BatHeap.H] | See `BatHeap.of_enum`.
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 [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 [BatArray.Cap] |
of_enum [BatArray] | Build an array from an enumeration.
of_enum_cmp [BatSet] |
of_enum_cmp [BatPSet] |
of_float [BatString] | Returns the string representation of an float.
of_float [BatRope] | Returns the rope representation of a float.
of_float [BatNumber.Numeric] |
of_float [BatNum] |
of_float [BatNativeint] | Convert the given floating-point number to a native integer, discarding the fractional part (truncate towards 0).
of_float [BatInt64] | Convert the given floating-point number to a 64-bit integer, discarding the fractional part (truncate towards 0).
of_float [BatInt32] | Convert the given floating-point number to a 32-bit integer, discarding the fractional part (truncate towards 0).
of_float [BatInt.Safe_int] | Convert the given floating-point number to integer integer, discarding the fractional part (truncate towards 0).
of_float [BatInt] | Convert the given floating-point number to integer integer, discarding the fractional part (truncate towards 0).
of_float [BatFloat.Safe_float] |
of_float [BatFloat] |
of_float [BatComplex] | `Complex.of_float x` returns the complex number `x+0i`
of_float [BatBool] |
of_float [BatBig_int] |
of_fun [BatStream] | `Stream.from f` returns a stream built from the function `f`.
of_input [BatSubstring] |
of_input [BatStream] | Convert an `input` to a stream.
of_int [BatString] | Returns the string representation of an int.
of_int [BatRope] | Returns the rope representation of an int.
of_int [BatNumber.Numeric] |
of_int [BatNum] |
of_int [BatNativeint] | Convert the given integer (type `int`) to a native integer (type `nativeint`).
of_int [BatInt64] | Convert the given integer (type `int`) to a 64-bit integer (type `int64`).
of_int [BatInt32] | Convert the given integer (type `int`) to a 32-bit integer (type `int32`).
of_int [BatInt.Safe_int] |
of_int [BatInt] |
of_int [BatFloat.Safe_float] |
of_int [BatFloat] |
of_int [BatComplex] |
of_int [BatBool] |
of_int [BatBig_int] |
of_int32 [BatNativeint] | Convert the given 32-bit integer (type `int32`) to a native integer.
of_int32 [BatInt64] | Convert the given 32-bit integer (type `int32`) to a 64-bit integer (type `int64`).
of_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_int_unsafe [BatUTF8.Byte] |
of_latin1 [BatRope] | Constructs a unicode rope from a latin-1 string.
of_list [BatVect] |
of_list [BatString] | Converts a list of characters to a string.
of_list [BatSet] | builds a set from the given list, using the default comparison function
of_list [BatRefList] | Creates a ref list from a list - O(1)
of_list [BatPSet] |
of_list [BatLazyList] | Lazy conversion from lists
of_list [BatHeap.H] | See `BatHeap.of_list`.
of_list [BatHeap] | Build a heap from a given list.
of_list [BatGenlex] | Create a lexer from a list of keywords
of_list [BatDynArray] | `of_list lst` returns a dynamic array with the elements of `lst` in it in order.
of_list [BatDllist] | Converts from a normal list to a Dllist and returns the first node.
of_list [BatDeque] | `of_list l` is a deque representation of the elements of `l`.
of_list [BatArray.Cap] |
of_nativeint [BatInt64] | Convert the given native integer (type `nativeint`) to a 64-bit integer (type `int64`).
of_nativeint [BatInt32] | Convert the given native integer (type `nativeint`) to a 32-bit integer (type `int32`).
of_object [BatEnum] | `of_object e` returns a representation of an object as an enumeration
of_option [BatResult] | Convert an `option` to a `result`
of_stream [BatLazyList] | Lazy conversion from stream.
of_string [BatUnit] | Convert the given string to a unit.
of_string [BatUTF8] | Adopt a string.
of_string [BatSubstring] |
of_string [BatRope] | `of_string s` returns a rope corresponding to the UTF-8 encoded string `s`.
of_string [BatPathGen.PathType] | Parse path in a given string.
of_string [BatNumber.Numeric] |
of_string [BatNum] |
of_string [BatNativeint] | Convert the given string to a native integer.
of_string [BatInt64] | Convert the given string to a 64-bit integer.
of_string [BatInt32] | Convert the given string to a 32-bit integer.
of_string [BatInt.Safe_int] | Convert the given string to an integer The string is read in decimal (by default) or in hexadecimal, octal or binary if the string begins with `0x`, `0o` or `0b` respectively.
of_string [BatInt] | Convert the given string to an integer The string is read in decimal (by default) or in hexadecimal, octal or binary if the string begins with `0x`, `0o` or `0b` respectively.
of_string [BatFloat.Safe_float] |
of_string [BatFloat] |
of_string [BatComplex] |
of_string [BatBool] | Convert the given string to a boolean.
of_string [BatBig_int] |
of_table [BatHashtbl.Cap] | Adopt a regular hashtable as a capability hashtble, allowing to decrease capabilities if necessary.
of_uchar [BatRope] | `of_uchar c` returns a rope containing exactly character `c`.
of_ustring [BatRope] | `of_string s` returns a rope corresponding to the string `s`.
ok [BatStd] | `f x |> ok` unwraps the `Ok` result of `f x` and returns it, or throws the exception contained if `Bad` is returned.
on_close_out [BatInnerIO] | Register a function to be triggered just before an output is closed.
on_output [BatStream] | Convert an `output` to a stream.
one [BatNumber.Numeric] |
one [BatNum] |
one [BatNativeint] | The native integer 1.
one [BatInt64] | The 64-bit integer 1.
one [BatInt32] | The 32-bit integer 1.
one [BatInt.Safe_int] | The integer `1`.
one [BatInt] | The integer `1`.
one [BatFloat.Safe_float] | Floating number one.
one [BatFloat] | Floating number one.
one [BatComplex] | The complex number `1`.
one [BatBool] |
one [BatBig_int] |
one_of [BatParserCo] | Accept one of several values.
one_plus [BatParserCo] | Accept a (non-empty) list of expressions
op_letter [BatGenlex.Languages.Definition] |
op_start [BatGenlex.Languages.Definition] |
open_connection [BatUnix] | Connect to a server at the given address.
open_in [BatPervasives] | Open the named file for reading.
open_in [BatFile] | `open_in file_name` opens the file named `file_name` for reading.
open_in_bin [BatPervasives] | Same as `Pervasives.open_in`, but the file is opened in binary mode, so that no translation takes place during reads.
open_in_gen [BatPervasives] | `open_in mode perm filename` opens the named file for reading, as described above.
open_out [BatPervasives] | Open the named file for writing, and return a new output channel on that file.
open_out [BatFile] | `open_out file_name` opens the file named `file_name` for writing.
open_out_bin [BatPervasives] | Same as `BatPervasives.open_out`, but the file is opened in binary mode, so that no translation takes place during writes.
open_out_gen [BatPervasives] | `open_out_gen mode perm filename` opens the named file for writing, as described above.
open_process [BatUnix] | Same as `Unix.open_process_out`, but redirects both the standard input and standard output of the command to pipes connected to the two returned `input`/`output`.
open_process_full [BatUnix] | Similar to `Unix.open_process`, but the second argument specifies the environment passed to the command.
open_process_in [BatUnix] | High-level pipe and process management.
open_process_out [BatUnix] | Same as `Unix.open_process_in`, but redirect the standard input of the command to a pipe.
open_temporary_out [BatFile] | `open_temporary_out ()` opens a new temporary file for writing.
operations [BatNumber.Numeric] |
operations [BatNum] |
operations [BatNativeint] |
operations [BatInt.Safe_int] |
operations [BatInt] |
operations [BatFloat.Safe_float] |
operations [BatFloat] |
operations [BatComplex] |
operations [BatBool] |
operations [BatBig_int] |
opt [BatOptParse.Opt] | Get the value of an option as an optional value.
opt [BatGlobal] | Return `None` if the global is undefined, else `Some v` where v is the current global value contents.
other_exec [BatFile] | Give the permission to execute the file to the rest of the world.
other_read [BatFile] | Give the permission to read the file to the rest of the world.
other_write [BatFile] | Give the permission to modify the file to the rest of the world.
out_channel_of_descr [BatUnix] |
out_of_range [BatUTF8.Byte] |
out_of_range [BatUTF8] | `out_of_range s i` tests whether `i` is a position inside of `s`.
output [BatPervasives] | `output oc buf pos len` writes `len` characters from string `buf`, starting at offset `pos`, to the given output channel `oc`.
output [BatMarshal] | `output out v` writes the representation of `v` on `chan`.
output [BatInnerIO] | `output o s p l` writes up to `l` characters from string `s`, starting at offset `p`.
output [BatIO] | `output o s p l` writes up to `l` characters from string `s`, starting at offset `p`.
output [BatDigest] | Write a digest on the given output.
output_binary_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 [BatInnerIO] | Create an output that will append its results at the end of a buffer in an efficient way.
output_buffer [BatIO] | Create an output that will append its results at the end of a buffer in an efficient way.
output_buffer [BatBuffer] | `output_buffer oc b` writes the current contents of buffer `b` on the output channel `oc`.
output_byte [BatPervasives] | Write one 8-bit integer (as the single character with that code) on the given output channel.
output_channel [BatInnerIO] | Create an output that will write into a channel.
output_channel [BatIO] | Create an output that will write into a channel.
output_char [BatPervasives] | Write the character on the given output channel.
output_enum [BatIO] | Create an output that will write into an `enum`.
output_file [BatStd] | creates a filename, write text into it and close it.
output_of_descr [BatUnix] | Create an `output` writing on the given descriptor.
output_rope [BatPervasives] | Write the rope on the given output channel.
output_string [BatPervasives] | Write the string on the given output channel.
output_string [BatInnerIO] | Create an output that will write into a string in an efficient way.
output_string [BatIO] | Create an output that will write into a string in an efficient way.
output_value [BatPervasives] | Write the representation of a structured value of any type to a channel.
P
p [BatPathGen.PathType] | = `BatPathGen.PathType.of_string`
pack [BatInt32] | `pack str off i` writes the little endian bit representation of `i` into string `str` at offset `off`
pack_big [BatInt32] | `pack_big str off i` writes the big endian bit representation of `i` into string `str` at offset `off`
params [BatOo.Oo.Internal] |
parent [BatPathGen.PathType] | Returns parent path, i.e.
parse [BatUCharParser] | Apply a parser to a Unicode Rope.
parse [BatOptParse.OptParser] | Parse arguments as if the arguments `args.(first)`, `args.(first+1)`, ..., `args.(last)` had been given on the command line.
parse [BatCharParser] | Apply a parser to a string.
parse_argv [BatOptParse.OptParser] | Parse all the arguments in `Sys.argv`.
partition [BatVect.Make] | `partition p a` returns a pair of arrays `(a1, a2)`, where `a1` is the array of all the elements of `a` that satisfy the predicate `p`, and `a2` is the array of all the elements of `a` that do not satisfy `p`.
partition [BatVect] | `partition p a` returns a pair of arrays `(a1, a2)`, where `a1` is the array of all the elements of `a` that satisfy the predicate `p`, and `a2` is the array of all the elements of `a` that do not satisfy `p`.
partition [BatSet.S.Labels] |
partition [BatSet.S] | `partition p s` returns a pair of sets `(s1, s2)`, where `s1` is the set of all the elements of `s` that satisfy the predicate `p`, and `s2` is the set of all the elements of `s` that do not satisfy `p`.
partition [BatSet] | returns two disjoint subsets, those that satisfy the given predicate and those that don't
partition [BatPSet] |
partition [BatPMap] |
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] |
partition [BatEnum] | as `switch`
partition [BatArray.Cap] |
partition [BatArray] | `partition p a` returns a pair of arrays `(a1, a2)`, where `a1` is the array of all the elements of `a` that satisfy the predicate `p`, and `a2` is the array of all the elements of `a` that do not satisfy `p`.
pass [BatPrintexc] | `Printexc.pass fn x` applies `fn` to `x` and returns the result.
peek [BatQueue.Exceptionless] |
peek [BatPervasives] | `peek e` returns `None` if `e` is empty or `Some x` where `x` is the next element of `e`.
peek [BatLazyList] | `peek l` returns the first element of `l`, if it exists.
peek [BatEnum] | `peek e` returns `None` if `e` is empty or `Some x` where `x` is the next element of `e`.
perm [BatFile] | Join permissions
pi [BatFloat.Safe_float] | The constant pi (3.14159...)
pi [BatFloat] | The constant pi (3.14159...)
pipe [BatInnerIO] | Create a pipe between an input and an ouput.
pipe [BatIO] | Create a pipe between an input and an ouput.
polar [BatComplex] | `polar norm arg` returns the complex having norm `norm` and argument `arg`.
pop [BatVect] | Return the last element of a vector and its first `n-1` elements.
pop [BatStack.Exceptionless] |
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 [BatPSet] |
pop [BatPMap] |
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.
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 [BatInt32] |
pow [BatInt.Safe_int] | `pow a b` computes ab
pow [BatInt] | `pow a b` computes ab
pow [BatFloat.Safe_float] |
pow [BatFloat] |
pow [BatComplex] | Power function.
pow [BatBool] |
pow [BatBig_int] |
power_big_int_positive_big_int [BatBig_int] | Exponentiation functions.
power_big_int_positive_int [BatBig_int] |
power_int_positive_big_int [BatBig_int] |
power_int_positive_int [BatBig_int] |
pp_set_formatter_out_channel [BatFormat] |
pp_set_formatter_output [BatFormat] | Deprecated
pre [BatRef] | Perform an operation on a reference and return the new value of that reference.
pre_decr [BatRef] | Increment an integer, return the new value.
pre_incr [BatRef] | Increment an integer, return the new value.
pred [BatNumber.Discrete] |
pred [BatNumber.Numeric] |
pred [BatNum] |
pred [BatNativeint] | Predecessor.
pred [BatInt64] | Predecessor.
pred [BatInt32] | Predecessor.
pred [BatInt.Safe_int] | Predecessor.
pred [BatInt] | Predecessor.
pred [BatFloat.Safe_float] | Substract `1.` from a floating number.
pred [BatFloat] | Substract `1.` from a floating number.
pred [BatComplex] | Remove `BatComplex.one` from this number.
pred [BatBool] |
pred [BatBig_int] |
prefix_action [BatEnum] | `prefix_action f e` will behave as `e` but guarantees that `f ()` will be invoked exactly once before the current first element of `e` is read.
prepend [BatVect.Make] | `prepend c r` returns a new vect with the `c` character at the beginning in amortized `O(1)` time.
prepend [BatVect] | `prepend c r` returns a new vect with the `c` character at the beginning in amortized `O(1)` time.
prepend [BatDllist] | `prepend n a` Creates a new node containing data `a` and inserts it into the list before node `n`.
prepend_char [BatRope] | `prepend_char c r` returns a new rope with the `c` character at the beginning in amortized `O(1)` time.
prepend_list [BatDeque] | `prepent_list l dq` is equivalent to `append (of_list l) dq`, but more efficient.
prerr_all [BatPervasives] | Print the contents of an input to the error output.
prerr_bool [BatStd] | Print a boolean to stderr.
prerr_bool [BatPervasives] | Print a boolean to stderr.
prerr_guess [BatPervasives] | Attempt to print the representation of a runtime value on the error output.
prev [BatUTF8.Byte] |
prev [BatUTF8] | `prev s i` returns the position of the head of the Unicode character located immediately before `i`.
prev [BatDllist] | Given a node, get the previous element in the list before the node.
print [BatVect.Make] | Printing
print [BatVect] |
print [BatUref] | Print the uref.
print [BatUnit] | Printing
print [BatUTF8] | Printing
print [BatUChar] | Printing
print [BatTuple.Tuple5] |
print [BatTuple.Tuple4] |
print [BatTuple.Tuple3] |
print [BatTuple.Tuple2] |
print [BatSubstring] | `print oc ss` prints `ss` to the output channel `oc`
print [BatString] | Print a string.
print [BatStd] | print the representation of a runtime value on stdout.
print [BatStack] |
print [BatSet.S] |
print [BatSet] |
print [BatSeq] | Print the contents of a sequence
print [BatRope] |
print [BatRef] |
print [BatQueue] |
print [BatPrintexc] | Print an exception.
print [BatPervasives] | Print and consume the contents of an enumeration.
print [BatPair] | Prints a pair using given printing functions.
print [BatPSet] |
print [BatPMap] |
print [BatOption] |
print [BatNum] | Printing
print [BatNativeint] |
print [BatMultiPMap] |
print [BatMap.S] |
print [BatMap] |
print [BatList] | Print the contents of a list
print [BatLazyList] |
print [BatInt.Safe_int] |
print [BatInt] |
print [BatHeap.H] | See `BatHeap.print`.
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 [BatEnum] | Print and consume the contents of an enumeration.
print [BatDynArray] |
print [BatDllist] |
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
print2 [BatPair] |
print_all [BatPervasives] | Print the contents of an input to the standard output.
print_as_list [BatSplay.Map] |
print_backtrace [BatPrintexc] | `print_backtrace oc` Prints the an exception backtrace on the output channel `oc`.
print_bool [BatStd] | Print a boolean to stdout.
print_bool [BatPervasives] | Print a boolean on standard output.
print_guess [BatPervasives] | Attempt to print the representation of a runtime value on the standard output.
print_quoted [BatString] | Print a string, with quotes as added by the `quote` function.
print_rope [Batteries_print] |
print_stat [BatGc] | Print the current values of the memory management counters (in human-readable form) into the channel argument.
print_string_cap_ro [Batteries_print] |
print_string_cap_rw [Batteries_print] |
print_tuple0 [BatValue_printer] |
print_tuple1 [BatValue_printer] |
print_tuple10 [BatValue_printer] |
print_tuple2 [BatValue_printer] |
print_tuple3 [BatValue_printer] |
print_tuple4 [BatValue_printer] |
print_tuple5 [BatValue_printer] |
print_tuple6 [BatValue_printer] |
print_tuple7 [BatValue_printer] |
print_tuple8 [BatValue_printer] |
print_tuple9 [BatValue_printer] |
print_uchar [Batteries_print] |
print_ustring [Batteries_print] |
printf [BatPrintf] | The usual `printf` function, prints to the standard output `stdout`, i.e.
printf [BatPrint] | `printf fmt args` formats the arguments in `args` as specified by `fmt` and prints the result on the standard output `BatIO.stdout`, i.e.
printf [BatInnerIO.Printf] | The usual `printf` function, prints to the standard output `BatInnerIO.stdout`, i.e.
printf [BatIO] | A `fprintf`-style unparser.
println [BatString] | Print a string, end the line.
printn [BatTuple.Tuple5] |
printn [BatTuple.Tuple4] |
printn [BatTuple.Tuple3] |
printn [BatTuple.Tuple2] |
prj12 [BatTuple.Tuple5] |
prj12 [BatTuple.Tuple4] |
prj12 [BatTuple.Tuple3] |
prj123 [BatTuple.Tuple5] |
prj123 [BatTuple.Tuple4] |
prj1234 [BatTuple.Tuple5] |
prj1235 [BatTuple.Tuple5] |
prj124 [BatTuple.Tuple5] |
prj124 [BatTuple.Tuple4] |
prj1245 [BatTuple.Tuple5] |
prj125 [BatTuple.Tuple5] |
prj13 [BatTuple.Tuple5] |
prj13 [BatTuple.Tuple4] |
prj13 [BatTuple.Tuple3] |
prj134 [BatTuple.Tuple5] |
prj1345 [BatTuple.Tuple5] |
prj135 [BatTuple.Tuple5] |
prj14 [BatTuple.Tuple5] |
prj14 [BatTuple.Tuple4] |
prj145 [BatTuple.Tuple5] |
prj15 [BatTuple.Tuple5] |
prj23 [BatTuple.Tuple5] |
prj23 [BatTuple.Tuple4] |
prj23 [BatTuple.Tuple3] |
prj234 [BatTuple.Tuple5] |
prj234 [BatTuple.Tuple4] |
prj2345 [BatTuple.Tuple5] |
prj235 [BatTuple.Tuple5] |
prj24 [BatTuple.Tuple5] |
prj24 [BatTuple.Tuple4] |
prj245 [BatTuple.Tuple5] |
prj25 [BatTuple.Tuple5] |
prj34 [BatTuple.Tuple5] |
prj34 [BatTuple.Tuple4] |
prj345 [BatTuple.Tuple5] |
prj35 [BatTuple.Tuple5] |
prj45 [BatTuple.Tuple5] |
progress_in [BatIO] | `progress_in inp f` create an input that calls `f ()` whenever some content is succesfully read from it.
progress_out [BatIO] | `progress_out out f` create an output that calls `f ()` whenever some content is succesfully written to it.
promote [BatDllist] | `promote n` Swaps `n` with `next n`.
protect [BatRef] | Assign a reference temporarily.
public_method_label [BatOo.Oo.Internal] |
push [BatRefList] | Adds an element at the head - O(1)
push [BatPervasives] | `push e x` will add `x` at the beginning of `e`.
push [BatEnum] | `push e x` will add `x` at the beginning of `e`.
put [BatBitSet] | `put s v n` sets the nth-bit in the bitset `s` to `v`.
Q
quo [BatNum] | Additional operations
quomod_big_int [BatBig_int] | Euclidean division of two big integers.
quote [BatString] | Add quotes around a string and escape any quote or escape appearing in that string.
R
range [BatParserCo] | Accept any element from a given range.
range [BatLazyList] | Compute lazily a range of integers a ..
range [BatEnum] | `range p until:q` creates an enumeration of integers `[p, p+1, ..., q]`.
range [BatChar] |
range [BatArray] | `range a` returns an enumeration of all valid indexes into the given array.
range_iter [BatRope] | `rangeiter f m n r` applies `f` to all the characters whose indices `k` satisfy `m` <= `k` < `m + n`.
range_iteri [BatRope] | As `range_iter`, but passes base + index of the character in the subrope defined by next to arguments.
rangeiter [BatVect.Make] | `rangeiter f m n r` applies `f` to all the elements whose indices `k` satisfy `m` <= `k` < `m + n`.
rangeiter [BatVect] | `rangeiter f m n r` applies `f` to all the elements whose indices `k` satisfy `m` <= `k` < `m + n`.
ranges [BatISet] |
ratio_of_num [BatNum] |
rchop [BatString] | Returns the same string but without the last `n` characters.
rchop [BatRope] | Returns the same rope but without the last character.
rcontains_from [BatUTF8] |
rcontains_from [BatRope] | `rcontains_from s stop c` tests if character `c` appears in the subrope of `s` starting from the beginning of `s` to index `stop`.
read [BatInnerIO] | Read a single char from an input or raise `No_more_input` if no input available.
read [BatIO] | Read a single char from an input or raise `No_more_input` if no input is available.
read_all [BatInnerIO] | read all the contents of the input until `No_more_input` is raised.
read_all [BatIO] | read all the contents of the input until `No_more_input` is raised.
read_bits [BatIO] | Read up to 31 bits, raise Bits_error if n < 0 or n > 31
read_byte [BatInnerIO] | Read an unsigned 8-bit integer.
read_byte [BatIO] | Read an unsigned 8-bit integer.
read_double [BatInnerIO] | Read an IEEE double precision floating point value.
read_double [BatIO.BigEndian] | Read an IEEE double precision floating point value.
read_double [BatIO] | Read an IEEE double precision floating point value.
read_float [BatInnerIO] | Read an IEEE single precision floating point value.
read_float [BatIO.BigEndian] | Read an IEEE single precision floating point value.
read_float [BatIO] | Read an IEEE single precision floating point value.
read_i16 [BatInnerIO] | Read a signed 16-bit word.
read_i16 [BatIO.BigEndian] | Read a signed 16-bit word.
read_i16 [BatIO] | Read a signed 16-bit word.
read_i32 [BatInnerIO] | Read a signed 32-bit integer.
read_i32 [BatIO.BigEndian] | Read a signed 32-bit integer.
read_i32 [BatIO] | Read a signed 32-bit integer.
read_i64 [BatInnerIO] | Read a signed 64-bit integer as an OCaml int64.
read_i64 [BatIO.BigEndian] | Read a signed 64-bit integer as an OCaml int64.
read_i64 [BatIO] | Read a signed 64-bit integer as an OCaml int64.
read_line [BatInnerIO] | Read a LF or CRLF terminated string.
read_line [BatIO] | Read a LF or CRLF terminated string.
read_only [BatHashtbl.Cap] | Drop to read-only permissions.
read_only [BatArray.Cap] | Drop to read-only permissions.
read_real_i32 [BatInnerIO] | Read a signed 32-bit integer as an OCaml int32.
read_real_i32 [BatIO.BigEndian] | Read a signed 32-bit integer as an OCaml int32.
read_real_i32 [BatIO] | Read a signed 32-bit integer as an OCaml int32.
read_rope [BatIO] | Read up to n uchars from a UTF-8 encoded input
read_signed_byte [BatInnerIO] | Read an signed 8-bit integer.
read_signed_byte [BatIO] | Read an signed 8-bit integer.
read_string [BatInnerIO] | Read a null-terminated string.
read_string [BatIO] | Read a null-terminated string.
read_uall [BatIO] | Read the whole contents of a UTF-8 encoded input
read_uchar [BatIO] | Read one UChar from a UTF-8 encoded input
read_ui16 [BatInnerIO] | Read an unsigned 16-bit word.
read_ui16 [BatIO.BigEndian] | Read an unsigned 16-bit word.
read_ui16 [BatIO] | Read an unsigned 16-bit word.
read_uline [BatIO] | Read a line of UTF-8
real_i32s_of [BatIO.BigEndian] | Read an enumeration of signed 32-bit integers as OCaml `int32`s.
real_i32s_of [BatIO] | Read an enumeration of signed 32-bit integers as OCaml `int32`s.
really_input [BatPervasives] | `really_input ic buf pos len` reads `len` characters from channel `ic`, storing them in string `buf`, starting at character number `pos`.
really_input [BatInnerIO] | `really_input i s p l` reads exactly `l` characters from the given input, storing them in the string `s`, starting at position `p`.
really_input [BatIO] | `really_input i s p l` reads exactly `l` characters from the given input, storing them in the string `s`, starting at position `p`.
really_nread [BatInnerIO] | `really_nread i n` reads a string of exactly `n` characters from the input.
really_nread [BatIO] | `really_nread i n` reads a string of exactly `n` characters from the input.
really_output [BatInnerIO] | `really_output o s p l` writes exactly `l` characters from string `s` onto the the output, starting with the character at offset `p`.
really_output [BatIO] | `really_output o s p l` writes exactly `l` characters from string `s` onto the the output, starting with the character at offset `p`.
rear [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.
reduce [BatVect] | as `BatVect.fold_left`, but no initial value - just applies reducing function to elements from left to right.
reduce [BatSeq.Exceptionless] |
reduce [BatSeq] | `reduce f (cons e s)` is `fold_left f e s`.
reduce [BatPervasives] | Transformation loop on an enumeration, used to build a single value from an enumeration.
reduce [BatList] | `List.reduce f h::t` is `fold_left f h t`.
reduce [BatEnum] | A simplified version of `fold`, which uses the first element of the enumeration as a default value.
reduce [BatArray] | `Array.reduce f a` is `fold_left f a.(0) [|a.(1); ..; a.(n-1)|]`.
ref [BatRef] | Return a fresh reference containing the given value.
register_formatter [BatLogger] | `register_formatter name formatter` registers a named log formatter.
relative_to_any [BatPathGen.PathType] | `relative_to_any base sub` returns relative path `rel` such that `normalize (base/:rel) = normalize sub`, i.e.
relative_to_parent [BatPathGen.PathType] | `relative_to_parent parent sub` returns relative path `rel` such that `(normalize parent)/:rel = normalize sub`.
rem [BatNativeint] | Integer remainder.
rem [BatInt64] | Integer remainder.
rem [BatInt32] | Integer remainder.
rem [BatInt.Safe_int] | Integer remainder.
rem [BatInt] | Integer remainder.
remove [BatVect.Make] | `remove m n r` returns the vect resulting from deleting the elements with indexes ranging from `m` to `m + n - 1` (included) from the original vect `r`.
remove [BatVect] | `remove m n r` returns the vect resulting from deleting the elements with indexes ranging from `m` to `m + n - 1` (included) from the original vect `r`.
remove [BatSet.S] | `remove x s` returns a set containing all elements of `s`, except `x`.
remove [BatSet] | `remove x s` returns a set containing all elements of `s`, except `x`.
remove [BatRope] | `remove m n r` returns the rope resulting from deleting the characters with indexes ranging from `m` to `m + n - 1` (included) from the original rope `r`.
remove [BatRefList] | Remove an element from the ref list raise `Not_found` if the element is not found
remove [BatPSet] |
remove [BatPMap] |
remove [BatMultiPMap] | `remove k d m` returns a map containing the same bindings as `m`, except for `k` which is not bound to `d` anymore in the returned map.
remove [BatMap.S] | `remove x m` returns a map containing the same bindings as `m`, except for `x` which is unbound in the returned map.
remove [BatMap] | `remove x m` returns a map containing the same bindings as `m`, except for `x` which is unbound in the returned map.
remove [BatList] | `remove l x` returns the list `l` without the first element `x` found or returns `l` if no element is equal to `x`.
remove [BatLazyList] | `remove l x` returns the list `l` without the first element `x` found or returns `l` if no element is equal to `x`.
remove [BatInnerWeaktbl] | `Weaktbl.remove tbl x` removes the current binding of `x` in `tbl`, restoring the previous binding if it exists.
remove [BatISet] |
remove [BatIMap] |
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_all [BatRefList] | Remove all elements equal to the specified element from the ref list
remove_all [BatMultiPMap] | `remove_all x m` returns a map containing the same bindings as `m`, except for `x` which is unbound in the returned map.
remove_all [BatList] | `remove_all l x` is similar to `remove` but removes all elements that are equal to `x` and not only the first one.
remove_all [BatLazyList] | `remove_all l x` is similar to `remove` but removes all elements that are equal to `x` and not only the first one.
remove_all [BatHashtbl.Cap] |
remove_all [BatHashtbl.S] |
remove_all [BatHashtbl] | Remove all bindings for the given key
remove_all_such [BatLazyList.Labels] |
remove_all_such [BatLazyList] | `remove_all l x` is similar to `remove` but removes all elements that are equal to `x` and not only the first one.
remove_assoc [BatList] | `remove_assoc a l` returns the list of pairs `l` without the first pair with key `a`, if any.
remove_assq [BatList] | Same as `List.remove_assoc`, but uses physical equality instead of structural equality to compare keys.
remove_at [BatRefList.Index] | Remove the element at the specified index raise `Invalid_index` if the index is outside `0 ; length-1`
remove_if [BatRefList] | Remove the first element matching the specified predicate raise `Not_found` if no element has been removed
remove_if [BatList.Labels] |
remove_if [BatList] | `remove_if cmp l` is similar to `remove`, but with `cmp` used instead of ( = ).
remove_if [BatLazyList.Labels] |
remove_if [BatLazyList] | `remove_if cmp l` is similar to `remove`, but with `cmp` used instead of ( = ).
remove_range [BatISet] |
remove_range [BatIMap] |
repeat [BatString] | `repeat s n` returns `s ^ s ^ ... ^ s`
repeat [BatEnum] | `repeat ~times:n x` creates a enum sequence filled with `n` times of `x`.
replace [BatString] | `replace ~str ~sub ~by` returns a tuple constisting of a boolean and a string where the first occurrence of the string `sub` within `str` has been replaced by the string `by`.
replace [BatRope] | `replace ~str ~sub ~by` returns a tuple constisting of a boolean and a rope where the first occurrence of the rope `sub` within `str` has been replaced by the rope `by`.
replace [BatInnerWeaktbl] | `Weaktbl.replace tbl x y` replaces the current binding of `x` in `tbl` by a binding of `x` to `y`.
replace [BatHashtbl.Cap.Labels] |
replace [BatHashtbl.Cap] |
replace [BatHashtbl.S.Labels] |
replace [BatHashtbl.S] |
replace [BatHashtbl.Labels] |
replace [BatHashtbl] | `Hashtbl.replace tbl x y` replaces the current binding of `x` in `tbl` by a binding of `x` to `y`.
replace_chars [BatString] | `replace_chars f s` returns a string where all chars `c` of `s` have been replaced by the string returned by `f c`.
replace_chars [BatRope] | `replace_chars f s` returns a rope where all chars `c` of `s` have been replaced by the rope returned by `f c`.
reserved_names [BatGenlex.Languages.Definition] |
reset [BatUTF8.Buf] | Empty the buffer and de-allocate the internal storage.
reshape [BatBigarray] | `reshape b [|d1;...;dN|]` converts the big array `b` to a `N`-dimensional array of dimensions `d1`...
reshape_1 [BatBigarray] | Specialized version of `Bigarray.reshape` for reshaping to one-dimensional arrays.
reshape_2 [BatBigarray] | Specialized version of `Bigarray.reshape` for reshaping to two-dimensional arrays.
reshape_3 [BatBigarray] | Specialized version of `Bigarray.reshape` for reshaping to three-dimensional arrays.
restart_on_EINTR [BatUnix] | `restart_on_EINTR f x` invokes `f` on `x` repetedly until the function returns a value or raise another exception than EINTR.
return [BatReturn] | Return to a label.
return [BatParserCo] | A parser which always succeds
return [BatOption.Monad] | `return x` puts a value in the Option monad, that is, returns `Some x`.
return [BatMonad.S] | Return a value, that is, put a value in the monad.
return [BatEnum.Monad] | This function puts a single value in the BatEnum monad, that is to say it creates an enumeration containing a single element.
rev [BatRefList] | Reverses the ref list - O(n)
rev [BatLazyList] | Eager list reversal.
rev [BatDllist] | List reversal.
rev [BatDeque] | `rev dq` reverses `dq`.
rev [BatArray.Cap] | Array transformations
rev [BatArray] | Array reversal.
rev_append [BatLazyList] | Eager reverse-and-append
rev_drop [BatDllist] | Remove node from the list no matter where it is.
rev_enum [BatDllist] | Create a reverse enum of the list.
rev_in_place [BatArray.Cap] |
rev_in_place [BatArray] | In-place array reversal.
rev_map [BatList.Labels] |
rev_map2 [BatList.Labels] |
rfind [BatString] | `rfind s x` returns the starting index of the last occurrence of string `x` within string `s`.
rfind [BatRope] | `rfind s x` returns the starting index of the last occurrence of rope `x` within rope `s`.
rfind [BatRefList] | Find the first element in the reversed ref list matching the specified predicate raise `Not_found` if no element is found
rfind [BatList.Labels.LExceptionless] |
rfind [BatList.Labels] |
rfind [BatList.Exceptionless] | `rfind p l` returns `Some x` where `x` is the last element of `l` such that `p x` returns `true` or `None` if such element as not been found.
rfind [BatList] | `rfind p l` returns the last element `x` of `l` such as `p x` returns `true` or raises `Not_found` if such element as not been found.
rfind [BatLazyList.Labels.Exceptionless] |
rfind [BatLazyList.Labels] |
rfind [BatLazyList.Exceptionless] | `rfind p l` returns `Some x` where `x` is the last element of `l` such that `p x` returns `true` or `None` if such element as not been found.
rfind [BatLazyList] | `rfind p l` returns the last element `x` of `l` such as `p x` returns `true` or raises `Not_found` if such element as not been found.
rfind_exn [BatLazyList.Labels] |
rfind_exn [BatLazyList] | `find_exn p e l` returns the last element of `l` such as `p x` returns `true` or raises `e` if such an element has not been found.
rfind_from [BatString] | `rfind_from s ofs x` behaves as `rfind s x` but starts searching from the right at offset `ofs`.
rfind_from [BatRope] | `rfind_from s ofs x` behaves as `rfind s x` but starts searching at offset `ofs`.
rfindi [BatLazyList.Labels.Exceptionless] |
rfindi [BatLazyList.Labels] |
rfindi [BatLazyList.Exceptionless] | `findi p e l` returns `Some (i, ai)` where `ai` and `i` are respectively the last element of `l` and its index, such that `p i ai` is true, or `None` if no such element has been found.
rfindi [BatLazyList] | `findi p e l` returns the last element `ai` of `l` along with its index `i` such that `p i ai` is true, or raises `Not_found` if no such element has been found.
right [BatString] | `left r len` returns the string containing the `len` last characters of `r`.
right [BatRope] | `left r len` returns the rope containing the `len` last characters of `r`
right_branch [BatAvlTree] |
rindex [BatUTF8] | As `String.rindex`
rindex [BatRope] | `Rope.rindex s c` returns the position of the rightmost occurrence of character `c` in rope `s`.
rindex [BatPathGen.StringType] |
rindex_from [BatRope] | Same as `BatRope.rindex`, but start searching at the character position given as second argument.
rindex_of [BatList] | `rindex_of e l` returns the index of the last occurrence of `e` in `l`, or `None` if there is no occurrence of `e` in `l`
rindex_of [BatLazyList] | `index_of e l` returns the index of the last occurrence of `e` in `l`, or `None` if there is no occurrence of `e` in `l`
rindex_ofq [BatList] | `rindex_ofq e l` behaves as `rindex_of e l` except it uses physical equality
rindex_ofq [BatLazyList] | `rindex_ofq e l` behaves as `rindex_of e l` except it uses physical equality
root [BatPathGen.PathType] | Root of the filesystem (`[""]`).
root [BatAvlTree] |
rope [BatUCharParser] | Recognize exactly one string
rope_enum [Batteries_print] |
rope_pset [Batteries_print] |
rope_set [Batteries_print] |
round [BatNum] |
rprintf [BatPrint] | `rprintf fmt` returns the result as a rope
rsplit [BatString] | `rsplit s sep` splits the string `s` between the last occurrence of `sep`, and returns the two parts before and after the occurence (excluded).
rsplit [BatRope] | `rsplit s sep` splits the rope `s` between the last occurrence of `sep`.
run [BatParserCo] | `run p s` executes parser `p` on source `s`.
run_initializers [BatOo.Oo.Internal] |
run_initializers_opt [BatOo.Oo.Internal] |
S
s [BatPathGen.PathType] | = `BatPathGen.PathType.to_string`
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`
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.
script [BatUChar] |
search [BatStr] | `search r s` searches for all the substrings of `s` matching regular expression `r`.
second [BatTuple.Tuple5] |
second [BatTuple.Tuple4] |
second [BatTuple.Tuple3] |
second [BatTuple.Tuple2] | Equivalent to `Pervasives.snd`.
second [BatStd] | Projection of a pair to its second element.
second [BatPervasives] | Apply a function to the second element of a pair.
self_init [BatRandom] | Initialize the generator with a more-or-less random seed chosen in a system-dependent way.
send [BatOo.Oo.Internal] |
sendcache [BatOo.Oo.Internal] |
sendself [BatOo.Oo.Internal] |
seq [BatLazyList] | `seq init step cond` creates a sequence of data, which starts from `init`, extends by `step`, until the condition `cond` fails.
seq [BatEnum.Labels] |
seq [BatEnum] | `seq init step cond` creates a sequence of data, which starts from `init`, extends by `step`, until the condition `cond` fails.
sequence [BatEnum.WithMonad] | `sequence e` evaluates each monadic elements (of type `'a m`) contained in the enumeration `e` to get a monadic enumeration of `'a` elements, of type `'a BatEnum.t m`.
set [BatVect.RANDOMACCESS] |
set [BatVect.Make] | `set r n c` returns a copy of the `r` vect where the element at index `n` (see also `get`) has been set to `c`.
set [BatVect] | `set v n c` returns a copy of the `v` vect where the (n+1)th element (see also `get`) has been set to `c`.
set [BatRope] | `set r n c` returns a copy of rope `r` where the (n+1)th character has been set to `c`.
set [BatRefList.Index] | Change the element at the specified index raise `Invalid_index` if the index is outside `0 ; length-1`
set [BatRef] | As `:=`
set [BatOptParse.Opt] | Set the value of an option.
set [BatGlobal] | Set the global value contents.
set [BatDynArray] | `set darr idx v` sets the element of `darr` at index `idx` to value `v`.
set [BatDllist] | Given a node, set the data associated with that node.
set [BatBitSet] | `set s n` sets the nth-bit in the bitset `s` to true.
set [BatBigarray.Array3] | `Array3.set a x y v`, or alternatively `a.{x,y,z} <- v`, stores the value `v` at coordinates (`x`, `y`, `z`) in `a`.
set [BatBigarray.Array2] | `Array2.set a x y v`, or alternatively `a.{x,y} <- v`, stores the value `v` at coordinates (`x`, `y`) in `a`.
set [BatBigarray.Array1] | `Array1.set a x v`, also written `a.{x} <- v`, stores the value `v` at index `x` in `a`.
set [BatBigarray.Genarray] | Assign an element of a generic big array.
set [BatArray.Cap] |
set_browser [Batteries_config] | `set_browser f` replaces the default browser with a function `f`.
set_formatter_out_channel [BatFormat] | Redirect the pretty-printer output to the given channel.
set_formatter_output [BatFormat] |
set_full_state [BatParserCo.Source] |
set_method [BatOo.Oo.Internal] |
set_methods [BatOo.Oo.Internal] |
set_permissions [BatFile] | Set the permissions on a file.
set_resizer [BatDynArray] | Change the resizer for this array.
set_state [BatRandom] | Set the state of the generator used by the basic functions.
set_to_map [BatIMap] |
shift [BatVect] | Return the first element of a vector and its last `n-1` elements.
shift_left [BatNativeint] | `Nativeint.shift_left x y` shifts `x` to the left by `y` bits.
shift_left [BatInt64] | `Int64.shift_left x y` shifts `x` to the left by `y` bits.
shift_left [BatInt32] | `Int32.shift_left x y` shifts `x` to the left by `y` bits.
shift_right [BatNativeint] | `Nativeint.shift_right x y` shifts `x` to the right by `y` bits.
shift_right [BatInt64] | `Int64.shift_right x y` shifts `x` to the right by `y` bits.
shift_right [BatInt32] | `Int32.shift_right x y` shifts `x` to the right by `y` bits.
shift_right_logical [BatNativeint] | `Nativeint.shift_right_logical x y` shifts `x` to the right by `y` bits.
shift_right_logical [BatInt64] | `Int64.shift_right_logical x y` shifts `x` to the right by `y` bits.
shift_right_logical [BatInt32] | `Int32.shift_right_logical x y` shifts `x` to the right by `y` bits.
should [BatParserCo] | Prevent backtracking.
shuffle [BatRandom] | `shuffle e` returns a new array, containing the same set of elements as `e`, but in a random order.
shutdown_connection [BatUnix] | ``Shut down'' a connection established with `Unix.open_connection`; that is, transmit an end-of-file condition to the server reading on the other side of the connection.
sign [BatNum] | Return `-1`, `0` or `1` according to the sign of the argument.
sign_big_int [BatBig_int] | Return `0` if the given big integer is zero, `1` if it is positive, and `-1` if it is negative.
signed_bytes_of [BatIO] | Read an enumeration of signed 8-bit integers.
sin [BatFloat.Safe_float] | See `BatFloat.Safe_float.atan2`.
sin [BatFloat] | See `BatFloat.atan2`.
singleton [BatVect.Make] | Returns a vect of length 1 holding only the given element.
singleton [BatVect] | Returns a Vect of length 1 holding only the given element.
singleton [BatSet.S] | `singleton x` returns the one-element set containing only `x`.
singleton [BatSet] | Creates a new set with the single given element in it.
singleton [BatPSet] |
singleton [BatPMap] |
singleton [BatMap.S] | `singleton x y` returns the one-element map that contains a binding `y` for `x`.
singleton [BatMap] | creates a new map with a single binding
singleton [BatISet] |
singleton [BatEnum] | Create an enumeration consisting in exactly one element.
singleton_tree [BatAvlTree] |
sinh [BatFloat.Safe_float] | See `BatFloat.Safe_float.tanh`.
sinh [BatFloat] | See `BatFloat.tanh`.
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] | See `BatHeap.size`.
size [BatHeap] | Number of elements in the heap.
size [BatDeque] | `size dq` is the number of elements in the `dq`.
size_of [BatFile] | `size_of name` returns the size of file `name` in bytes.
size_of_big [BatFile] | `size_of_big name` returns the size of file `name` in bytes, as a 64-bit integer.
skip [BatEnum] | `skip n e` removes the first `n` element from the enumeration, if any, then returns `e`.
skip [BatDllist] | `skip n i` Return the node that is `i` nodes after node `n` in the list.
slice [BatSubstring] | `slice sus i' None` returns the substring `(s, i+i', n-i')`, where `sus = (s, i, n)`.
slice [BatString] | `slice ?first ?last s` returns a "slice" of the string which corresponds to the characters `s.[first]`, `s.[first+1]`, ..., `s[last-1]`.
slice [BatRope] | `slice ?first ?last s` returns a "slice" of the rope which corresponds to the characters `s.[first]`, `s.[first+1]`, ..., `s[last-1]`.
slice_left [BatBigarray.Array2] | Extract a row (one-dimensional slice) of the given two-dimensional big array.
slice_left [BatBigarray.Genarray] | Extract a sub-array of lower dimension from the given big array by fixing one or several of the first (left-most) coordinates.
slice_left_1 [BatBigarray.Array3] | Extract a one-dimensional slice of the given three-dimensional big array by fixing the first two coordinates.
slice_left_2 [BatBigarray.Array3] | Extract a two-dimensional slice of the given three-dimensional big array by fixing the first coordinate.
slice_right [BatBigarray.Array2] | Extract a column (one-dimensional slice) of the given two-dimensional big array.
slice_right [BatBigarray.Genarray] | Extract a sub-array of lower dimension from the given big array by fixing one or several of the last (right-most) coordinates.
slice_right_1 [BatBigarray.Array3] | Extract a one-dimensional slice of the given three-dimensional big array by fixing the last two coordinates.
slice_right_2 [BatBigarray.Array3] | Extract a two-dimensional slice of the given three-dimensional big array by fixing the last coordinate.
snoc [BatDeque] | `snoc x dq` adds `x` to the rear of `dq`.
sort [BatRefList] | Sort elements using the specified comparator or compare as default comparator
sort [BatList] | Sort the list using optional comparator (by default `compare`).
sort [BatLazyList] | Sort the list using optional comparator (by default `compare`).
sort [BatArray.Cap.Labels] |
sort [BatArray.Cap] |
sort [BatArray.Labels] |
sort_unique [BatList] | `sort_unique cmp l` returns the list `l` sorted and without any duplicate element.
source [BatPathGen.StringType.Parse] |
source_map [BatParserCo] |
source_of_enum [BatUCharParser] | Create a source from an enumeration of unicode characters.
source_of_enum [BatCharParser] | Create a source from a latin-1 character.
source_of_rope [BatUCharParser] | Create a source from a Unicode Rope.
source_of_string [BatCharParser] | Create a source from a latin-1 character string.
span [BatSubstring] | `span sus1 sus2` returns a substring spanning from the start of `sus1` to the end of `sus2`, provided this is well-defined: `sus1` and `sus2` must have the same underlying string, and the start of `sus1` must not be to the right of the end of `sus2`; otherwise raises `Invalid_argument`.
span [BatEnum] | `span test e` produces two enumerations `(hd, tl)`, such that `hd` is the same as `take_while test e` and `tl` is the same as `drop_while test e`.
splice [BatString] | `String.splice s off len rep` cuts out the section of `s` indicated by `off` and `len` and replaces it by `rep`
splice [BatRope] | `splice s off len rep` returns the rope in which the section of `s` indicated by `off` and `len` has been cut and replaced by `rep`.
splice [BatDllist] | `splice n1 n2` Connects `n1` and `n2` so that `next n1 == n2 && prev n2 == n1`.
split [BatString] | `split s sep` splits the string `s` between the first occurrence of `sep`, and returns the two parts before and after the occurence (excluded).
split [BatStream] | `split` is the opposite of `comb`
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 [BatRope] | `split s sep` splits the rope `s` between the first occurrence of `sep`.
split [BatPathGen.PathType] | Dissect the path to its components (parent path, core part of name and possibly an extension).
split [BatPSet] |
split [BatPMap] |
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_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_leftmost [BatAvlTree] |
split_nth [BatList] | Obsolete.
split_nth [BatLazyList] | Obsolete.
split_on_char [BatSubstring] | `split_on_char c ss` returns substrings of input `ss` as divided by `c`
split_on_comma [BatSubstring] |
split_on_dot [BatSubstring] |
split_on_pipe [BatSubstring] |
split_on_slash [BatSubstring] |
split_rightmost [BatAvlTree] |
splitl [BatSubstring] | `splitl p sus` splits `sus` into a pair `(sus1, sus2)` of substrings where `sus1` is the longest prefix (left substring) all of whose characters satisfy `p`, and `sus2` is the rest.
splitr [BatSubstring] | `splitr p sus` splits `sus` into a pair `(sus1, sus2)` of substrings where `sus2` is the longest suffix (right substring) all of whose characters satisfy `p`, and `sus1` is the rest.
sprint [BatSeq] | Using a string printer, print a sequence to a string (as sprintf vs.
sprint [BatList] | Using a string printer, print a list to a string (as sprintf vs.
sprint [BatArray.Cap] |
sprint [BatArray] | Using a string printer, print an array to a string (as sprintf vs.
sprintf [BatPrintf] | A function which doesn't print its result but returns it as a string.
sprintf [BatPrint] | A function which doesn't print its result but returns it as a string.
sprintf [BatInnerIO.Printf] | A function which doesn't print its result but returns it as a string.
sprintf2 [BatPrintf] | A function which doesn't print its result but returns it as a string.
sprintf2 [BatInnerIO.Printf] | A function which doesn't print its result but returns it as a string.
sqrt [BatComplex] | Square root.
sqrt_big_int [BatBig_int] | `sqrt_big_int a` returns the integer square root of `a`, that is, the largest big integer `r` such that `r * r <= a`.
square [BatNum] |
square_big_int [BatBig_int] | Return the square of the given big integer
sscanf [BatScanf] | Same as `Scanf.bscanf`, but reads from the given string.
sscanf_format [BatScanf] | Same as `Scanf.bscanf_format`, but reads from the given string.
stable_sort [BatList.Labels] |
stable_sort [BatLazyList] |
stable_sort [BatArray.Cap.Labels] |
stable_sort [BatArray.Cap] |
stable_sort [BatArray.Labels] |
start [BatGenlex.Languages.Make] | Medium-level API
starts_with [BatString] | `starts_with s x` returns `true` if `s` is starting with `x`, `false` otherwise.
starts_with [BatRope] | `starts_with s x` returns `true` if `s` is starting with `x`, `false` otherwise.
state [BatParserCo] | Succeed and return the state of the parser
stats [BatOo.Oo.Internal] |
std_formatter [BatFormat] | The standard formatter used by the formatting functions above.
stderr [BatPervasives] | Standard error output, as per Unix/Windows conventions.
stderr [BatInnerIO] | Standard error output, as per Unix/Windows conventions.
stderr [BatIO] | Standard error output, as per Unix/Windows conventions.
stderr_formatter [BatLogger] | `stderr_formatter` is a standard formatter that outputs log events to stderr using the same format as `make_std_formatter`.
stdib [BatScanf.Scanning] | The scanning buffer reading from `stdin`.
stdin [BatPervasives] | Standard input, as per Unix/Windows conventions (by default, keyboard).
stdin [BatInnerIO] | Standard input, as per Unix/Windows conventions (by default, keyboard).
stdin [BatIO] | Standard input, as per Unix/Windows conventions (by default, keyboard).
stdnull [BatPervasives] | An output which discards everything written to it.
stdnull [BatInnerIO] | An output which discards everything written to it.
stdnull [BatIO] | An output which discards everything written to it.
stdout [BatPervasives] | Standard output, as per Unix/Windows conventions (by default, console).
stdout [BatInnerIO] | Standard output, as per Unix/Windows conventions (by default, console).
stdout [BatIO] | Standard output, as per Unix/Windows conventions (by default, console).
step_resizer [BatDynArray] | The stepwise resizer- another example of a resizer function, this time of a parameterized resizer.
store_const [BatOptParse.StdOpt] | `store_const ?default const` returns a flag option which stores the constant value `const` when the option is encountered on the command line.
store_false [BatOptParse.StdOpt] | `store_false ()` returns an option which is set to false when it is encountered on the command line.
store_true [BatOptParse.StdOpt] | `store_true ()` returns an option which is set to true when it is encountered on the command line.
str_callback [BatOptParse.StdOpt] | See `OptParse.StdOpt.int_callback`.
str_decode [BatBase64] | Decode a string encoded into Base64, raise `Invalid_char` if a character in the input string is not a valid one.
str_encode [BatBase64] | Encode a string into Base64.
str_option [BatOptParse.StdOpt] | See `OptParse.StdOpt.int_option`.
string [BatUCharParser] | Recognize exactly one string
string [BatGenlex.Languages.Make] | As `CharParser.string`, but case-insensitive if specified by `case_sensitive`.
string [BatCharParser] | Recognize exactly one string
string_dynarray [Batteries_print] |
string_enum [Batteries_print] |
string_literal [BatGenlex.Languages.Make] | Accepts a string, i.e.
string_of [BatUnit] | Convert the given unit to a string.
string_of_big_int [BatBig_int] | Return the string representation of the given big integer, in decimal (base 10).
string_of_cap [Batteries_print] |
string_of_char [BatStd] | creates a string from a char.
string_of_char [BatPervasives] | creates a string from a char.
string_pset [Batteries_print] |
string_set [Batteries_print] |
strings_of [BatIO] | Read an enumeration of null-terminated strings.
strip [BatString] | Returns the string without the chars if they are at the beginning or at the end of the string.
strip [BatRope] | Returns the rope without the chars if they are at the beginning or at the end of the rope.
sub [BatVect.RANDOMACCESS] |
sub [BatVect.Make] | `sub m n r` returns a sub-vect of `r` containing all the elements whose indexes range from `m` to `m + n - 1` (included).
sub [BatVect] | `sub m n r` returns a sub-vect of `r` containing all the elements whose indexes range from `m` to `m + n - 1` (included).
sub [BatUTF8] | As `String.sub`
sub [BatRope] | `sub r m n` returns a sub-rope of `r` containing all characters whose indexes range from `m` to `m + n - 1` (included).
sub [BatPathGen.StringType] | As `String.sub`, but indexed in specific way.
sub [BatNumber.Numeric] |
sub [BatNum] |
sub [BatNativeint] | Subtraction.
sub [BatInt64] | Subtraction.
sub [BatInt32] | Subtraction.
sub [BatInt.Safe_int] | Substraction.
sub [BatInt] | Subtraction.
sub [BatFloat.Safe_float] |
sub [BatFloat] |
sub [BatDynArray] | `sub darr start len` returns an array holding the subset of `len` elements from `darr` starting with the element at index `idx`.
sub [BatComplex] | Subtraction
sub [BatBool] |
sub [BatBigarray.Array1] | Extract a sub-array of the given one-dimensional big array.
sub [BatBig_int] |
sub [BatArray.Cap.Labels] |
sub [BatArray.Cap] |
sub [BatArray.Labels] |
sub_left [BatBigarray.Array3] | Extract a three-dimensional sub-array of the given three-dimensional big array by restricting the first dimension.
sub_left [BatBigarray.Array2] | Extract a two-dimensional sub-array of the given two-dimensional big array by restricting the first dimension.
sub_left [BatBigarray.Genarray] | Extract a sub-array of the given big array by restricting the first (left-most) dimension.
sub_right [BatBigarray.Array3] | Extract a three-dimensional sub-array of the given three-dimensional big array by restricting the second dimension.
sub_right [BatBigarray.Array2] | Extract a two-dimensional sub-array of the given two-dimensional big array by restricting the second dimension.
sub_right [BatBigarray.Genarray] | Extract a sub-array of the given big array by restricting the last (right-most) dimension.
subset [BatSet.S] | `subset s1 s2` tests whether the set `s1` is a subset of the set `s2`.
subset [BatSet] | `subset a b` returns true if `a` is a subset of `b`.
subset [BatPSet] |
subset [BatISet] |
substring [BatSubstring] | `substring s o l` returns a substring with base-string `s`, offset `o` and length `l`.
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] |
suffix_action [BatEnum] | `suffix_action f e` will behave as `e` but guarantees that `f ()` will be invoked after the contents of `e` are exhausted.
sum [BatList] | `sum l` returns the sum of the elements of `l`
sum [BatEnum] | `sum` returns the sum of the given int enum.
suspend [BatParserCo] | `suspend s` returns the state of the parser in a form that can be resumed by calling the returned function.
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 [BatBitSet] | `sym_diff s t` returns the symmetrical difference of `s` and `t`.
sync [BatConcurrent] | Specialized version of `synchronized`.
synchronize [BatRMutex] | Protect a function.
synchronize [BatMutex.Mutex] | Protect a function.
synchronize [BatConcurrent.Lock] |
synchronize [BatConcurrent] | `synchronize locker f` returns a function `f'` which behaves as `f` but whose executions are protected by one lock obtained from `locker`.
synchronize_in [BatIO] | `synchronize_in inp` produces a new `BatIO.input` which reads from `input` in a thread-safe way.
synchronize_out [BatIO] | `synchronize_out out` produces a new `BatIO.output` which writes to `output` in a thread-safe way.
T
t_printer [BatUref] | See `BatValue_printer`.
t_printer [BatUTF8] |
t_printer [BatUChar] |
t_printer [BatString] |
t_printer [BatSeq] |
t_printer [BatRope] |
t_printer [BatOption] |
t_printer [BatNativeint] |
t_printer [BatList] |
t_printer [BatInt] |
t_printer [BatHeap.H] | See `BatHeap.t_printer`.
t_printer [BatHeap] | See `BatValue_printer`.
t_printer [BatFloat.Safe_float] |
t_printer [BatFloat] |
t_printer [BatEnum] |
t_printer [BatDynArray] |
t_printer [BatDeque] | See `BatValue_printer`.
t_printer [BatChar] |
t_printer [BatBool] |
t_printer [BatArray] |
tab_out [BatIO] | Create an output shifted to the right by a number of spaces (or other character as specified by `tab`).
tail [BatString] | `tail r pos` returns the string containing all but the `pos` first characters of `r`
tail [BatRope] | `tail r pos` returns the rope containing all but the `pos` first characters of `r`
take [BatStream] | `take n stream` returns the prefix of `stream` of length `n`, or `stream` itself if `n` is greater than the length of `stream`
take [BatSeq] | `take n s` returns up to the `n` first elements from sequence `s`, if available.
take [BatQueue.Exceptionless] |
take [BatList] | `take n l` returns up to the `n` first elements from list `l`, if available.
take [BatLazyList] | `take n l` returns up to the `n` first elements from list `l`, if available.
take [BatEnum] | `take n e` returns the prefix of `e` of length `n`, or `e` itself if `n` is greater than the length of `e`
take_while [BatStream.StreamLabels] |
take_while [BatStream] | `take_while test stream` returns the longest (possibly empty) prefix of `stream` of elements that satisfy `test`.
take_while [BatSeq] | `take_while f s` returns the first elements of sequence `s` which satisfy the predicate `f`.
take_while [BatList.Labels] |
take_while [BatList] | `takewhile f xs` returns the first elements of list `xs` which satisfy the predicate `f`.
take_while [BatLazyList.Labels] |
take_while [BatLazyList] | `take_while f xs` returns the first elements of list `xs` which satisfy the predicate `f`.
take_while [BatEnum.Labels] |
take_while [BatEnum] | `take_while f e` produces a new enumeration in which only remain the first few elements `x` of `e` such that `f x`
takel [BatSubstring] | `takel p sus` returns the longest prefix (left substring) of `sus` all of whose characters satisfy predicate `p`.
taker [BatSubstring] | `taker p sus` returns the longest suffix (right substring) of `sus` all of whose characters satisfy predicate `p`.
takewhile [BatList] | obsolete, as `BatList.take_while`
tan [BatFloat.Safe_float] | See `BatFloat.Safe_float.atan2`.
tan [BatFloat] | See `BatFloat.atan2`.
tanh [BatFloat.Safe_float] | The usual hyperbolic trigonometric functions.
tanh [BatFloat] | The usual hyperbolic trigonometric functions.
tap [BatStd] |
tap [BatPervasives] | Allows application of a function in the middle of a pipe sequence without disturbing the sequence.
third [BatTuple.Tuple5] |
third [BatTuple.Tuple4] |
third [BatTuple.Tuple3] |
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 [BatLazyList] | Return the given list without its first element.
to_array [BatVect] | `to_array r` returns an array corresponding to the vect `r`.
to_array [BatLazyList] | Eager conversion to array.
to_array [BatDynArray] | `to_array darr` returns the elements of `darr` in order as an array.
to_array [BatBigarray.Array3] | Build a three-dimensional array initialized from the given big array.
to_array [BatBigarray.Array2] | Build a two-dimensional array initialized from the given big array.
to_array [BatBigarray.Array1] | Build a one-dimensional array initialized from the given big array.
to_array [BatArray.Cap] | Return a capability array as an array.
to_byte [BatInt32] |
to_channel [BatMarshal] |
to_char [BatUChar] | `to_char u` returns the Latin-1 representation of `u`.
to_container [BatVect.Make] | `to_container r` returns a container corresponding to the vect `r`.
to_enum_filter [BatGenlex] | Apply the lexer to an enum.
to_float [BatString] | Returns the float represented by the given string or raises `Failure "float_of_string"` if the string does not represent a float.
to_float [BatRope] | Returns the float represented by the given rope or raises Invalid_rope if the rope does not represent a float.
to_float [BatNumber.Numeric] |
to_float [BatNum] |
to_float [BatNativeint] | Convert the given native integer to a floating-point number.
to_float [BatInt64] | Convert the given 64-bit integer to a floating-point number.
to_float [BatInt32] | Convert the given 32-bit integer to a floating-point number.
to_float [BatInt.Safe_int] | Convert the given integer to a floating-point number.
to_float [BatInt] | Convert the given integer to a floating-point number.
to_float [BatFloat.Safe_float] |
to_float [BatFloat] |
to_float [BatComplex] | `Complex.to_float (a+bi)` returns the float `a`
to_float [BatBool] |
to_float [BatBig_int] |
to_format [Batteries_print] |
to_format [BatIO] |
to_input_channel [BatIO] | Create a channel that will read from an input.
to_int [BatUTF8.Byte] |
to_int [BatUChar] | Alias of `uint_code`
to_int [BatString] | Returns the integer represented by the given string or raises `Failure "int_of_string"` if the string does not represent an integer.
to_int [BatRope] | Returns the integer represented by the given rope or raises `Invalid_rope` if the rope does not represent an integer.
to_int [BatNumber.Discrete] |
to_int [BatNumber.Numeric] |
to_int [BatNum] |
to_int [BatNativeint] | Convert the given native integer (type `nativeint`) to an integer (type `int`).
to_int [BatInt64] | Convert the given 64-bit integer (type `int64`) to an integer (type `int`).
to_int [BatInt32] | Convert the given 32-bit integer (type `int32`) to an integer (type `int`).
to_int [BatInt.Safe_int] |
to_int [BatInt] |
to_int [BatFloat.Safe_float] |
to_int [BatFloat] |
to_int [BatComplex] |
to_int [BatBool] |
to_int [BatBig_int] |
to_int32 [BatNativeint] | Convert the given native integer to a 32-bit integer (type `int32`).
to_int32 [BatInt64] | Convert the given 64-bit integer (type `int64`) to a 32-bit integer (type `int32`).
to_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] | Converts a string to the list of its characters.
to_list [BatStream] | Convert a stream to a list
to_list [BatRefList] | Returns the current elements as a list - O(1)
to_list [BatLazyList] | Eager conversion to string.
to_list [BatHeap.H] | See `BatHeap.to_list`.
to_list [BatHeap] | Enumerate the elements of the heap.
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_nativeint [BatInt64] | Convert the given 64-bit integer (type `int64`) to a native integer.
to_nativeint [BatInt32] | Convert the given 32-bit integer (type `int32`) to a native integer.
to_object [BatEnum] | `to_object e` returns a representation of `e` as an object.
to_option [BatResult] | Convert a `result` to an `option`
to_stream [BatLazyList] | Lazy conversion to stream.
to_stream_filter [BatGenlex] | Apply the lexer to a stream.
to_string [BatUTF8] | Return an UTF-8 encoded string representing this Unicode string.
to_string [BatSubstring] | `string sus` is the string s`i..i+n-1` represented by sus = (s, i, n).
to_string [BatStream] | convert stream of chars to string, using buffer
to_string [BatRope] | `to_string t` returns a UTF-8 encoded string representing `t`
to_string [BatPathGen.StringType] | Convert to primitive string with UTF-8 content.
to_string [BatPathGen.PathType] | Convert to type primitive string with UTF-8 content.
to_string [BatNumber.Numeric] |
to_string [BatNum] | Convert a number to a string, using fractional notation.
to_string [BatNativeint] | Return the string representation of its argument, in decimal.
to_string [BatInt64] | Return the string representation of its argument, in decimal.
to_string [BatInt32] | Return the string representation of its argument, in signed decimal.
to_string [BatInt.Safe_int] | Return the string representation of its argument, in signed decimal.
to_string [BatInt] | Return the string representation of its argument, in signed decimal.
to_string [BatIO] |
to_string [BatFloat.Safe_float] |
to_string [BatFloat] |
to_string [BatComplex] |
to_string [BatBool] |
to_string [BatBig_int] |
to_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_table [BatHashtbl.Cap] | Return a capability hashtable as a regular hashtable.
to_ustring [BatRope] | `to_ustring r` returns the string corresponding to the rope `r`.
to_ustring [BatPathGen.PathType] | Convert to the chosen `ustring` type.
toggle [BatBitSet] | `toggle s n` changes the nth-bit value in the bitset `s`.
tokens [BatSubstring] | `tokens p sus` returns the list of tokens in `sus`, from left to right, where a token is a non-empty maximal substring of `sus` not containing any delimiter, and a delimiter is a character satisfying `p`.
top [BatStack.Exceptionless] |
transcode_in [BatCharEncodings] | Transcoders
transcode_out [BatCharEncodings] | Convert the contents of an output between encodings.
transform [BatRefList] | transform all elements in the ref list using a function.
translate [BatSubstring] | `translate f sus` applies `f` to every character of `sus`, from left to right, and returns the concatenation of the results.
trim [BatSubstring] | removes whitespace from left and right ends of input
trim [BatString] | Returns the same string but without the leading and trailing whitespaces (according to `BatChar.is_whitespace`).
trim [BatRope] | Transformations
triml [BatSubstring] | `triml k sus` returns sus less its leftmost k characters; or the empty string at the end of sus if it has less than k characters.
trimr [BatSubstring] | `trimr k sus` returns sus less its rightmost k characters; or the empty string at the beginning of sus if it has less than k characters.
try_lock [BatRMutex] | Same as `RMutex.lock`, but does not suspend the calling thread if the mutex is already locked: just return `false` immediately in that case.
try_lock [BatMutex.Mutex] | Same as `BatMutex.Mutex.lock`, but does not suspend the calling thread if the mutex is already locked: just return `false` immediately in that case.
try_lock [BatConcurrent.BaseLock] |
try_lock [BatConcurrent.Lock] |
U
uchars_of [BatIO] | offer the characters of an UTF-8 encoded input as an enumeration
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.
ulines_of [BatIO] | offer the lines of a UTF-8 encoded input as an enumeration
uncapitalize [BatRope] | Return a copy of the argument, with the first character set to lowercase.
uncombine [BatLazyList] | Divide a list of pairs into a pair of lists.
uncombine [BatEnum] | `uncombine` is the opposite of `combine`
uncurry [BatTuple.Tuple5] |
uncurry [BatTuple.Tuple4] |
uncurry [BatTuple.Tuple3] |
uncurry [BatTuple.Tuple2] |
uncurry [BatStd] | Turn a function that takes its arguments one at a time into a function that takes a pair as argument.
uncurry [BatPervasives] | Convert a function which accepts a two arguments into a function which accepts a pair of arguments.
undef [BatGlobal] | Reset the global value contents to undefined.
undefined [BatPervasives] | The undefined function.
unfold [BatLazyList] | `unfold data next` creates a (possibly infinite) lazy list from the successive results of applying `next` to `data`, then to the result, etc.
unfold [BatEnum.Labels] |
unfold [BatEnum] | As `from_loop`, except uses option type to signal the end of the enumeration.
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 [BatPSet] |
union [BatPMap] |
union [BatMap] | `union m1 m2` merges two maps, using the comparison function of `m1`.
union [BatISet] |
union [BatIMap] |
union [BatBitSet] | `union s t` return the union of sets `s` and `t`.
uniq [BatEnum] | `uniq e` returns a duplicate of `e` with repeated values omitted.
unique [BatStd] | returns an unique identifier every time it is called.
unique [BatPervasives] | Returns an unique identifier every time it is called.
unique [BatList] | `unique cmp l` returns the list `l` without any duplicate element.
unique [BatLazyList] | `unique cmp l` returns the list `l` without any duplicate element.
unique_cmp [BatList] | As `unique`, except comparator parameter returns an int
unique_eq [BatList] | As `unique` except comparator label is ~eq.
unique_eq [BatLazyList] | as `unique` except only uses an equality function.
unite [BatUref] | `unite ~sel ur1 ur2` unites the urefs `ur1` and `ur2`, selecting the result of `sel (uget ur1) (uget ur2)` for the contents of the resulting united uref.
unite [BatBitSet] | `unite s t` sets `s` to the union of the sets `s` and `t`.
unix_perm [BatFile] | Create a permission from a Unix-style octal integer.
unlock [BatRMutex] | Unlock the given mutex.
unlock [BatMutex.Mutex] | Unlock the given mutex.
unlock [BatConcurrent.BaseLock] |
unlock [BatConcurrent.Lock] |
unpack [BatInt32] | `unpack str off` reads 4 bytes from string `str` starting at offset `off` as a little-endian int32
unpack_big [BatInt32] | `unpack str off` reads 4 bytes from string `str` starting at offset `off` as a big-endian int32
unquoted_printer [BatString] |
unregister_formatter [BatLogger] | `unregister_formatter name` unregisters a named log formatter.
unsafe_get [BatVect.RANDOMACCESS] |
unsafe_get [BatDynArray] |
unsafe_get [BatBigarray.Array3] | Like `Bigarray.Array3.get`, but bounds checking is not always performed.
unsafe_get [BatBigarray.Array2] | Like `Bigarray.Array2.get`, but bounds checking is not always performed.
unsafe_get [BatBigarray.Array1] | Like `Bigarray.Array1.get`, but bounds checking is not always performed.
unsafe_set [BatVect.RANDOMACCESS] |
unsafe_set [BatDynArray] |
unsafe_set [BatBigarray.Array3] | Like `Bigarray.Array3.set`, but bounds checking is not always performed.
unsafe_set [BatBigarray.Array2] | Like `Bigarray.Array2.set`, but bounds checking is not always performed.
unsafe_set [BatBigarray.Array1] | Like `Bigarray.Array1.set`, but bounds checking is not always performed.
unset [BatBitSet] | `unset s n` sets the nth-bit in the bitset `s` to false.
until [BatISet] |
until [BatIMap] |
uppercase [BatUTF8] | Return a copy of the argument, with all lowercase letters translated to uppercase.
uppercase [BatUCharParser] | Recognizes one upper-case ASCII character, including accentuated characters.
uppercase [BatUChar] | Convert the given character to its equivalent uppercase character.
uppercase [BatRope] | `uppercase s` returns a uppercase copy of rope `s`.
uppercase [BatPervasives] | Return a copy of the argument, with all lowercase letters translated to uppercase, including accented letters of the ISO Latin-1 (8859-1) character set.
uppercase [BatCharParser] | Recognizes one upper-case ASCII character, including accentuated characters.
uppercase_latin1 [BatCharParser] | Recognizes one upper-case Latin-1 character, including accentuated characters.
uref [BatUref] | `uref x` allocates a new uref and places the value `x` in it.
uref_printer [BatUref] | See `BatValue_printer`.
usage [BatOptParse.OptParser] | Display the usage message to the channel `chn` (default is `Pervasives.stdout`) and return.
user_exec [BatFile] | Give the current user permission to execute the file.
user_read [BatFile] | Give the current user permission to read the file.
user_write [BatFile] | Give the current user permission to write the file
uset [BatUref] | `uset ur x` updates the contents of `ur` with `x`.
ustring [BatUCharParser] | Recognize exactly one string
V
validate [BatUTF8] | `validate s` succeeds if s is valid UTF-8, otherwise raises `Malformed_code`.
value_option [BatOptParse.Opt] | Make an option which takes a single argument.
values [BatPMap] |
values [BatMap.S] | Return an enumeration of al the values of a map.
values [BatMap] | Return an enumeration of al the values of a map.
values [BatHashtbl.Cap] |
values [BatHashtbl.S] |
values [BatHashtbl] | Return an enumeration of all the values of a hashtable.
version [Batteries_config] | The version of OCaml Batteries Included, as a human-readable freeform string.
version_option [BatOptParse.StdOpt] | `version_option f` returns the standard version option which displays the string returned by `f ()` (and nothing else) on standard output and exits.
W
while_do [BatEnum] | `while_do cont f e` is a loop on `e` using `f` as body and `cont` as condition for continuing.
whitespace [BatUCharParser] | Recognizes white-space
whitespace [BatCharParser] | Recognizes white-space
whitespaces [BatGenlex.Languages.Make] |
widen [BatOo.Oo.Internal] |
with_dispose [BatStd] | `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 [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_file_in [BatFile] | `with_file_in file_name f` opens the file named `file_name` for reading, invokes `f` to process the contents of that file then, once `f` has returned or triggered an exception, closes the file before proceeding.
with_file_out [BatFile] | `with_file_out file_name f` opens the file named `file_name` for writing, invokes `f` to write onto that file then, once `f` has returned or triggered an exception, closes the file before proceeding.
with_label [BatReturn] | as `label`
with_log [BatLogger] | `with_log logger level event_fun ?result body` logs an event before and after calling `body ()`.
with_temporary_out [BatFile] | `with_temporary_out f` opens a new temporary file for writing, invokes `f` with to write onto that file then, once `f` has returned or triggered an exception, closes the file before proceeding.
word_size [Batteries_config] | Size of one word on the machine currently executing the Caml program, in bits: 32 or 64.
would_at_fail [BatLazyList] | `would_at_fail l n` returns `true` if `l` contains strictly less than `n` elements, `false` otherwise
wrap [BatStd] | `wrap f x` wraps a function that would normally throw an exception on failure such that it now returns a result with either the `Ok` return value or the `Bad` exception.
wrap [BatOptParse.Formatter] | `wrap text width` reflows the given text paragraph into lines of width at most `width` (lines may exceed this if the are single words that exceed this limit).
wrap_in [BatInnerIO] | Fully create an input reading from other inputs by giving all the needed functions.
wrap_in [BatIO] | Fully create an input reading from other inputs by giving all the needed functions.
wrap_out [BatInnerIO] | Fully create an output that writes to one or more underlying outputs.
wrap_out [BatIO] | Fully create an output that writes to one or more underlying outputs.
write [BatInnerIO] | Write a single char to an output.
write [BatIO] | Write a single char to an output.
write_bits [BatIO] | Write up to 31 bits represented as a value, raise Bits_error if nbits < 0 or nbits > 31 or the value representation excess nbits.
write_bitss [BatIO] | Write an enumeration of bits
write_buf [BatInnerIO] | Write the contents of a buffer to an output.
write_buf [BatIO] | Write the contents of a buffer to an output.
write_byte [BatInnerIO] | Write an unsigned 8-bit byte.
write_byte [BatIO] | Write an unsigned 8-bit byte.
write_bytes [BatIO.BigEndian] | Write an enumeration of unsigned 8-bit bytes.
write_bytes [BatIO] | Write an enumeration of unsigned 8-bit bytes.
write_chars [BatIO] | Write an enumeration of chars.
write_chunks [BatIO] | Write an enumeration of strings, without appending null characters.
write_double [BatInnerIO] | Write an IEEE double precision floating point value.
write_double [BatIO.BigEndian] | Write an IEEE double precision floating point value.
write_double [BatIO] | Write an IEEE double precision floating point value.
write_doubles [BatIO.BigEndian] | Write an enumeration of IEEE double precision floating point value.
write_doubles [BatIO] | Write an enumeration of IEEE double precision floating point value.
write_float [BatInnerIO] | Write an IEEE single precision floating point value.
write_float [BatIO.BigEndian] | Write an IEEE single precision floating point value.
write_float [BatIO] | Write an IEEE single precision floating point value.
write_i16 [BatInnerIO] | Write a signed 16-bit word.
write_i16 [BatIO.BigEndian] | Write a signed 16-bit word.
write_i16 [BatIO] | Write a signed 16-bit word.
write_i16s [BatIO.BigEndian] | Write an enumeration of signed 16-bit words.
write_i16s [BatIO] | Write an enumeration of signed 16-bit words.
write_i32 [BatInnerIO] | Write a signed 32-bit integer.
write_i32 [BatIO.BigEndian] | Write a signed 32-bit integer.
write_i32 [BatIO] | Write a signed 32-bit integer.
write_i32s [BatIO.BigEndian] | Write an enumeration of signed 32-bit integers.
write_i32s [BatIO] | Write an enumeration of signed 32-bit integers.
write_i64 [BatInnerIO] | Write an OCaml int64.
write_i64 [BatIO.BigEndian] | Write an OCaml int64.
write_i64 [BatIO] | Write an OCaml int64.
write_i64s [BatIO.BigEndian] | Write an enumeration of OCaml int64s.
write_i64s [BatIO] | Write an enumeration of OCaml int64s.
write_line [BatInnerIO] | Write a line and append a LF (it might be converted to CRLF on some systems depending on the underlying BatIO).
write_line [BatIO] | Write a line and append a line end.
write_lines [BatIO] | Write an enumeration of lines, appending a LF (it might be converted to CRLF on some systems depending on the underlying BatIO).
write_lines [BatFile] | `write_lines name lines` writes strings given by `lines` to file `name` with newline character appended to each line.
write_only [BatHashtbl.Cap] | Drop to write-only permissions.
write_only [BatArray.Cap] | Drop to write-only permissions.
write_real_i32 [BatInnerIO] | Write an OCaml int32.
write_real_i32 [BatIO.BigEndian] | Write an OCaml int32.
write_real_i32 [BatIO] | Write an OCaml int32.
write_real_i32s [BatIO.BigEndian] | Write an enumeration of OCaml int32s.
write_real_i32s [BatIO] | Write an enumeration of OCaml int32s.
write_rope [BatIO] | Write a character rope onto a UTF-8 encoded output.
write_ropes [BatIO] | Write an enumeration of ropes onto a UTF-8 encoded output, without appending a line-end.
write_string [BatInnerIO] | Write a string and append an null character.
write_string [BatIO] | Write a string and append an null character.
write_strings [BatIO] | Write an enumeration of strings, appending null characters.
write_uchar [BatIO] | Write one uchar to a UTF-8 encoded output.
write_uchars [BatIO] | Write an enumeration of characters onto a UTF-8 encoded output.
write_ui16 [BatInnerIO] | Write an unsigned 16-bit word.
write_ui16 [BatIO.BigEndian] | Write an unsigned 16-bit word.
write_ui16 [BatIO] | Write an unsigned 16-bit word.
write_ui16s [BatIO.BigEndian] | Write an enumeration of unsigned 16-bit words.
write_ui16s [BatIO] | Write an enumeration of unsigned 16-bit words.
write_uline [BatIO] | Write one line onto a UTF-8 encoded output.
write_ulines [BatIO] | Write an enumeration of lines onto a UTF-8 encoded output.
X
xprint [BatInt] | prints as hex string
Z
zero [BatNumber.Numeric] |
zero [BatNum] | Usual operations
zero [BatNativeint] | The native integer 0.
zero [BatInt64] | The 64-bit integer 0.
zero [BatInt32] | The 32-bit integer 0.
zero [BatInt.Safe_int] | The integer `0`.
zero [BatInt] | The integer `0`.
zero [BatFloat.Safe_float] | Floating number zero.
zero [BatFloat] | Floating number zero.
zero [BatComplex] | The complex number `0`.
zero [BatBool] |
zero [BatBig_int] |
zero_plus [BatParserCo] | Accept a (possibly empty) list of expressions.