# Index of values

( * ) [BatNum] |
( * ) [BatNativeint] |
( * ) [BatInt64] |
( * ) [BatInt.Safe_int] | Multiplication.
( * ) [BatInt] | Multiplication.
( * ) [BatFloat.Safe_float] |
( * ) [BatFloat] |
( * ) [BatComplex] |
( * ) [BatBounded.NumericSig] |
( * ) [BatBool] |
( * ) [BatNumber.Infix] |
( * ) [BatBig_int] |
( ** ) [BatNum] |
( ** ) [BatNativeint] |
( ** ) [BatInt64] |
( ** ) [BatInt.Safe_int] | `a ** b` computes ab
( ** ) [BatInt] | `a ** b` computes ab
( ** ) [BatFloat.Safe_float] |
( ** ) [BatFloat] |
( ** ) [BatComplex] |
( ** ) [BatBool] |
( ** ) [BatNumber.Infix] |
( ** ) [BatBig_int] |
( **/ ) [BatNum.Infix] |
( **/ ) [BatNum.TaggedInfix] |
( **/ ) [BatNum] |
( */ ) [BatNum.Infix] |
( */ ) [BatNum.TaggedInfix] |
( */ ) [BatNum] |
( *: ) [BatBounded.NumericSig] |
( *= ) [BatNumber.RefOps] |
( ~* ) [BatParserCo.Infix] |
( ~* ) [BatParserCo] | As `zero_plus` without arguments.
(!!) [BatPathGen.PathType.OperatorLift] | Prefix operator that converts primitive string to `ustring`.
(!) [BatRef] | `!r` returns the current contents of reference `r`.
(%) [BatPervasives] | Function composition: the mathematical `o` operator.
(%) [BatInnerPervasives] |
(%>) [BatPervasives] | Piping function composition.
(%>) [BatInnerPervasives] |
(&&) [BatBool] | The boolean ``and''.
(+) [BatNum] |
(+) [BatNativeint] |
(+) [BatInt64] |
(+) [BatInt.Safe_int] | Addition.
(+) [BatInt] | Addition.
(+) [BatFloat.Safe_float] |
(+) [BatFloat] |
(+) [BatComplex] |
(+) [BatBounded.NumericSig] |
(+) [BatBool] |
(+) [BatNumber.Infix] |
(+) [BatBig_int] |
(+/) [BatNum.Infix] |
(+/) [BatNum.TaggedInfix] |
(+/) [BatNum] |
(+:) [BatBounded.NumericSig] |
(+=) [BatNumber.RefOps] |
(-) [BatNum] |
(-) [BatNativeint] |
(-) [BatInt64] |
(-) [BatInt.Safe_int] | Substraction.
(-) [BatInt] | Subtraction.
(-) [BatFloat.Safe_float] |
(-) [BatFloat] |
(-) [BatComplex] |
(-) [BatBounded.NumericSig] |
(-) [BatBool] |
(-) [BatNumber.Infix] |
(-) [BatBig_int] |
(--) [BatSeq.Infix] |
(--) [BatPervasives] | Enumerate numbers.
(--) [BatNumber.Discrete] |
(--) [BatNativeint] | Enumerate an interval.
(--) [BatInt64] | Enumerate an interval.
(--) [BatInt32] | Enumerate an interval.
(--) [BatInt] | Enumerate an interval.
(--) [BatFloat] |
(--) [BatEnum.Infix] | As `range`, without the label.
(--) [BatEnum] |
(--) [BatComplex] |
(--) [BatChar.Infix] |
(--) [BatChar] | Produce the enumeration of a segment of characters.
(--) [BatBool] |
(--) [BatNumber.Infix] |
(--) [BatBig_int] |
(---) [BatSeq.Infix] |
(---) [BatPervasives] | As `--`, but accepts enumerations in reverse order.
(---) [BatNumber.Discrete] |
(---) [BatNativeint] | Enumerate an interval.
(---) [BatInt64] | Enumerate an interval.
(---) [BatInt32] | Enumerate an interval.
(---) [BatInt] | Enumerate an interval.
(---) [BatFloat] |
(---) [BatEnum.Infix] | As `--`, but accepts enumerations in reverse order.
(---) [BatEnum] |
(---) [BatComplex] |
(---) [BatBool] |
(---) [BatNumber.Infix] |
(---) [BatBig_int] |
(--.) [BatSeq.Infix] |
(--.) [BatPervasives] | `(a, step) --. b)` creates a float enumeration from `a` to `b` with an increment of `step` between elements.
(--.) [BatEnum.Infix] | `(a, step) --. b)` creates a float enumeration from `a` to `b` with an increment of `step` between elements.
(--.) [BatEnum] |
(-->) [BatMultiPMap.Infix] | `map-->key` returns the current binding of `key` in `map`.
(-->) [BatMultiMap.Infix] | `map-->key` returns the current binding of `key` in `map`.
(-->) [BatMap.PMap.Infix] | `map-->key` returns the current binding of `key` in `map`, or raises `Not_found`.
(-->) [BatMap.PMap] | Map find and insert from Infix
(-->) [BatMap.Infix] | `map-->key` returns the current binding of `key` in `map`, or raises `Not_found`.
(-->) [BatMap.S.Infix] | `map-->key` returns the current binding of `key` in `map`, or raises `Not_found`.
(-->) [BatMap] | Map find and insert from Infix
(-->) [BatIMap.Infix] | `map-->key` returns the current binding of `key` in `map`, or
(-->) [BatHashtbl.S.Infix] | `tbl-->x` returns the current binding of `x` in `tbl`, or raises `Not_found` if no such binding exists.
(-->) [BatHashtbl.Infix] | `tbl-->x` returns the current binding of `x` in `tbl`, or raises `Not_found` if no such binding exists.
(--^) [BatSeq.Infix] |
(--^) [BatPervasives] | Enumerate numbers, without the right endpoint
(--^) [BatEnum.Infix] | As `(--)` but without the right endpoint
(--^) [BatEnum] |
(--~) [BatSeq.Infix] |
(--~) [BatPervasives] | As ( -- ), but for characters.
(--~) [BatEnum.Infix] | As ( -- ), but for characters.
(--~) [BatEnum] |
(-/) [BatNum.Infix] |
(-/) [BatNum.TaggedInfix] |
(-/) [BatNum] |
(-:) [BatBounded.NumericSig] |
(-=) [BatNumber.RefOps] |
(/) [BatNum] |
(/) [BatNativeint] |
(/) [BatInt64] |
(/) [BatInt.Safe_int] | Integer division.
(/) [BatInt] | Integer division.
(/) [BatFloat.Safe_float] |
(/) [BatFloat] |
(/) [BatComplex] |
(/) [BatBounded.NumericSig] |
(/) [BatBool] |
(/) [BatNumber.Infix] |
(/) [BatBig_int] |
(//) [BatSeq.Infix] |
(//) [BatPervasives] | Filtering (pronounce this operator name "such that").
(//) [BatNum.Infix] |
(//) [BatNum.TaggedInfix] |
(//) [BatNum] |
(//) [BatEnum.Infix] | Filtering (pronounce this operator name "such that").
(//) [BatEnum] |
(//@) [BatSeq.Infix] |
(//@) [BatPervasives] |
(//@) [BatPathGen.PathType.Infix] |
(//@) [BatPathGen.PathType.Operators] | `basepath//@relpath` catenates two paths.
(//@) [BatEnum.Infix] |
(//@) [BatEnum] |
(/:) [BatPathGen.PathType.Infix] |
(/:) [BatPathGen.PathType.Operators] | `path/:name` is a path of `name` located in a directory `path`.
(/:) [BatBounded.NumericSig] |
(/=) [BatNumber.RefOps] |
(/@) [BatSeq.Infix] |
(/@) [BatPervasives] |
(/@) [BatEnum.Infix] |
(/@) [BatEnum] |
(:=) [BatRef] | `r := a` stores the value of `a` in reference `r`.
(<) [BatInt.Safe_int] | Comparaison: `a < b` is true if and only if `a` is strictly smaller than `b`.
(<) [BatInt] |
(<) [BatNumber.Compare] |
(<--) [BatMultiPMap.Infix] | `map<--(key, value)` returns a map containing the same bindings as `map`, plus a binding of `key` to `value`.
(<--) [BatMultiMap.Infix] | `map<--(key, value)` returns a map containing the same bindings as `map`, plus a binding of `key` to `value`.
(<--) [BatMap.PMap.Infix] | `map<--(key, value)` returns a map containing the same bindings as `map`, plus a binding of `key` to `value`.
(<--) [BatMap.PMap] |
(<--) [BatMap.Infix] | `map<--(key, value)` returns a map containing the same bindings as `map`, plus a binding of `key` to `value`.
(<--) [BatMap.S.Infix] | `map<--(key, value)` returns a map containing the same bindings as `map`, plus a binding of `key` to `value`.
(<--) [BatMap] |
(<--) [BatIMap.Infix] | `map<--(key, value)` returns a map containing the same bindings as `map`, plus a binding of `key` to `value`.
(<--) [BatHashtbl.S.Infix] | `tbl<--(x, y)` adds a binding of `x` to `y` in table `tbl`.
(<--) [BatHashtbl.Infix] | `tbl<--(x, y)` adds a binding of `x` to `y` in table `tbl`.
(</) [BatNum.Infix] |
(</) [BatNum.TaggedInfix] |
(</) [BatNum] |
(<=) [BatInt.Safe_int] | Comparaison: `a <= b` is true if and only if `a` is smaller or equalto `b`.
(<=) [BatInt] |
(<=) [BatNumber.Compare] |
(<=/) [BatNum.Infix] |
(<=/) [BatNum.TaggedInfix] |
(<=/) [BatNum] |
(<>) [BatInt.Safe_int] | Comparaison: `a <> b` is true if and only if `a` and `b` have different values.
(<>) [BatInt] |
(<>) [BatNumber.Compare] |
(<>/) [BatNum.Infix] |
(<>/) [BatNum.TaggedInfix] |
(<>/) [BatNum] |
(<|>) [BatParserCo.Infix] |
(<|>) [BatParserCo] | Accept one of two parsers
(=) [BatInt.Safe_int] | Comparaison: `a = b` if and only if `a` and `b` have the same value.
(=) [BatInt] |
(=) [BatNumber.Compare] |
(=/) [BatNum.Infix] |
(=/) [BatNum.TaggedInfix] |
(=/) [BatNum] |
(=~) [BatFloat.Infix] | Approximate comparison of two floats, as `approx_equal`.
(>) [BatInt.Safe_int] | Comparaison: `a > b` is true if and only if `a` is strictly greater than `b`.
(>) [BatInt] |
(>) [BatNumber.Compare] |
(>/) [BatNum.Infix] |
(>/) [BatNum.TaggedInfix] |
(>/) [BatNum] |
(>::) [BatParserCo.Infix] |
(>::) [BatParserCo] | As `cons`
(>=) [BatInt.Safe_int] | Comparaison: `a >= b` is true if and only if `a` is greater or equal to `b`.
(>=) [BatInt] |
(>=) [BatNumber.Compare] |
(>=/) [BatNum.Infix] |
(>=/) [BatNum.TaggedInfix] |
(>=/) [BatNum] |
(>>=) [BatResult.Infix] |
(>>=) [BatResult.Monad] | as `bind`
(>>=) [BatParserCo.Infix] |
(>>=) [BatParserCo] | As `bind`
(>>>) [BatParserCo.Infix] |
(>>>) [BatParserCo] | As `bind`, but ignoring the result
(@) [BatPervasives] | List concatenation.
(@) [BatList.Infix] |
(@) [BatList] | Tail recursive `List.append`.
(@/) [BatSeq.Infix] |
(@/) [BatPervasives] | Mapping operators.
(@/) [BatEnum.Infix] | Mapping operators.
(@/) [BatEnum] |
(@//) [BatSeq.Infix] |
(@//) [BatPervasives] | Map combined with filter.
(@//) [BatEnum.Infix] | Map combined with filter.
(@//) [BatEnum] |
(@@) [BatPervasives] |
(@@) [BatInnerPervasives] |
(^:^) [BatLazyList.Infix] |
(^:^) [BatLazyList] | As `cons`: `x^:^l` is the lazy list with head `x` and tail `l`
(^@^) [BatLazyList.Infix] |
(^@^) [BatLazyList] | As lazy append
(^^) [BatParserCo.Infix] |
(^^) [BatParserCo] | `p ^^ n` is the same thing as `times n p`
(^^^) [BatText] | As `BatText.append`
(|>) [BatteriesPrint] |
(|>) [BatPervasives] |
(|>) [BatInnerPervasives] |
(|?) [BatPervasives] | Like `BatOption.default`, with the arguments reversed.
(|?) [BatOption.Infix] | Like `BatOption.default`, with the arguments reversed.
(|?) [BatOption] | Like `BatOption.default`, with the arguments reversed.
(|?) [BatInnerPervasives] |
(||) [BatBool] | The boolean ``or''.
(~+) [BatParserCo.Infix] |
(~+) [BatParserCo] | As `one_plus`
(~?) [BatParserCo.Infix] |
(~?) [BatParserCo] | As `maybe`
A
abs [BatNumber.Numeric] |
abs [BatNum] |
abs [BatNativeint] | Return the absolute value of its argument.
abs [BatInt64] | Return the absolute value of its argument.
abs [BatInt32] | Return the absolute value of its argument.
abs [BatInt.Safe_int] | Return the absolute value of its argument.
abs [BatInt] | Return the absolute value of its argument, except when the argument is `min_num`.
abs [BatFloat.Safe_float] | The absolute value of a floating point number.
abs [BatFloat] | The absolute value of a floating point number.
abs [BatComplex] | `abs c` returns the module of this complex number, i.e.
abs [BatBool] |
abs [BatBig_int] |
abs_big_int [BatBig_int] | Absolute value.
abs_num [BatNum] |
accept [BatUnix] | Accept connections on the given socket.
access [BatUnix] | Check that the process has the given permissions over the named file.
acos [BatFloat.Safe_float] | See `BatFloat.Safe_float.atan2`.
acos [BatFloat] | See `BatFloat.atan2`.
add [BatSet.PSet] | `add x s` returns a set containing all elements of `s`, plus `x`.
add [BatSet.S] | `add x s` returns a set containing all elements of `s`, plus `x`.
add [BatSet] | `add x s` returns a set containing all elements of `s`, plus `x`.
add [BatRefList] | Adds an element at the end - O(n)
add [BatQueue] | `add x q` adds the element `x` at the end of the queue `q`.
add [BatOptParse.OptParser] | Add an option to the option parser.
add [BatNumber.Numeric] |
add [BatNum] |
add [BatNativeint] | Addition.
add [BatMultiPMap] | `add x y m` returns a map containing the same bindings as `m`, plus a binding of `x` to `y`.
add [BatMultiMap] | `add x y m` returns a map containing the same bindings as `m`, plus a binding of `x` to `y`.
add [BatMap.PMap] | `add x y m` returns a map containing the same bindings as `m`, plus a binding of `x` to `y`.
add [BatMap.S.Labels] |
add [BatMap.S] | `add x y m` returns a map containing the same bindings as `m`, plus a binding of `x` to `y`.
add [BatMap] | `add x y m` returns a map containing the same bindings as `m`, plus a binding of `x` to `y`.
add [BatInt64] | Addition.
add [BatInt32] | Addition.
add [BatInt.Safe_int] | Addition.
add [BatInt] | Addition.
add [BatInnerWeaktbl] | `Weaktbl.add tbl x y` adds a binding of `x` to `y` in table `tbl`.
add [BatISet] | Add the given int to the set, returning a new set
add [BatIMap] | `add x y t` adds a binding from `x` to `y` in `t`, returning a new map.
add [BatHeap.H] | 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 [BatBitSet] | `add n s` returns a copy of `s` with bit `n` true.
add [BatBig_int] |
add_big_int [BatBig_int] | Addition.
add_buffer [BatUTF8.Buf] | `add_buffer b1 b2` adds the contents of `b2` to `b1`.
add_buffer [BatBuffer] | `add_buffer b1 b2` appends the current contents of buffer `b2` at the end of buffer `b1`.
add_carry [BatMap.PMap] | `add_carry k v m` adds the binding `(k,v)` to `m`, returning the new map and optionally the previous value bound to `k`.
add_carry [BatMap] | `add_carry k v m` adds the binding `(k,v)` to `m`, returning the new map and optionally the previous value bound to `k`.
add_channel [BatBuffer] |
add_char [BatUTF8.Buf] | Add one Unicode character to the buffer.
add_char [BatBuffer] | `add_char b c` appends the character `c` at the end of the buffer `b`.
add_group [BatOptParse.OptParser] | Add a group to the option parser.
add_initializer [BatOo.Internal] |
add_input [BatBuffer] | `add_input b ic n` reads exactly `n` character from the input `ic` and stores them at the end of buffer `b`.
add_int_big_int [BatBig_int] | Addition of a small integer to a big integer.
add_num [BatNum] |
add_range [BatISet] | `add_range lo hi t` adds the range of integers `lo, hi` (including both endpoints) to the given set, returning a new set
add_range [BatIMap] | `add lo hi y t` adds bindings to `y` for all values in the range `lo,hi`, returning a new map
add_sort [BatRefList] | Adds an element in a sorted list, using the given comparator.
add_string [BatUTF8.Buf] | Add the UTF-8 string to the buffer.
add_string [BatBuffer] | `add_string b s` appends the string `s` at the end of the buffer `b`.
add_substitute [BatBuffer] | `add_substitute b f s` appends the string pattern `s` at the end of the buffer `b` with substitution.
add_substring [BatBuffer] | `add_substring b s ofs len` takes `len` characters from offset `ofs` in string `s` and appends them at the end of the buffer `b`.
advance [BatCharParser] | Advance by one char.
after [BatISet] | `after x t` returns the portion of `t` in the range `x+1, max_int`
after [BatIMap] | Return the sub-map of bindings in the range `x+1,max_int`
alarm [BatUnix] | Schedule a `SIGALRM` signal after the given number of seconds.
all [BatSubstring] | `all s` is the substring `(s, 0, size s)`.
allocated_bytes [BatGc] | Return the total number of bytes allocated since the program was started.
and_big_int [BatBig_int] | Bitwise logical ``and''.
any [BatParserCo] | Accept any singleton value.
any_option [BatOptParse.StdOpt] | `any_option ?default ?metavar coerce` returns an option which takes a single argument from the command line and calls `coerce` to coerce it to the proper type.
apnd [BatStream] | `apnd fla flb` equals `[<fla;flb>]`.
append [BatVect.RANDOMACCESS] |
append [BatVect.Make] | `append c r` returns a new vect with the `c` element at the end in amortized `O(1)` time.
append [BatVect] | `append c r` returns a new vect with the `c` element at the end in amortized `O(1)` time.
append [BatText] | `append r u` concatenates the `r` and `u` ropes.
append [BatSeq] | `append s1 s2` returns the sequence which first returns all elements of `s1` then all elements of `s2`.
append [BatPathGen.PathType] | Alternative name for `BatPathGen.PathType.Operators.(/:)`
append [BatList] | Catenate two lists.
append [BatLazyList] | Lazy append
append [BatFingerTree.S] | `append` is equivalent to `List.append`.
append [BatEnum] | `append e1 e2` returns an enumeration that will enumerate over all elements of `e1` followed by all elements of `e2`.
append [BatDynArray] | `append src dst` adds all elements of `src` to the end of `dst`.
append [BatDllist] | `append n a` Creates a new node containing data `a` and inserts it into the list after node `n`.
append [BatDeque] | `append dq1 dq2` represents the concatenateion of `dq1` and `dq2`.
append [BatArray.Cap] |
append [BatArray] | `Array.append v1 v2` returns a fresh array containing the concatenation of the arrays `v1` and `v2`.
append_char [BatText] | `append_char c r` returns a new rope with the `c` character at the end in amortized `O(1)` time.
append_list [BatDeque] | `append_list dq l` is equivalent to `append dq (of_list l)`, but more efficient.
apply [BatOption] | `apply None x` returns `x` and `apply (Some f) x` returns `f x`
approx [BatNum] | `approx n` return the integer closest to `n`
approx_equal [BatFloat] | Test whether two floats are approximately equal (i.e.
approx_num_exp [BatNum] | Approximate a number by a decimal.
approx_num_fix [BatNum] | See `Num.approx_num_exp`.
arg [BatComplex] | Argument.
arg_max [BatEnum] | `arg_min f xs` returns the `x` in `xs` for which `f x` is minimum.
arg_min [BatEnum] |
args [BatPervasives] | An enumeration of the arguments passed to this program through the command line.
argv [BatSys] | The command line arguments given to the process.
array1_of_genarray [BatBigarray] | Return the one-dimensional big array corresponding to the given generic big array.
array2_of_genarray [BatBigarray] | Return the two-dimensional big array corresponding to the given generic big array.
array3_of_genarray [BatBigarray] | Return the three-dimensional big array corresponding to the given generic big array.
asin [BatFloat.Safe_float] | 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 [BatList] | `assoc a l` returns the value associated with key `a` in the list of pairs `l`.
assoc [BatLazyList.Labels.Exceptionless] |
assoc [BatLazyList.Exceptionless] | `assoc a l` returns `Some b` where `b` is the value associated with key `a` in the list of pairs `l`.
assoc [BatLazyList] | `assoc a l` returns the value associated with key `a` in the list of pairs `l`.
assoc_inv [BatList.Labels.LExceptionless] |
assoc_inv [BatList.Exceptionless] | `assoc_inv b l` returns `Some a` where `a` is the key associated with value `b` in the list of pairs `l`.
assoc_inv [BatList] | `assoc_inv b l` returns the key associated with value `b` in the list of pairs `l`.
assq [BatList.Labels.LExceptionless] |
assq [BatList.Exceptionless] | As `BatList.Exceptionless.assoc` but with physical equality.
assq [BatList] | Same as `List.assoc`, but uses physical equality instead of structural equality to compare keys.
assq [BatLazyList.Labels.Exceptionless] |
assq [BatLazyList.Exceptionless] | As `BatLazyList.Exceptionless.assoc` but with physical equality
assq [BatLazyList] | As `BatLazyList.assoc` but with physical equality
assq_inv [BatList] | Same as `List.assoc_inv`, but uses physical equality instead of structural equality to compare keys.
at [BatVect.Make] | as `get`
at [BatVect] | as `get`
at [BatSeq.Exceptionless] |
at [BatSeq] | `at l n` returns the element at index `n` (starting from `0`) in the sequence `l` or raise `Invalid_argument` is the index is outside of `l` bounds.
at [BatList.Labels.LExceptionless] |
at [BatList.Exceptionless] | If `n` is inside the bounds of `l`, `at l n` returns `Ok x`, where `x` is the n-th element of the list `l`.
at [BatList] | `at l n` returns the n-th element of the list `l` or
at [BatLazyList.Labels.Exceptionless] |
at [BatLazyList.Exceptionless] | If `n` is inside the bounds of `l`, `at l n` returns ``Ok x`, where `x` is the n-th element of the list `l`.
at [BatLazyList] | `at l n` returns the element at index `n` (starting from `0`) in the list `l`.
at [BatDeque] | `at ~backwards dq k` returns the `k`th element of `dq`, from the front if `backwards` is false, and from the rear if `backwards` is true.
at_index [BatRefList.Index] | Return the element of ref list at the specified index raise `Invalid_index` if the index is outside `0 ; length-1`
atan [BatFloat.Safe_float] | See `BatFloat.Safe_float.atan2`.
atan [BatFloat] | See `BatFloat.atan2`.
atan2 [BatFloat.Safe_float] | The usual trigonometric functions.
atan2 [BatFloat] | The usual trigonometric functions.
avg [BatArray] | `avg l` returns the average of `l`
B
backtrace_status [BatPrintexc] | `Printexc.backtrace_status()` returns `true` if exception backtraces are currently recorded, `false` if not.
backwards [BatVect.RANDOMACCESS] |
backwards [BatVect.Make] | Returns an enumeration of the elements of a vector, from last to first.
backwards [BatVect] | Returns an enumeration of the elements of a vector, from last to first.
backwards [BatString.Cap] |
backwards [BatString] | Returns an enumeration of the characters of a string, from last to first.
backwards [BatSet.S] | Return an enumeration of all elements of the given set.
backwards [BatSet] | Return an enumeration of all elements of the given set.
backwards [BatRefList] | Returns an enumeration of current elements in the ref list, going from last to first
backwards [BatMap.PMap] | creates an enumeration for this map, enumerating key,value pairs with the keys in decreasing order.
backwards [BatMap.S] | Return an enumeration of (key, value) pairs of a map.
backwards [BatMap] | creates an enumeration for this map, enumerating key,value pairs with the keys in decreasing order.
backwards [BatList] | Returns an enumeration of the elements of a list.
backwards [BatFingerTree.S] | `backwards t` builds an enumeration of the elements of `t` going from right to left.
backwards [BatDllist] | `backwards t` is similar to `rev_enum t` except that the enumeration starts at the node before the current one:
backwards [BatArray.Cap] |
backwards [BatArray] | Returns an enumeration of the elements of an array, from last to first.
balance [BatVect.Make] | `balance r` returns a balanced copy of the `r` vect.
balance [BatVect] | `balance r` returns a balanced copy of the `r` vect.
balance [BatText] | `balance r` returns a balanced copy of the `r` rope.
base [BatSubstring] | `base sus` is the concrete triple `(s, i, n)`, where `psus = (s, i, n)`.
base_of_t [BatBounded.BoundedType] | `base_of_t x` converts a value of type `BatBounded.BoundedType.t` back to a `BatBounded.BoundedType.base_t` if possible.
base_of_t_exn [BatBounded.BoundedType] | `base_of_t_exn x` converts a value of type `BatBounded.BoundedType.t` back to a `BatBounded.BoundedType.base_t`.
before [BatISet] | `before x t` returns the portion of `t` in the range `min_int, x-1`
before [BatIMap] | Return the sub-map of bindings in the range `min_int, x-1`
beginning_of_input [BatScanf.Scanning] | `Scanning.beginning_of_input ib` tests the beginning of input condition of the given scanning buffer.
belongs [BatPathGen.PathType] | `belongs base sub` is `true` when `sub` descends from `base`, i.e.
big_endian [BatSys] | Whether the machine currently executing the OCaml program is big-endian.
big_int_base_default_symbols [BatBig_int] | Default vector of symbols used by `to_string_in_base` and its fixed-base derivatives `to_string_in_binary`, `to_string_in_octal` and `to_string_in_hexa` to represent digits.
big_int_of_int [BatBig_int] | Convert a small integer to a big integer.
big_int_of_int32 [BatBig_int] | Convert a 32-bit integer to a big integer.
big_int_of_int64 [BatBig_int] | Convert a 64-bit integer to a big integer.
big_int_of_nativeint [BatBig_int] | Convert a native integer to a big integer.
big_int_of_num [BatNum] |
big_int_of_string [BatBig_int] | Convert a string to a big integer, in decimal.
bin_comp [BatOrd] |
bin_eq [BatOrd] |
bin_ord [BatOrd] | binary lifting of the comparison function, using lexicographic order: `bin_ord ord1 v1 v1' ord2 v2 v2'` is `ord2 v2 v2'` if `ord1 v1 v1' = Eq`, and `ord1 v1 v1'` otherwhise.
bind [BatUnix] | Bind a socket to an address.
bind [BatResult.Monad] | Monadic composition.
bind [BatParserCo] | Monadic-style combination:
bind [BatOption.Monad] | `bind m f` combines the calculation result `m` with the function `f`.
bind [BatOption] | `bind (Some x) f` returns `f x` and `bind None f` returns `None`.
bind [BatInterfaces.Monad] | Monadic binding.
bind [BatEnum.Monad] | `bind m f` takes the result of the monadic computation m, puts the f function in the monadic context passing it the result of m and then returning a monadic result.
bindings [BatMap.PMap] | Return the list of all bindings of the given map.
bindings [BatMap.S] | Return the list of all bindings of the given map.
bindings [BatMap] | Return the list of all bindings of the given map.
bits [BatRandom.Incubator.Private_state_enums.State] |
bits [BatRandom.State] |
bits [BatRandom] | Return 30 random bits in a nonnegative integer.
bits_of [BatIO] | Read an enumeration of bits
bits_of_float [BatInt64] | Return the internal representation of the given float according to the IEEE 754 floating-point ``double format'' bit layout.
bits_of_float [BatInt32] | Return the internal representation of the given float according to the IEEE 754 floating-point ``single format'' bit layout.
blit [BatText] | `blit src srcoff dst dstoff len` returns a copy of `dst` in which `len` characters have been copied from rope `src`, starting at character number `srcoff`, to rope `dst`, starting at character number `dstoff`.
blit [BatString.Cap] |
blit [BatString] | `String.blit src srcoff dst dstoff len` copies `len` characters from string `src`, starting at character number `srcoff`, to string `dst`, starting at character number `dstoff`.
blit [BatDynArray] | `blit src srcidx dst dstidx len` copies `len` elements from `src` starting with index `srcidx` to `dst` starting at `dstidx`.
blit [BatBuffer] | `Buffer.blit src srcoff dst dstoff len` copies `len` characters from the current contents of the buffer `src`, starting at offset `srcoff` to string `dst`, starting at character `dstoff`.
blit [BatBigarray.Array3] | Copy the first big array to the second big array.
blit [BatBigarray.Array2] | Copy the first big array to the second big array.
blit [BatBigarray.Array1] | Copy the first big array to the second big array.
blit [BatBigarray.Genarray] | Copy all elements of a big array in another big array.
blit [BatArray.Cap.Labels] |
blit [BatArray.Cap] |
blit [BatArray.Labels] |
blit [BatArray] | `Array.blit v1 o1 v2 o2 len` copies `len` elements from array `v1`, starting at element number `o1`, to array `v2`, starting at element number `o2`.
bool [BatRandom.Incubator.Private_state_enums.State] |
bool [BatRandom.State] |
bool [BatRandom] | `Random.bool ()` returns `true` or `false` with probability 0.5 each.
bounded [BatBounded.BoundedType] | `bounded ~bounds x` returns a bounded `BatBounded.BoundedType.t` value derived from `x`.
bounding_of_ord [BatBounded] | `bounding_of_ord ~default_low ~default_high conv ord` will returning a bounding function using `ord` for value comparison and `default_low` and `default_high` for values which fall outside of the requested range.
bounding_of_ord_chain [BatBounded] | `bounding_oF_ord_chain ?low ?high ord` is like `BatBounded.bounding_of_ord` except that functions are used to handle out of range values rather than single default values.
bounds [BatBounded.BoundedType] | `bounds` defines the `(min, max)` bounds for the bounded range
bounds [BatBounded.S] | `bounds` defines the `(min, max)` bounds for the bounded range
bprintf [BatPrintf] | As `BatPrintf.fprintf`, but with buffers instead of outputs.
bprintf [BatFormat] | A deprecated and error prone function.
bprintf2 [BatPrintf] | As `BatPrintf.printf` but writes to a buffer instead of printing to the output.
break [BatEnum] | Negated span.
browse [BatteriesConfig] |
bscanf [BatScanf] | `bscanf ib fmt r1 ... rN f` reads arguments for the function `f`, from the scanning buffer `ib`, according to the format string `fmt`, and applies `f` to these values.
bscanf_format [BatScanf] | `bscanf_format ib fmt f` reads a format string token from the scannning buffer `ib`, according to the given format string `fmt`, and applies `f` to the resulting format string value.
bytes_of [BatIO] | Read an enumeration of unsigned 8-bit integers.
C
c_layout [BatBigarray] |
callback_option [BatOptParse.Opt] | Make a callback option which takes a single argument.
capacity [BatBitSet] | Internals
capitalize [BatString.Cap] |
capitalize [BatString] | Return a copy of the argument, with the first character set to uppercase.
cardinal [BatSet.PSet] | Return the number of elements of a set.
cardinal [BatSet.S] | Return the number of elements of a set.
cardinal [BatSet] | Return the number of elements of a set.
cardinal [BatMap.PMap] | Return the number of bindings of a map.
cardinal [BatMap.S] | Return the number of bindings of a map.
cardinal [BatMap] | Return the number of bindings of a map.
cardinal [BatISet] | Returns the number of elements in the set
cartesian_product [BatList] | Different from `List.combine`, this returns every pair of elements formed out of the two lists.
case_char [BatCharParser] | As `char`, but case-insensitive
case_sensitive [BatGenlex.Languages.Definition] | `true` if the language is case-sensitive, `false` otherwise.
case_string [BatCharParser] | As `case_string`, but case-insensitive
cast_output [BatInnerIO] | You can safely transform any output to an unit output in a safe way by using this function.
cast_output [BatIO] | You can safely transform any output to an unit output in a safe way by using this function.
catch [BatResult] | Execute a function and catch any exception as a result.
catch [BatPrintexc] | `Printexc.catch fn x` is similar to `Printexc.print`, but aborts the program with exit code 2 after printing the uncaught exception.
catch2 [BatResult] | As `catch` but two paramaters.
catch3 [BatResult] | As `catch` but three paramaters.
catch_break [BatSys] | `catch_break` governs whether interactive interrupt (ctrl-C) terminates the program or raises `Break`.
ceil [BatNum] |
ceil [BatFloat.Safe_float] | See `BatFloat.Safe_float.floor`.
ceil [BatFloat] | See `BatFloat.floor`.
ceiling_num [BatNum] |
channel [BatDigest] | If `len` is nonnegative, `Digest.channel ic len` reads `len` characters from channel `ic` and returns their digest, or
char [BatRandom.Incubator.Private_state_enums.State] |
char [BatRandom.State] |
char [BatRandom] | Return a random Latin-1 character.
char [BatGenlex.Languages.Make] | Low-level API
char [BatCharParser] | Recognize exactly one char
char [BatBigarray] | As shown by the types of the values above, big arrays of kind `float32_elt` and `float64_elt` are accessed using the OCaml type `float`.
char_dynarray [BatteriesPrint] |
char_enum [BatteriesPrint] |
char_literal [BatGenlex.Languages.Make] | Accepts a character literal, i.e.
char_of [BatUChar] | `char_of u` returns the Latin-1 representation of `u`.
char_pset [BatteriesPrint] |
chars_of [BatText] | offer the characters of an UTF-8 encoded input as an enumeration
chars_of [BatIO] | Read an enumeration of Latin-1 characters.
chdir [BatUnix] | Change the process working directory.
chdir [BatSys] | Change the current working directory of the process.
chmod [BatUnix] | Change the permissions of the named file.
chmod [BatFile] | As `BatFile.set_permissions`
choice [BatRandom] | `choice e` returns a randomly-chosen element of `e`.
choose [BatSet.PSet] | returns an arbitrary (but deterministic) element of the given set.
choose [BatSet.S.Exceptionless] |
choose [BatSet.S] | Return one element of the given set, or raise `Not_found` if the set is empty.
choose [BatSet] | returns an arbitrary (but deterministic) element of the given set.
choose [BatMap.PMap] | Return one binding of the given map, or raise `Not_found` if the map is empty.
choose [BatMap.S] | Return one binding of the given map, or raise `Not_found` if the map is empty.
choose [BatMap] | Return one binding of the given map, or raise `Not_found` if the map is empty.
choose [BatISet] | Returns some element in the set
chown [BatUnix] | Change the owner uid and owner gid of the named file.
chr [BatUChar] | `chr n` returns the Unicode character with the code number `n`.
chr [BatChar] | Return the character with the given ASCII code.
chroot [BatUnix] | Change the process root directory.
chunks_of [BatIO] | Read an input as an enumeration of strings of given length.
classify [BatFloat.Safe_float] | Return the class of the given floating-point number: normal, subnormal, zero, infinite, or not a number.
classify [BatFloat] | Return the class of the given floating-point number: normal, subnormal, zero, infinite, or not a number.
clear [BatUTF8.Buf] | Empty the buffer, but retains the internal storage which was holding the contents
clear [BatStack] | Discard all elements from a stack.
clear [BatRefList] | Removes all elements
clear [BatQueue] | Discard all elements from a queue.
clear [BatInnerWeaktbl] | Empty a hash table.
clear [BatHashtbl.Cap] |
clear [BatHashtbl.S] |
clear [BatHashtbl] | Empty a hash table.
clear [BatHashcons.Table] | `clear tab` removes all entries from the table `tab`.
clear [BatDynArray] | remove all elements from the array and resize it to 0.
clear [BatBuffer] | Empty the buffer.
clear_close_on_exec [BatUnix] | Clear the ``close-on-exec'' flag on the given descriptor.
clear_nonblock [BatUnix] | Clear the ``non-blocking'' flag on the given descriptor.
clone [BatEnum] | `clone e` creates a new enumeration that is copy of `e`.
close [BatUnix] | Close a file descriptor.
close_all [BatInnerIO] | Close all outputs.
close_box [BatFormat] | Closes the most recently opened pretty-printing box.
close_in [BatPervasives] | Close the given channel.
close_in [BatInnerIO] | Close the input.
close_in [BatIO] | Close the input.
close_in_noerr [BatPervasives] | Same as `close_in`, but ignore all errors.
close_out [BatPervasives] | Close the given channel, flushing all buffered write operations.
close_out [BatInnerIO] | Close the output and return its accumulator data.
close_out [BatIO] | Close the output and return its accumulator data.
close_out_noerr [BatPervasives] | Same as `close_out`, but ignore all errors.
close_process [BatUnix] | Close `input`/`output` opened by `Unix.open_process`, wait for the associated command to terminate, and return its termination status.
close_process_full [BatUnix] | Close i/o opened by `Unix.open_process_full`, wait for the associated command to terminate, and return its termination status.
close_process_in [BatUnix] | Close `input` opened by `Unix.open_process_in`, wait for the associated command to terminate, and return its termination status.
close_process_out [BatUnix] | Close `output` opened by `Unix.open_process_out`, wait for the associated command to terminate, and return its termination status.
close_tag [BatFormat] | `close_tag ()` closes the most recently opened tag `t`.
close_tbox [BatFormat] | Closes the most recently opened tabulation box.
closedir [BatUnix] | Close a directory descriptor.
clump [BatEnum] | `clump size add get e` runs `add` on `size` (or less at the end) elements of `e` and then runs `get` to produce value for the result enumeration.
code [BatUChar] | `code u` returns the Unicode code number of `u`.
code [BatChar] | Return the ASCII code of the argument.
comb [BatStream] | `comb` transform a pair of stream into a stream of pairs of corresponding elements.
combine [BatSeq.Exceptionless] |
combine [BatSeq] | Transform a pair of sequences into a sequence of pairs.
combine [BatList] | Transform a pair of lists into a list of pairs: `combine [a0; a1; ...; an] [b0; b1; ...; bn]` is `[(a0,b0); (a1,b1); ...; (an,bn)]`.
combine [BatLazyList] | Transform a pair of lists into a list of pairs: `combine [^ a0; a1; ... ^] [^ b0; b1; ... ^]` is `[^ (a0, b0); (a1, b1); ... ^]`.
combine [BatIO] | `combine (a,b)` creates a new `output` `c` such that writing to `c` will actually write to both `a` and `b`
combine [BatEnum] | `combine` transform a pair of stream into a stream of pairs of corresponding elements.
command [BatSys] | Execute the given shell command and return its exit code.
comment [BatGenlex.Languages.Make] |
comment_delimiters [BatGenlex.Languages.Definition] |
comp [BatTuple.Tuple5] |
comp [BatTuple.Tuple4] |
comp [BatTuple.Tuple3] |
comp [BatTuple.Tuple2] |
comp [BatOrd] | Returns an legacy comparison from a variant ordering
comp0 [BatOrd] |
comp_by [BatOrd.Incubator] |
compact [BatGc] | Perform a full major collection and compact the heap.
compact [BatDynArray] | `compact darr` ensures that the space allocated by the array is minimal.
compare [BatVect] |
compare [BatUnit] | Compare two units.
compare [BatUTF8] | Code point comparison by the lexicographic order.
compare [BatUChar] | `compare u1 u2` returns, a value > 0 if `u1` has a larger Unicode code number than `u2`, 0 if `u1` and `u2` are the same Unicode character, a value < 0 if `u1` has a smaller Unicode code number than `u2`.
compare [BatTuple.Tuple5] |
compare [BatTuple.Tuple4] |
compare [BatTuple.Tuple3] |
compare [BatTuple.Tuple2] |
compare [BatText] | The comparison function for ropes, with the same specification as `Pervasives.compare`.
compare [BatSubstring] | `compare sus1 sus2` performs lexicographic comparison, using the standard ordering Char.compare on the characters.p Equivalent to, but more efficient than, `String.compare (to_string sus1) (to_string sus2)`.
compare [BatString.Cap] |
compare [BatString] | The comparison function for strings, with the same specification as `Pervasives.compare`.
compare [BatStack] |
compare [BatSet.PSet] | Total ordering between sets.
compare [BatSet.S] | Total ordering between sets.
compare [BatSet] | Total ordering between sets.
compare [BatRef] | Given a comparison function, produce a comparison function for refs of that type.
compare [BatQueue] |
compare [BatPathGen.StringType] | Usual comparison function.
compare [BatOption] | Compare two options, possibly using custom comparators for the value.
compare [BatNumber.Numeric] |
compare [BatNum] |
compare [BatNativeint] | The comparison function for native integers, with the same specification as `Pervasives.compare`.
compare [BatMap.PMap] |
compare [BatMap.S.Labels] |
compare [BatMap.S] | Total ordering between maps.
compare [BatMap] |
compare [BatLog.Level_sig] |
compare [BatList] |
compare [BatInterfaces.OrderedType] | A total ordering function This is a two-argument function `f` such that `f e1 e2` is zero if the values `e1` and `e2` are equal, `f e1 e2` is strictly negative if `e1` is smaller than `e2`, and `f e1 e2` is strictly positive if `e1` is greater than `e2`.
compare [BatInt64] | The comparison function for 64-bit integers, with the same specification as `Pervasives.compare`.
compare [BatInt32] | The comparison function for 32-bit integers, with the same specification as `Pervasives.compare`.
compare [BatInt.Safe_int] | The comparison function for integers, with the same specification as `Pervasives.compare`.
compare [BatInt] | The comparison function for integers, with the same specification as `Pervasives.compare`.
compare [BatInnerIO.Output] | A total order on outputs
compare [BatInnerIO.Input] | A total order on inputs
compare [BatISet] | Compare two sets.
compare [BatHashcons] | Comparison on the tags
compare [BatFloat.Safe_float] |
compare [BatFloat] |
compare [BatFingerTree.S] | `compare cmp t1 t2` compares the two sequences lexicographically.
compare [BatEnum.Labels] |
compare [BatEnum] | `compare cmp a b` compares enumerations `a` and `b` by lexicographical order using comparison `cmp`.
compare [BatDigest] | The comparison function for 16-character digest, with the same specification as `Pervasives.compare` and the implementation shared with `String.compare`.
compare [BatComplex] |
compare [BatOrd.Comp] |
compare [BatChar] | The comparison function for characters, with the same specification as `Pervasives.compare`.
compare [BatBool] |
compare [BatBitSet] | `compare s1 s2` compares two bitsets using a lexicographic ordering.
compare [BatBig_int] |
compare [BatArray.Cap] |
compare [BatArray] | `compare c` generates the lexicographical order on arrays induced by `c`.
compare_big_int [BatBig_int] | `compare_big_int a b` returns `0` if `a` and `b` are equal, `1` if `a` is greater than `b`, and `-1` if `a` is smaller than `b`.
compare_index [BatUTF8] | `compare_index s i1 i2` returns a value < 0 if `i1` is the position located before `i2`, 0 if `i1` and `i2` points the same location, a value > 0 if `i1` is the position located after `i2`.
compare_num [BatNum] |
compare_subset [BatSet.S] | Partial ordering between sets as generated by `subset`
compl [BatISet] | Create the complement of the given set - i.e.
complex32 [BatBigarray] | See `Bigarray.char`.
complex64 [BatBigarray] | See `Bigarray.char`.
compose [BatConcurrent] | Compose two lock systems into a third lock system.
concat [BatVect.RANDOMACCESS] |
concat [BatVect.Make] | `concat r u` concatenates the `r` and `u` vects.
concat [BatVect] | `concat r u` concatenates the `r` and `u` vects.
concat [BatText] | `concat sep sl` concatenates the list of ropes `sl`, inserting the separator rope `sep` between each.
concat [BatSubstring] | `concat suss` returns a string consisting of the concatenation of the substrings.
concat [BatString.Cap] |
concat [BatString] | `String.concat sep sl` concatenates the list of strings `sl`, inserting the separator string `sep` between each.
concat [BatStream] | concatenate a stream of streams
concat [BatSeq] | `concat s` returns the sequence which returns all the elements of all the elements of `s`, in the same order.
concat [BatPervasives] | `concat e` returns an enumeration over all elements of all enumerations of `e`.
concat [BatPathGen.PathType] | 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 [BatArray] | Same as `Array.append`, but concatenates a list of arrays.
concat_with_separators [BatPathGen.StringType] | `concat_with_separators sep lst` catenates all n elements of `lst` inserting (n-1) copies of `sep` in between.
conj [BatComplex] | Conjugate: given the complex `x + i.y`, returns `x - i.y`.
connect [BatUnix] | Connect a socket to an address.
cons [BatStream] | `cons x stream` equals `[<'x; stream>]`.
cons [BatSeq] | `cons e s = fun () -> Cons(e, s)`
cons [BatParserCo] | `cons p q` applies parser `p` then parser `q` and conses the results into a list.
cons [BatList] | `cons h t` returns the list starting with `h` and continuing as `t`
cons [BatLazyList] | Build a list from a head and a tail.
cons [BatFingerTree.S] | `cons t elt` adds `elt` to the left of `t`.
cons [BatDeque] | `cons x dq` adds `x` to the front of `dq`.
conservative_exponential_resizer [BatDynArray] | `conservative_exponential_resizer` is an example resizer function which uses the oldlength parameter.
const [BatPervasives] | Ignore its second argument.
const [BatInnerPervasives] |
contains [BatText] | `contains s c` tests if character `c` appears in the rope `s`.
contains [BatSubstring] | `contains s c` tests if character `c` appears in the substring `s`.
contains [BatString.Cap] |
contains [BatString] | `String.contains s c` tests if character `c` appears in the string `s`.
contains_from [BatText] | `contains_from s start c` tests if character `c` appears in the subrope of `s` starting from `start` to the end of `s`.
contains_from [BatString.Cap] |
contains_from [BatString] | `String.contains_from s start c` tests if character `c` appears in `s` after position `start`.
contents [BatUTF8.Buf] | `contents buf` returns the contents of the buffer.
contents [BatBuffer] | Return a copy of the current contents of the buffer.
copy [BatVect.RANDOMACCESS] |
copy [BatString.Cap] |
copy [BatString] | Return a copy of the given string.
copy [BatStack] | Return a copy of the given stack.
copy [BatRefList] | Makes a copy of a ref list - O(1)
copy [BatRef] | `copy r` returns a new reference with the same initial content as `r`.
copy [BatRandom.Incubator.Private_state_enums.State] | Return a copy of the given state.
copy [BatRandom.State] | Return a copy of the given state.
copy [BatQueue] | Return a copy of the given queue.
copy [BatOo.Internal] |
copy [BatOo] | `Oo.copy o` returns a copy of object `o`, that is a fresh object with the same methods and instance variables as `o`
copy [BatInnerWeaktbl] | Return a copy of the given hashtable.
copy [BatIO] | Read everything from an input and copy it to an output.
copy [BatHashtbl.Cap] |
copy [BatHashtbl.S] |
copy [BatHashtbl] | Return a copy of the given hashtable.
copy [BatDynArray] | `copy src` returns a fresh copy of `src`, such that no modification of `src` affects the copy, or vice versa (all new memory is allocated for the copy).
copy [BatDllist] | Copy the list attached to the given node and return the copy of the given node.
copy [BatBitSet] | Copy a bitset : further modifications of first one will not affect the copy.
copy [BatArray.Cap] |
copy [BatArray] | `Array.copy a` returns a copy of `a`, that is, a fresh array containing the same elements as `a`.
copy_enum [BatRefList] | Makes a copy of a enum.
copy_list [BatRefList] | Makes a copy of a list - O(1)
copysign [BatFloat] | `copysign x y` returns a copy of `x` with the same sign as `y`.
cos [BatFloat.Safe_float] | 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 [BatStream] | Return the current count of the stream elements, i.e.
count [BatHashcons.Table] | `count tab` returns a count of how many live objects are in `tab`.
count [BatEnum] | `count e` returns the number of remaining elements in `e` without consuming the enumeration.
count [BatBitSet] | `count s` returns the number of bits set in the bitset `s`.
count_option [BatOptParse.StdOpt] | Create a counting option which increments its value each time the option is encountered on the command line.
counters [BatGc] | Return `(minor_words, promoted_words, major_words)`.
create [BatUTF8.Buf] | `create n` creates the buffer with the initial size `n`-bytes.
create [BatSubstring] |
create [BatString.Cap] |
create [BatString] | `String.create n` returns a fresh string of length `n`.
create [BatStack] | Return a new stack, initially empty.
create [BatSet.PSet] | Creates a new empty set, using the provided function for key comparison.
create [BatRMutex] | Return a new mutex.
create [BatQueue] | Return a new queue, initially empty.
create [BatMultiPMap] | creates a new empty map, using the provided function for key comparison.
create [BatMap.PMap] | creates a new empty map, using the provided function for key comparison.
create [BatInnerWeaktbl] | `Weaktbl.create n` creates a new, empty hash table, with initial size `n`.
create [BatHashtbl.Cap] |
create [BatHashtbl.S] |
create [BatHashtbl] | `Hashtbl.create n` creates a new, empty hash table, with initial size `n`.
create [BatHashcons.Table] | `create n` creates a table with at least `n` cells.
create [BatDynArray] | `create()` returns a new empty dynamic array.
create [BatDllist] | Creates a node.
create [BatConcurrent.BaseLock] |
create [BatConcurrent.Lock] |
create [BatConcurrent] | Create a lock from a pair of locking/unlocking functions
create [BatBuffer] | `create n` returns a fresh buffer, initially empty.
create [BatBitSet] | Create an empty bitset with at least an initial capacity (in number of bits).
create [BatBigarray.Array3] | `Array3.create kind layout dim1 dim2 dim3` returns a new bigarray of three dimension, whose size is `dim1` in the first dimension, `dim2` in the second dimension, and `dim3` in the third.
create [BatBigarray.Array2] | `Array2.create kind layout dim1 dim2` returns a new bigarray of two dimension, whose size is `dim1` in the first dimension and `dim2` in the second dimension.
create [BatBigarray.Array1] | `Array1.create kind layout dim` returns a new bigarray of one dimension, whose size is `dim`.
create [BatBigarray.Genarray] | `Genarray.create kind layout dimensions` returns a new big array whose element kind is determined by the parameter `kind` (one of `float32`, `float64`, `int8_signed`, etc) and whose layout is determined by the parameter `layout` (one of `c_layout` or `fortran_layout`).
create [BatAvlTree] | `create l v r` is similar to `make_tree l v r` but performs no rebalancing; in other words, you should use this only when you know that `l` and `r` are already balanced.
create [BatArray.Cap.Labels] |
create [BatArray.Cap] |
create [BatArray.Labels] |
create [BatArray] |
create_alarm [BatGc] | `create_alarm f` will arrange for `f` to be called at the end of each major GC cycle, starting with the current cycle or the next one.
create_full [BatBitSet] | Create a full bitset with at least initial capacity (in number of bits).
create_in [BatInnerIO] | Fully create an input by giving all the needed functions.
create_in [BatIO] | Fully create an input by giving all the needed functions.
create_matrix [BatArray.Cap.Labels] |
create_matrix [BatArray.Cap] |
create_matrix [BatArray.Labels] |
create_matrix [BatArray] |
create_object [BatOo.Internal] |
create_object_and_run_initializers [BatOo.Internal] |
create_object_opt [BatOo.Internal] |
create_out [BatInnerIO] | Fully create an output by giving all the needed functions.
create_out [BatIO] | Fully create an output by giving all the needed functions.
create_process [BatUnix] | `create_process prog args new_stdin new_stdout new_stderr` forks a new process that executes the program in file `prog`, with arguments `args`.
create_process_env [BatUnix] | `create_process_env prog args env new_stdin new_stdout new_stderr` works as `Unix.create_process`, except that the extra argument `env` specifies the environment passed to the program.
create_table [BatOo.Internal] |
current_browse [BatteriesConfig] |
curry [BatTuple.Tuple5] |
curry [BatTuple.Tuple4] |
curry [BatTuple.Tuple3] |
curry [BatTuple.Tuple2] |
curry [BatPervasives] | Convert a function which accepts a pair of arguments into a function which accepts two arguments.
curry [BatInnerPervasives] |
cycle [BatEnum] | `cycle` is similar to `repeat`, except that the content to fill is a subenum rather than a single element.
D
data_size [BatMarshal] | See `Marshal.header_size`.
dbg_formatter [BatLogger] | `dbg_formatter` is a debug formatter that outputs log events to stderr using the same format as `make_dbg_formatter`.
debug_mode [BatParserCo] | If set to `true`, debugging information will be printed to the standard error.
decode [BatBase64] | Generic base64 decoding over an input.
decorate_fast_sort [BatArray] | As `Array.decorate_stable_sort`, but uses fast_sort internally.
decorate_stable_sort [BatArray] | `decorate_stable_sort f a` returns a sorted copy of `a` such that if `f x < f y` then `x` is earlier in the result than `y`.
decr_num [BatNum] |
decr_option [BatOptParse.StdOpt] | Exactly identical to `count_option ~dest:dest ~increment:(-1) ()`.
default [BatResult] | `default d r` evaluates to `d` if `r` is `Bad` else `x` when `r` is `Ok x`
default [BatOption] | `default x (Some v)` returns `v` and `default x None` returns `x`.
default_browse [BatteriesConfig] | The default function to open a www browser.
default_buffer_size [BatInnerIO] | The default size of buffers.
default_buffer_size [BatIO] | The default size for internal buffers.
default_delayed [BatOption] | Like `BatOption.default`, but the default value is passed as a thunk that is only computed if needed.
default_level [BatLog.Level_sig] | a comparison function between levels, to know whether logging at a particular level should be printed
default_permission [BatFile] | Default permissions.
default_resizer [BatDynArray] | The default resizer function the library is using - in this version of DynArray, this is the `exponential_resizer` but should change in next versions.
default_validator [BatPathGen.PathType] | Forward slash and code zero are considered invalid.
del_min [BatHeap.H] | 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_alarm [BatGc] | `delete_alarm a` will stop the calls to the function associated to `a`.
delete_last [BatDynArray] | `delete_last darr` deletes the last element of `darr`.
delete_range [BatDynArray] | `delete_range darr p len` deletes `len` elements starting at index `p`.
demote [BatDllist] | `demote n` Swaps `n` with `prev n`.
descr_of_in_channel [BatUnix] | Return the descriptor corresponding to an input channel.
descr_of_input [BatUnix] | Return the descriptor corresponding to an input.
descr_of_out_channel [BatUnix] | Return the descriptor corresponding to an output channel.
descr_of_output [BatUnix] | Return the descriptor corresponding to an output.
destructive_set [BatVect.Make] | `destructive_set n e v` sets the element of index `n` in the `v` vect to `e`.
destructive_set [BatVect] | `destructive_set n e v` sets the element of index `n` in the `v` vect to `e`.
diff [BatSet.PSet] | `diff s t` returns the set of all elements in `s` but not in `t`.
diff [BatSet.S] | Set difference.
diff [BatSet] | `diff s t` returns the set of all elements in `s` but not in `t`.
diff [BatMap.PMap] | `diff m1 m2` removes all bindings of keys found in `m2` from `m1`, using the comparison function of `m1`.
diff [BatMap] | `diff m1 m2` removes all bindings of keys found in `m2` from `m1`, using the comparison function of `m1`.
diff [BatISet] | Compute the difference between two sets.
diff [BatBitSet] | `diff s t` returns `s`-`t`.
differentiate [BatBitSet] | `differentiate s t` removes the elements of `t` from `s`.
differentiate_sym [BatBitSet] | `differentiate_sym s t` sets `s` to the symmetrical difference of the sets `s` and `t`.
digit [BatCharParser] | Recognizes one decimal digit
dim [BatBigarray.Array1] | Return the size (dimension) of the given one-dimensional big array.
dim1 [BatBigarray.Array3] | Return the first dimension of the given three-dimensional big array.
dim1 [BatBigarray.Array2] | Return the first dimension of the given two-dimensional big array.
dim2 [BatBigarray.Array3] | Return the second dimension of the given three-dimensional big array.
dim2 [BatBigarray.Array2] | Return the second dimension of the given two-dimensional big array.
dim3 [BatBigarray.Array3] | Return the third dimension of the given three-dimensional big array.
dims [BatBigarray.Genarray] | `Genarray.dims a` returns all dimensions of the big array `a`, as an array of integers of length `Genarray.num_dims a`.
disjoint [BatSet.PSet] | `disjoint s1 s2` tests whether the sets `s1` and `s2` contain no shared elements.
disjoint [BatSet.S] | `disjoint s1 s2` tests whether the sets `s1` and `s2` contain no shared elements.
disjoint [BatSet] | `disjoint s1 s2` tests whether the sets `s1` and `s2` contain no shared elements.
div [BatNumber.Numeric] |
div [BatNum] |
div [BatNativeint] | Integer division.
div [BatInt64] | Integer division.
div [BatInt32] | Integer division.
div [BatInt.Safe_int] | Integer division.
div [BatInt] | Integer division.
div [BatFloat.Safe_float] |
div [BatFloat] |
div [BatComplex] | Division
div [BatBool] |
div [BatBig_int] |
div_big_int [BatBig_int] | Euclidean quotient of two big integers.
div_num [BatNum] |
documentation_root [BatteriesConfig] |
domain [BatIMap] | `domain t` returns the set of ints that are bound in `t`
domain_of_sockaddr [BatUnix] | Return the socket domain adequate for the given socket address.
doubles_of [BatIO.BigEndian] | Read an enumeration of IEEE double precision floating point values.
doubles_of [BatIO] | Read an enumeration of IEEE double precision floating point values.
drive_letter [BatPathGen.PathType] | Return drive letter of the given absolute path.
drop [BatStream] | `drop n stream` returns the suffix of `stream` after the first `n` elements, or a empty stream if `n` is greater than the length of `stream`
drop [BatSeq] | `drop n s` returns `s` without the first `n` elements, or the empty sequence if `s` have less than `n` elements.
drop [BatList] | `drop n l` returns `l` without the first `n` elements, or the empty list if `l` have less than `n` elements.
drop [BatLazyList] | `drop n l` returns `l` without the first `n` elements, or the empty list if `l` have less than `n` elements.
drop [BatEnum] | `drop n e` removes the first `n` element from the enumeration, if any.
drop [BatDllist] | Remove node from the list no matter where it is.
drop_bits [BatIO] | Drop up to 7 buffered bits and restart to next input character.
drop_while [BatStream.StreamLabels] |
drop_while [BatStream] | `drop_while test stream` returns the remaining suffix of `take_while test stream`.
drop_while [BatSeq] | `drop_while f s` returns the sequence `s` with the first elements satisfying the predicate `f` dropped.
drop_while [BatList.Labels] |
drop_while [BatList] | `drop_while p xs` returns the suffix remaining after `take_while p xs`.
drop_while [BatLazyList.Labels] |
drop_while [BatLazyList] | `drop_while f xs` returns the list `xs` with the first elements satisfying the predicate `f` dropped.
drop_while [BatEnum.Labels] |
drop_while [BatEnum] | `drop_while p e` produces a new enumeration in which only all the first elements such that `f e` have been junked.
dropl [BatSubstring] | `dropl p sus` drops the longest prefix (left substring) of `sus` all of whose characters satisfy predicate `p`.
dropr [BatSubstring] | `dropr p sus` drops the longest suffix (right substring) of sus all of whose characters satisfy predicate `p`.
dropwhile [BatList] | obsolete, as `BatList.drop_while`
dummy_class [BatOo.Internal] |
dummy_pos [BatLexing] | A value of type `position`, guaranteed to be different from any valid position.
dummy_table [BatOo.Internal] |
dump [BatPervasives] | Attempt to convert a value to a string.
dup [BatUnix] | Return a new file descriptor referencing the same file as the given descriptor.
dup [BatStream] | `dup stream` returns a pair of streams which are identical to `stream`.
dup [BatEnum] | `dup stream` returns a pair of streams which are identical to `stream`.
dup2 [BatUnix] | `dup2 fd1 fd2` duplicates `fd1` to `fd2`, closing `fd2` if already opened.
E
e [BatFloat] | Euler? ...
eager_append [BatLazyList] | Evaluate a list and append another list after this one.
eager_of_list [BatLazyList] | Eager conversion from lists.
either [BatParserCo] | Accept one of several parsers.
elements [BatSet.PSet] | Return the list of all elements of the given set.
elements [BatSet.S] | Return the list of all elements of the given set.
elements [BatSet] | Return the list of all elements of the given set.
elements [BatISet] | Returns a list of all elements in the set
elems [BatHeap.H] |
elems [BatHeap] |
empty [BatVect.RANDOMACCESS] |
empty [BatVect.Make] | The empty vect.
empty [BatVect] | The empty vect.
empty [BatText] | The empty rope.
empty [BatSubstring] |
empty [BatStream] | Return `()` if the stream is empty, else raise `Stream.Failure`.
empty [BatSet.PSet] | The empty set, using `compare` as comparison function
empty [BatSet.S] | The empty set.
empty [BatSet] | The empty set, using `compare` as comparison function
empty [BatRefList] | Returns a new empty ref list
empty [BatMultiPMap] | The empty map, using `compare` as key comparison function.
empty [BatMultiMap] | The empty map, using `compare` as key comparison function.
empty [BatMap.PMap] | The empty map, using `compare` as key comparison function.
empty [BatMap.S] | The empty map.
empty [BatMap] | The empty map, using `compare` as key comparison function.
empty [BatISet] | The empty set
empty [BatIMap] | The empty map.
empty [BatHeap.H] | See `BatHeap.empty`.
empty [BatHeap] | The empty heap.
empty [BatGlobal] | Returns an new named empty global.
empty [BatFingerTree.S] | `empty` is the sequence with no elements.
empty [BatEnum] | The empty enumeration : contains no element
empty [BatDynArray] | Return true if the number of elements in the array is 0.
empty [BatDeque] | The empty deque.
empty [BatBitSet] | Create an empty bitset of capacity 0, the bitset will automatically expand when needed.
empty [BatAvlTree] |
encode [BatBase64] | Generic base64 encoding over an output.
end_of_input [BatScanf.Scanning] | `Scanning.end_of_input ib` tests the end-of-input condition of the given scanning buffer.
ends_with [BatText] | `ends_with s x` returns `true` if the rope `s` is ending with `x`, `false` otherwise.
ends_with [BatString.Cap] |
ends_with [BatString] | `ends_with s x` returns `true` if the string `s` is ending with `x`, `false` otherwise.
enum [BatVect.RANDOMACCESS] |
enum [BatVect.Make] | Returns an enumeration of the elements of the vector.
enum [BatVect] | Returns an enumeration of the elements of the vector.
enum [BatTuple.Tuple5] |
enum [BatTuple.Tuple4] |
enum [BatTuple.Tuple3] |
enum [BatTuple.Tuple2] |
enum [BatSubstring] | `enum ss` returns an enumeration of the characters represented by ss.
enum [BatString.Cap] | Conversions
enum [BatString] | Returns an enumeration of the characters of a string.
enum [BatStream] | Convert a stream to an enumeration.
enum [BatStack] | `enum s` returns an enumeration of the elements of stack `s`, from the most recently entered to the least recently entered.
enum [BatSet.PSet] | Return an enumeration of all elements of the given set.
enum [BatSet.S] | Return an enumeration of all elements of the given set.
enum [BatSet] | Return an enumeration of all elements of the given set.
enum [BatSeq] | `enum s` returns the enumeration of all element of `s`.
enum [BatRefList] | Returns an enumeration of current elements in the ref list
enum [BatQueue] | `enum q` returns a destructive enumeration of the elements of queue `q`, from the least recently entered to the most recently entered.
enum [BatOption] | `enum (Some x)` returns the singleton `x`, while `enum None` returns the empty enumeration.
enum [BatMultiPMap] | creates an enumeration for this map.
enum [BatMultiMap] | creates an enumeration for this map.
enum [BatMap.PMap] | creates an enumeration for this map, enumerating key,value pairs with the keys in increasing order.
enum [BatMap.S] | Return an enumeration of (key, value) pairs of a map.
enum [BatMap] | creates an enumeration for this map, enumerating key,value pairs with the keys in increasing order.
enum [BatList] | Returns an enumeration of the elements of a list.
enum [BatLazyList] | Lazy conversion to enumeration
enum [BatISet] | Enumerates all contiguous ranges in the set
enum [BatIMap] | `enum t` returns an enumeration of the bindings in `t`
enum [BatHeap.H] | 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 [BatFingerTree.S] | `enum t` builds an enumeration of the elements of `t` going from left to right.
enum [BatEnum.Enumerable] | Return an enumeration of the elements of the data structure
enum [BatEnum] | identity : added for consistency with the other data structures
enum [BatDynArray] | `enum darr` returns the enumeration of `darr` elements.
enum [BatDllist] | Create an enum of the list.
enum [BatDeque] | `enum dq` is an enumeration of the elements of `dq` from the front to the rear.
enum [BatChar] | Produce the enumeration of all characters
enum [BatBuffer] | Returns an enumeration of the characters of a buffer.
enum [BatBitSet] | `enum s` returns an enumeration of bits which are set in the bitset `s`.
enum [BatBigarray.Array3] | `enum e` returns an enumeration on the elements of `e`.
enum [BatBigarray.Array2] | `enum e` returns an enumeration on the elements of `e`.
enum [BatBigarray.Array1] | `Array1.enum e` returns an enumeration on the elements of `e`.
enum [BatBigarray.Genarray] | `enum e` returns an enumeration on the elements of `e`.
enum [BatAvlTree] |
enum [BatArray.Cap] |
enum [BatArray] | Returns an enumeration of the elements of an array.
enum_bits [BatRandom.Incubator.Private_state_enums.State] | A copy of the input state is made to start these generators; the input state is not modified.
enum_bits [BatRandom.Incubator.Private_state_enums] | These enumerations are built on a copy of the global RNG state.
enum_bits [BatRandom.State] |
enum_bits [BatRandom] |
enum_bool [BatRandom.Incubator.Private_state_enums.State] |
enum_bool [BatRandom.Incubator.Private_state_enums] |
enum_bool [BatRandom.State] |
enum_bool [BatRandom] |
enum_char [BatRandom.Incubator.Private_state_enums.State] |
enum_char [BatRandom.Incubator.Private_state_enums] |
enum_char [BatRandom.State] |
enum_char [BatRandom] |
enum_destruct [BatStack] | `enum s` returns a destructive enumeration of the elements of stack `s`, from the most recently entered to the least recently entered.
enum_float [BatRandom.Incubator.Private_state_enums.State] |
enum_float [BatRandom.Incubator.Private_state_enums] |
enum_float [BatRandom.State] |
enum_float [BatRandom] |
enum_int [BatRandom.Incubator.Private_state_enums.State] |
enum_int [BatRandom.Incubator.Private_state_enums] |
enum_int [BatRandom.State] |
enum_int [BatRandom] |
enum_int32 [BatRandom.Incubator.Private_state_enums.State] |
enum_int32 [BatRandom.Incubator.Private_state_enums] |
enum_int32 [BatRandom.State] |
enum_int32 [BatRandom] |
enum_int64 [BatRandom.Incubator.Private_state_enums.State] |
enum_int64 [BatRandom.Incubator.Private_state_enums] |
enum_int64 [BatRandom.State] |
enum_int64 [BatRandom] |
enum_nativeint [BatRandom.Incubator.Private_state_enums.State] |
enum_nativeint [BatRandom.Incubator.Private_state_enums] |
enum_nativeint [BatRandom.State] |
enum_nativeint [BatRandom] |
enum_print [BatteriesPrint] |
enum_print_limit [BatteriesPrint] |
environment [BatUnix] | Return the process environment, as an array of strings with the format ``variable=value''.
eof [BatParserCo] | Accept the end of an enumeration.
eprintf [BatPrintf] | The usual `eprintf` function, prints to the standard error output `stderr`, used to display warnings and errors.
eprintf [BatFormat] | Same as `fprintf` above, but output on `err_formatter`.
epsilon [BatFloat.Safe_float] | The smallest positive float `x` such that `1.0 +. x <> 1.0`.
epsilon [BatFloat] | The smallest positive float `x` such that `1.0 +. x <> 1.0`.
eq [BatUChar] | Equality by code point comparison
eq [BatTuple.Tuple5] |
eq [BatTuple.Tuple4] |
eq [BatTuple.Tuple3] |
eq [BatTuple.Tuple2] |
eq [BatRef] |
eq [BatOrd] | Derives an equality function from an ordering function.
eq [BatOption] | Test for equality between option types, possibly using a custom equality predicate.
eq [BatList] |
eq [BatOrd.Eq] |
eq [BatArray.Incubator.Eq] |
eq_big_int [BatBig_int] |
eq_by [BatOrd.Incubator] |
eq_comp [BatOrd] |
eq_comp0 [BatOrd] |
eq_num [BatNum] |
eq_ord [BatOrd] |
eq_ord0 [BatOrd] |
equal [BatVect] |
equal [BatUref] | `equal ur1 ur2` returns `true` iff `ur1` and `ur2` are equal urefs, either because they are physically the same or because they have been `BatUref.unite`d.
equal [BatUnit] | Always returns true.
equal [BatSubstring] | Substring equality
equal [BatString] | String equality
equal [BatStack] |
equal [BatSet.PSet] | `equal s1 s2` tests whether the sets `s1` and `s2` are equal, that is, contain equal elements.
equal [BatSet.S] | `equal s1 s2` tests whether the sets `s1` and `s2` are equal, that is, contain equal elements.
equal [BatSet] | `equal s1 s2` tests whether the sets `s1` and `s2` are equal, that is, contain equal elements.
equal [BatQueue] |
equal [BatNumber.Numeric] |
equal [BatNum] |
equal [BatNativeint] | Equality function for 64-bit integers, useful for `HashedType`.
equal [BatMap.PMap] | Construct a comparison or equality function for maps based on a value comparison or equality function.
equal [BatMap.S.Labels] |
equal [BatMap.S] | `equal cmp m1 m2` tests whether the maps `m1` and `m2` are equal, that is, contain equal keys and associate them with equal data.
equal [BatMap] | Construct a comparison or equality function for maps based on a value comparison or equality function.
equal [BatInt64] | Equality function for 64-bit integers, useful for `HashedType`.
equal [BatInt32] | Equality function for 32-bit integers, useful for `HashedType`.
equal [BatInt.Safe_int] | Equality function for integers, useful for `HashedType`.
equal [BatInt] | Equality function for integers, useful for `HashedType`.
equal [BatInnerIO.Output] |
equal [BatInnerIO.Input] |
equal [BatISet] | Test whether two sets are equal.
equal [BatHashtbl.HashedType] | The equality predicate used to compare keys.
equal [BatFloat] |
equal [BatFingerTree.S] | `equal eq t1 t2` returns `true` when the two sequences contain the the same elements.
equal [BatEnum] | `equal eq a b` returns `true` when `a` and `b` contain the same sequence of elements.
equal [BatComplex] |
equal [BatChar] |
equal [BatBool] |
equal [BatBitSet] | `equal s1 s2` returns true if, and only if, all bits values in s1 are the same as in s2.
equal [BatBig_int] |
equal [BatArray.Cap] |
equal [BatArray] | Hoist a equality test for elements to arrays.
err_formatter [BatFormat] | A formatter to use with formatting functions below for output to standard error.
error [BatOptParse.OptParser] | Display an error message and exit the program.
error_message [BatUnix] | Return a string describing the given error code.
escaped [BatString.Cap] |
escaped [BatString] | Return a copy of the argument, with special characters represented by escape sequences, following the lexical conventions of OCaml.
escaped [BatChar] | Return a string representing the given character, with special characters escaped following the lexical conventions of OCaml.
establish_server [BatUnix] | Establish a server on the given address.
eternity [BatLazyList] | An infinite list of nothing
exactly [BatParserCo] | Accept exactly one singleton.
exe [BatPervasives] | The name of the current executable.
executable_name [BatSys] | The name of the file containing the executable currently running.
execv [BatUnix] | `execv prog args` execute the program in file `prog`, with the arguments `args`, and the current process environment.
execve [BatUnix] | Same as `Unix.execv`, except that the third argument provides the environment to the program executed.
execvp [BatUnix] | Same as `Unix.execv`, except that the program is searched in the path.
execvpe [BatUnix] | Same as `Unix.execve`, except that the program is searched in the path.
exists [BatVect.Make] | `exists p [a0; a1; ...; an]` checks if at least one element of the vect satisfies the predicate `p`.
exists [BatVect] | `exists p [a0; a1; ...; an]` checks if at least one element of the vect satisfies the predicate `p`.
exists [BatText] | `exists str sub` returns true if `sub` is a subrope of `str` or false otherwise.
exists [BatString.Cap] |
exists [BatString] | `exists str sub` returns true if `sub` is a substring of `str` or false otherwise.
exists [BatSet.PSet] | `exists p s` checks if at least one element of the set satisfies the predicate `p`.
exists [BatSet.S.Labels] |
exists [BatSet.S] | `exists p s` checks if at least one element of the set satisfies the predicate `p`.
exists [BatSet] | `exists p s` checks if at least one element of the set satisfies the predicate `p`.
exists [BatSeq] | `exists p (cons a0 (cons a1 ...))` checks if at least one element of the sequence satisfies the predicate `p`.
exists [BatRefList] | Return `true` if an element matches the specified predicate
exists [BatPervasives] | `exists f e` returns `true` if there is some `x` in `e` such that `f x`
exists [BatMap.PMap] | Tests whether some key value pair satisfies some predicate function
exists [BatMap.S] | `exists p m` checks if at least one binding of the map satisfy the predicate `p`.
exists [BatMap] | Tests whether some key value pair satisfies some predicate function
exists [BatList.Labels] |
exists [BatList] | `exists p [a1; ...; an]` checks if at least one element of the list satisfies the predicate `p`.
exists [BatLazyList.Labels] |
exists [BatLazyList] | Eager existential.
exists [BatISet] | Test whether some element of a set satisfies a predicate
exists [BatEnum.Labels] |
exists [BatEnum] | `exists f e` returns `true` if there is some `x` in `e` such that `f x`
exists [BatDllist] | Test whether there exists an element of the given list for which the predicate returns true.
exists [BatArray.Cap.Labels] |
exists [BatArray.Cap] |
exists [BatArray.Labels] |
exists [BatArray] | `exists p [|a0; a1; ...; an|]` checks if at least one element of the array satisfies the predicate `p`.
exists2 [BatList.Labels] |
exists2 [BatList] | Same as `List.exists`, but for a two-argument predicate.
exists2 [BatLazyList.Labels] |
exists2 [BatLazyList] | Same as `BatLazyList.exists`, but for a two-argument predicate.
exists2 [BatArray] | As `Array.exists` but on two arrays.
exp [BatFloat.Safe_float] | Exponential.
exp [BatFloat] | Exponential.
exp [BatComplex] | Exponentiation.
explode [BatText] | `explode s` returns the list of characters in the rope `s`.
explode [BatSubstring] | `explode sus` returns the list of characters of sus, that is, `s(i), s(i+1), ..., s(i+n-1)` where `sus = (s, i, n)`.
explode [BatString.Cap] |
explode [BatString] | `explode s` returns the list of characters in the string `s`.
exponential_resizer [BatDynArray] | The exponential resizer- The default resizer except when the resizer is being copied from some other darray.
ext [BatPathGen.PathType] | Returns extension of the name of the object the pathname points to.
extract [BatSubstring] | `extract s i None` creates the substring (s, i, size s-i) consisting of the tail of s starting at i.
extract [BatMap.PMap] | `extract k m` removes the current binding of `k` from `m`, returning the value `k` was bound to and the updated `m`.
extract [BatMap.S] | `extract k m` removes the current binding of `k` from `m`, returning the value `k` was bound to and the updated `m`.
extract [BatMap] | `extract k m` removes the current binding of `k` from `m`, returning the value `k` was bound to and the updated `m`.
extract [BatBounded.S] | `extract x` will return `x` as a value of type `BatBounded.S.u`.
extract_big_int [BatBig_int] | `extract_big_int bi ofs n` returns a nonnegative number corresponding to bits `ofs` to `ofs + n - 1` of the binary representation of `bi`.
F
fail [BatParserCo] | Always fail, without consuming anything.
fast_count [BatEnum] | For users worried about the speed of `count` you can call the `fast_count` function that will give an hint about `count` implementation.
fast_sort [BatList.Labels] |
fast_sort [BatList] | Same as `List.sort` or `List.stable_sort`, whichever is faster on typical input.
fast_sort [BatArray.Cap.Labels] |
fast_sort [BatArray.Cap] |
fast_sort [BatArray.Labels] |
fast_sort [BatArray] | Same as `Array.sort` or `Array.stable_sort`, whichever is faster on typical input.
fatal [BatParserCo] |
fatal [BatLog.Make] | `fatal s` logs the message `s` and then calls `exit 1`.
fatal [BatLog] | `fatal s` logs the message `s` and then calls `exit 1`.
fatalf [BatLog.Make] | `fatalf` allows a format string (as `Printf.printf`)and the arguments to that format string to build the logging message.
fatalf [BatLog] | `fatalf` allows a format string (as `Printf.printf`)and the arguments to that format string to build the logging message.
favg [BatArray] | `favg l` returns the average of `l`
fchmod [BatUnix] | Change the permissions of an opened file.
fchown [BatUnix] | Change the owner uid and owner gid of an opened file.
feed [BatGenlex.Languages.Make] | Drop comments, present reserved operators and reserved names as `Kwd`, operators and identifiers as `Ident`, integer numbers as `Int`, floating-point numbers as `Float` and characters as `Char`.
fields [BatSubstring] | `fields p sus` returns the list of fields in `sus`, from left to right, where a field is a (possibly empty) maximal substring of `sus` not containing any delimiter, and a delimiter is a character satisfying `p`.
fifth [BatTuple.Tuple5] |
file [BatDigest] | Return the digest of the file whose name is given.
file_exists [BatSys] | Test if a file with the given name exists.
files_of [BatSys] | As `BatSys.readdir` but the results are presented as an enumeration of names.
fill [BatText] | `fill s start len c` returns the rope in which characters number `start` to `start + len - 1` of `s` has been replaced by `c`.
fill [BatString.Cap] |
fill [BatString] | `String.fill s start len c` modifies string `s` in place, replacing `len` characters by `c`, starting at `start`.
fill [BatOptParse.Formatter] | See `OptParse.Formatter.wrap`.
fill [BatBigarray.Array3] | Fill the given big array with the given value.
fill [BatBigarray.Array2] | Fill the given big array with the given value.
fill [BatBigarray.Array1] | Fill the given big array with the given value.
fill [BatBigarray.Genarray] | Set all elements of a big array to a given value.
fill [BatArray.Cap.Labels] |
fill [BatArray.Cap] |
fill [BatArray.Labels] |
fill [BatArray] | `Array.fill a ofs len x` modifies the array `a` in place, storing `x` in elements number `ofs` to `ofs + len - 1`.
filter [BatVect.Make] | `filter f v` returns a vect with the elements `x` from `v` such that `f x` returns `true`.
filter [BatVect] | `filter f v` returns a vect with the elements `x` from `v` such that `f x` returns `true`.
filter [BatText] | `filter f s` returns a copy of rope `s` in which only characters `c` such that `f c = true` remain.
filter [BatString.Cap] |
filter [BatString] | `filter f s` returns a copy of string `s` in which only characters `c` such that `f c = true` remain.
filter [BatStream.StreamLabels] |
filter [BatStream] | `filter test stream` picks all the elements satisfying `test` from `stream` and return the results in the same order as a stream.
filter [BatSet.PSet] | `filter p s` returns the set of all elements in `s` that satisfy predicate `p`.
filter [BatSet.S.Labels] |
filter [BatSet.S] | `filter p s` returns the set of all elements in `s` that satisfy predicate `p`.
filter [BatSet] | `filter p s` returns the set of all elements in `s` that satisfy predicate `p`.
filter [BatSeq] | `filter p s` returns the sequence of elements of `s` satisfying `p`.
filter [BatRefList] | Remove all elements that do not match the specified predicate
filter [BatPervasives] | `filter f e` returns an enumeration over all elements `x` of `e` such as `f x` returns `true`.
filter [BatParserCo] | `filter f p` is only accepts values `x` such that `p` accepts `x` and `f (p x)` is `true`
filter [BatOption] | `filter f None` returns `None`, `filter f (Some x)` returns `Some x` if `f x` is true, and `None` otherwise.
filter [BatMap.PMap] | `filter f m` returns a map where only the (key, value) pairs `key`, `a` of `m` such that `f key a = true` remain.
filter [BatMap.S.Labels] |
filter [BatMap.S] | `filter f m` returns a map where only the key, values pairs `key`, `a` of `m` such that `f key a = true` remain.
filter [BatMap] | `filter f m` returns a map where only the (key, value) pairs `key`, `a` of `m` such that `f key a = true` remain.
filter [BatList.Labels] |
filter [BatList] | `filter p l` returns all the elements of the list `l` that satisfy the predicate `p`.
filter [BatLazyList.Labels] |
filter [BatLazyList] | Lazy filtering.
filter [BatISet] | Builds the subset of those elements that satisfy the predicate
filter [BatHashtbl.Cap.Labels] |
filter [BatHashtbl.Cap] |
filter [BatHashtbl.S.Labels] |
filter [BatHashtbl.S] |
filter [BatHashtbl.Labels] |
filter [BatHashtbl] | `filter f m` returns a new hashtable where only the values `a` of `m` such that `f a = true` remain.
filter [BatEnum.Labels] |
filter [BatEnum] | `filter f e` returns an enumeration over all elements `x` of `e` such as `f x` returns `true`.
filter [BatDynArray] | `filter p a` returns all the elements of the array `a` that satisfy the predicate `p`.
filter [BatDllist] | `filter p l` returns a new list, with entirely new nodes, whose values are all the elements of the list `l` that satisfy the predicate `p`.
filter [BatArray.Cap.Labels] |
filter [BatArray.Cap] |
filter [BatArray.Labels] |
filter [BatArray] | `filter p a` returns all the elements of the array `a` that satisfy the predicate `p`.
filter_inplace [BatHashtbl.Cap.Labels] |
filter_inplace [BatHashtbl.Cap] |
filter_inplace [BatHashtbl.S.Labels] |
filter_inplace [BatHashtbl.S] |
filter_inplace [BatHashtbl.Labels] |
filter_inplace [BatHashtbl] | `filter_inplace f m` removes from `m` all bindings that does not satisfy the predicate f.
filter_map [BatVect.Make] | `filter_map f e` returns a vect consisting of all elements `x` such that `f y` returns `Some x` , where `y` is an element of `e`.
filter_map [BatVect] | `filter_map f e` returns a vect consisting of all elements `x` such that `f y` returns `Some x` , where `y` is an element of `e`.
filter_map [BatText] | `filter_map f l` calls `(f a0) (f a1).... (f an)` where `a0..an` are the characters of `l`.
filter_map [BatString.Cap] |
filter_map [BatString] | `filter_map f s` calls `(f a0) (f a1).... (f an)` where `a0..an` are the characters of `s`.
filter_map [BatSet.PSet] | `filter_map f m` combines the features of `filter` and `map`.
filter_map [BatSet.S.Labels] |
filter_map [BatSet.S] | `filter_map f m` combines the features of `filter` and `map`.
filter_map [BatSet] | `filter_map f m` combines the features of `filter` and `map`.
filter_map [BatSeq] | `filter_map f s` returns the sequence of elements filtered and mapped by `f`.
filter_map [BatPervasives] | Similar to a map, except that you can skip over some items of the incoming enumeration by returning None instead of Some value.
filter_map [BatMap.PMap] | `filter_map f m` combines the features of `filter` and `map`.
filter_map [BatMap.S] | `filter_map f m` combines the features of `filter` and `map`.
filter_map [BatMap] | `filter_map f m` combines the features of `filter` and `map`.
filter_map [BatList.Labels] |
filter_map [BatList] | `filter_map f l` calls `(f a0) (f a1).... (f an)` where `a0,a1..an` are the elements of `l`.
filter_map [BatLazyList.Labels] |
filter_map [BatLazyList] | Lazily eliminate some elements and transform others.
filter_map [BatHashtbl.Cap.Labels] |
filter_map [BatHashtbl.Cap] |
filter_map [BatHashtbl.S.Labels] |
filter_map [BatHashtbl.S] |
filter_map [BatHashtbl.Labels] |
filter_map [BatHashtbl] | `filter_map f m` combines the features of `filteri` and `map`.
filter_map [BatEnum.Labels] |
filter_map [BatEnum] | `filter_map f e` returns an enumeration over all elements `x` such as `f y` returns `Some x` , where `y` is an element of `e`.
filter_map [BatDynArray] | `filter_map f e` returns an array consisting of all elements `x` such that `f y` returns `Some x` , where `y` is an element of `e`.
filter_map [BatDllist] | `filter_map f l` calls `(f a0) (f a1) ... (f an)` where `a0,a1...an` are the elements of `l`.
filter_map [BatArray.Cap.Labels] |
filter_map [BatArray.Cap] |
filter_map [BatArray.Labels] |
filter_map [BatArray] | `filter_map f e` returns an array consisting of all elements `x` such that `f y` returns `Some x` , where `y` is an element of `e`.
filter_map_inplace [BatHashtbl.Cap.Labels] |
filter_map_inplace [BatHashtbl.Cap] |
filter_map_inplace [BatHashtbl.S.Labels] |
filter_map_inplace [BatHashtbl.S] |
filter_map_inplace [BatHashtbl.Labels] |
filter_map_inplace [BatHashtbl] | `filter_map_inplace f m` performs like filter_map but modify `m` inplace instead of creating a new Hashtbl.
filteri [BatHashtbl.Cap.Labels] |
filteri [BatHashtbl.Cap] |
filteri [BatHashtbl.S.Labels] |
filteri [BatHashtbl.S] |
filteri [BatHashtbl.Labels] |
filteri [BatHashtbl] | `filter f m` returns a hashtbl where only the key, values pairs `key`, `a` of `m` such that `f key a = true` remain.
filteri [BatArray] | As `filter` but with the index passed to the predicate.
filteri_inplace [BatHashtbl.Cap.Labels] |
filteri_inplace [BatHashtbl.Cap] |
filteri_inplace [BatHashtbl.S.Labels] |
filteri_inplace [BatHashtbl.S] |
filteri_inplace [BatHashtbl.Labels] |
filteri_inplace [BatHashtbl] | `filteri_inplace f m` performs as filter_inplace but `f` receive the value in additiuon to the key.
filterv [BatMap.PMap] | `filterv f m` returns a map where only the values `a` of `m` such that `f a = true` remain.
filterv [BatMap.S.Labels] |
filterv [BatMap.S] | `filterv f m` returns a map where only the values `a` of `m` such that `f a = true` remain.
filterv [BatMap] | `filterv f m` returns a map where only the values `a` of `m` such that `f a = true` remain.
finalise [BatGc] | `finalise f v` registers `f` as a finalisation function for `v`.
finalise_release [BatGc] | A finalisation function may call `finalise_release` to tell the GC that it can launch the next finalisation function without waiting for the current one to return.
finally [BatPervasives] | `finally fend f x` calls `f x` and then `fend()` even if `f x` raised an exception.
finally [BatInnerPervasives] |
find [BatVect.Make] | `find p a` returns the first element of vect `a` that satisfies the predicate `p`.
find [BatVect] | `find p a` returns the first element of vect `a` that satisfies the predicate `p`.
find [BatText] | `find s x` returns the starting index of the first occurrence of rope `x` within rope `s`.
find [BatString.Cap.Exceptionless] |
find [BatString.Cap] |
find [BatString.Exceptionless] | `find s x` returns `Some i`, the starting index of the first occurrence of string `x` within string `s`, or `None` if `x` is not a substring of `s`.
find [BatString] | `find s x` returns the starting index of the first occurrence of string `x` within string `s`.
find [BatSet.S.Exceptionless] |
find [BatSet.S] | `find x s` returns the element in s that tests equal to `x` under its comparison function.
find [BatSet] | `find x s` returns the set element that compares equal to `x`.
find [BatSeq] | `find p s` returns the first element of `s` such as `p e` returns `true`, if any.
find [BatRefList] | Find the first element matching the specified predicate raise `Not_found` if no element is found
find [BatPervasives] | `find f e` returns the first element `x` of `e` such that `f x` returns `true`, consuming the enumeration up to and including the found element, or, raises `Not_found` if no such element exists in the enumeration, consuming the whole enumeration in the search.
find [BatMultiPMap] | `find x m` returns the current binding of `x` in `m`
find [BatMultiMap] | `find x m` returns the current binding of `x` in `m`
find [BatMap.PMap.Exceptionless] |
find [BatMap.PMap] | `find x m` returns the current binding of `x` in `m`, or raises `Not_found` if no such binding exists.
find [BatMap.Exceptionless] |
find [BatMap.S.Exceptionless] |
find [BatMap.S] | `find x m` returns the current binding of `x` in `m`, or raises `Not_found` if no such binding exists.
find [BatMap] | `find x m` returns the current binding of `x` in `m`, or raises `Not_found` if no such binding exists.
find [BatList.Labels.LExceptionless] |
find [BatList.Labels] |
find [BatList.Exceptionless] | `find p l` returns `Some x` where `x` is the first element of `l` such as `p x` returns `true` or `None` if such an element has not been found.
find [BatList] | `find p l` returns the first element of the list `l` that satisfies the predicate `p`.
find [BatLazyList.Labels.Exceptionless] |
find [BatLazyList.Labels] |
find [BatLazyList.Exceptionless] | `rfind p l` returns `Some x` where `x` is the first element of `l` such that `p x` returns `true` or `None` if such element as not been found.
find [BatLazyList] | `find p l` returns the first element of `l` such as `p x` returns `true`.
find [BatInnerWeaktbl] | `Weaktbl.find tbl x` returns the current binding of `x` in `tbl`, or raises `Not_found` if no such binding exists.
find [BatIMap] | `find x t` returns the `y` that is bound to `x` in `t`.
find [BatHashtbl.Cap.Exceptionless] |
find [BatHashtbl.Cap] |
find [BatHashtbl.S.Exceptionless] |
find [BatHashtbl.S] |
find [BatHashtbl.Exceptionless] |
find [BatHashtbl] | `Hashtbl.find tbl x` returns the current binding of `x` in `tbl`, or raises `Not_found` if no such binding exists.
find [BatEnum.Labels.LExceptionless] |
find [BatEnum.Labels] |
find [BatEnum.Exceptionless] | `find f e` returns `Some x` where `x` is the first element `x` of `e` such that `f x` returns `true`, consuming the enumeration up to and including the found element, or `None` if no such element exists in the enumeration, consuming the whole enumeration in the search.
find [BatEnum] | `find f e` returns the first element `x` of `e` such that `f x` returns `true`, consuming the enumeration up to and including the found element.
find [BatDllist] | `find p l` returns the first element, `l` or after, for which `p` returns true.
find [BatDeque] | `find ~backwards f dq` returns `Some (n, x)` if `x` at position `n` is such that `f x` is true, or `None` if there is no such element.
find [BatArray.Cap.Labels] |
find [BatArray.Cap.Exceptionless] |
find [BatArray.Cap] |
find [BatArray.Labels.LExceptionless] |
find [BatArray.Labels] |
find [BatArray.Exceptionless] | `find p a` returns `Some x`, where `x` is the first element of array `a` that satisfies the predicate `p`, or `None` if there is no such element.
find [BatArray] | `find p a` returns the first element of array `a` that satisfies the predicate `p`.
find_all [BatVect.Make] | `find_all` is another name for `Vect.filter`.
find_all [BatVect] | `find_all` is another name for `Vect.filter`.
find_all [BatList.Labels] |
find_all [BatList] | `find_all` is another name for `List.filter`.
find_all [BatInnerWeaktbl] | `Weaktbl.find_all tbl x` returns the list of all data associated with `x` in `tbl`.
find_all [BatHashtbl.Cap] |
find_all [BatHashtbl.S] |
find_all [BatHashtbl] | `Hashtbl.find_all tbl x` returns the list of all data associated with `x` in `tbl`.
find_all [BatArray.Cap] |
find_all [BatArray] | `find_all` is another name for `Array.filter`.
find_default [BatHashtbl.Cap] |
find_default [BatHashtbl.S] |
find_default [BatHashtbl] | Find a binding for the key, and return a default value if not found
find_exc [BatRefList] | Same as find but takes an exception to be raised when no element is found as additional parameter
find_exn [BatList.Labels] |
find_exn [BatList] | `find_exn p e l` returns the first element of `l` such as `p x` returns `true` or raises `e` if such an element has not been found.
find_exn [BatLazyList.Labels] |
find_exn [BatLazyList] | `find_exn p e l` returns the first element of `l` such as `p x` returns `true` or raises `e` if such an element has not been found.
find_from [BatText] | `find_from s ofs x` behaves as `find s x` but starts searching at offset `ofs`.
find_from [BatString.Cap.Exceptionless] |
find_from [BatString.Cap] |
find_from [BatString.Exceptionless] | `find_from s ofs x` behaves as `find s x` but starts searching at offset `ofs`.
find_from [BatString] | `find_from s pos x` behaves as `find s x` but starts searching at position `pos`.
find_map [BatSeq] | `find_map p s` finds the first element of `s` for which `p e` returns `Some r`, if any.
find_map [BatList.Exceptionless] | `find_map f xs` returns `Some y` such that `x` is the first element of the list where `f x` returns `Some y`.
find_map [BatList] | `find_map pred list` finds the first element of `list` for which `pred element` returns `Some r`.
find_map [BatEnum] | `find_map f e` finds the first element `x` of `e` such that `f x` returns `Some r`, then returns r.
find_min [BatHeap.H] | 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.Make] | `findi p a` returns the index of the first element of vect `a` that satisfies the predicate `p`.
findi [BatVect] | `findi p a` returns the index of the first element of vect `a` that satisfies the predicate `p`.
findi [BatList.Labels.LExceptionless] |
findi [BatList.Labels] |
findi [BatList.Exceptionless] | `findi p e l` returns `Some (i, ai)` where `ai` and `i` are respectively the first element of `l` and its index, such that `p i ai` is true, or `None` if no such element has been found.
findi [BatList] | `findi p e l` returns the first element `ai` of `l` along with its index `i` such that `p i ai` is true, or
findi [BatLazyList.Labels.Exceptionless] |
findi [BatLazyList.Labels] |
findi [BatLazyList.Exceptionless] | `findi p e l` returns `Some (i, ai)` where `ai` and `i` are respectively the first element of `l` and its index, such that `p i ai` is true, or `None` if no such element has been found.
findi [BatLazyList] | `findi p e l` returns the first element `ai` of `l` along with its index `i` such that `p i ai` is true.
findi [BatArray.Cap.Exceptionless] |
findi [BatArray.Cap] |
findi [BatArray.Labels.LExceptionless] |
findi [BatArray.Labels] |
findi [BatArray.Exceptionless] | `findi p a` returns `Some n`, where `n` is the index of the first element of array `a` that satisfies the predicate `p`, or `None` if there is no such element.
findi [BatArray] | `findi p a` returns the index of the first element of array `a` that satisfies the predicate `p`.
first [BatVect.Make] |
first [BatVect] |
first [BatUTF8] | The position of the head of the first Unicode character.
first [BatTuple.Tuple5] |
first [BatTuple.Tuple4] |
first [BatTuple.Tuple3] |
first [BatTuple.Tuple2] | Equivalent to `Pervasives.fst`.
first [BatSubstring] | `first sus` returns `Some c` where `c` is the first character in `sus`, if `sus` is non-empty; otherwise returns `None`.
first [BatSeq.Exceptionless] |
first [BatSeq] | Same as `BatSeq.hd`
first [BatRefList] | Returns the first element or raises `Empty_list` if the ref list is empty
first [BatList] | Returns the first element of the list, or
first [BatLazyList] | As `hd`
flags [BatLog.Config] |
flags [BatLog] | This ref holds the output flags.
flatten [BatSeq] | Same as `BatSeq.concat`.
flatten [BatList] | Same as `concat`.
flatten [BatLazyList] | Lazy concatenation of a list of lazy lists
flatten [BatEnum] | Synonym of `BatEnum.concat`
flip [BatPervasives] | Argument flipping.
flip [BatInnerPervasives] |
float [BatRandom.Incubator.Private_state_enums.State] |
float [BatRandom.State] |
float [BatRandom] | `Random.float bound` returns a random floating-point number between 0 (inclusive) and `bound` (exclusive).
float [BatGenlex.Languages.Make] | Parse a floating-point number.
float32 [BatBigarray] | See `Bigarray.char`.
float64 [BatBigarray] | See `Bigarray.char`.
float_callback [BatOptParse.StdOpt] | See `OptParse.StdOpt.int_callback`.
float_dynarray [BatteriesPrint] |
float_of_big_int [BatBig_int] | Returns a floating-point number approximating the given big integer.
float_of_bits [BatInt64] | Return the floating-point number whose internal representation, according to the IEEE 754 floating-point ``double format'' bit layout, is the given `int64`.
float_of_bits [BatInt32] | Return the floating-point number whose internal representation, according to the IEEE 754 floating-point ``single format'' bit layout, is the given `int32`.
float_of_num [BatNum] |
float_option [BatOptParse.StdOpt] | See `OptParse.StdOpt.int_option`.
floats_of [BatIO.BigEndian] | Read an enumeration of IEEE single precision floating point values.
floats_of [BatIO] | Read an enumeration of IEEE single precision floating point values.
floor [BatNum] |
floor [BatFloat.Safe_float] | Round the given float to an integer value.
floor [BatFloat] | Round the given float to an integer value.
floor_num [BatNum] |
flush [BatPervasives] | Flush the buffer associated with the given output, performing all pending writes on that channel.
flush [BatInnerIO] | Flush an output.
flush [BatIO] | Flush an output.
flush_all [BatPervasives] | Write all pending data to output channels, ignore all errors.
flush_all [BatInnerIO] | Flush all outputs.
flush_all [BatIO] | Flush all outputs, ignore errors.
flush_bits [BatIO] | Flush remaining unwritten bits, adding up to 7 bits which values 0.
flush_input [BatLexing] | Discard the contents of the buffer and reset the current position to 0.
flush_str_formatter [BatFormat] | Returns the material printed with `str_formatter`, flushes the formatter and resets the corresponding buffer.
fold [BatVect.Make] | An alias for `fold_left`
fold [BatVect] | An alias for `BatVect.fold_left`
fold [BatText] | `Rope.fold f a r` computes `f (... (f (f a r0) r1)...) rN-1` where `rn = Rope.get n r` and `N = length r`.
fold [BatStream.StreamLabels] |
fold [BatStream] | `fold` is `foldl` without initialization value, where the first element of stream is taken as `init`.
fold [BatSet.PSet] | `fold f s a` computes `(f xN ... (f x1 (f x0 a))...)`, where `x0,x1..xN` are the elements of `s`, in increasing order.
fold [BatSet.S.Labels] |
fold [BatSet.S] | `fold f s a` computes `(f xN ... (f x1 (f x0 a))...)`, where `x0`,`x1`..
fold [BatSet] | `fold f s a` computes `(f xN ... (f x1 (f x0 a))...)`, where `x0,x1..xN` are the elements of `s`, in increasing order.
fold [BatQueue] | `fold f accu q` is equivalent to `List.fold_left f accu l`, where `l` is the list of `q`'s elements.
fold [BatPervasives] | Transformation loop on an enumeration, used to build a single value from an enumeration.
fold [BatMultiPMap] | `fold f m a` computes `(f kN dN ... (f k1 d1 (f k0 d0 a))...)`, where `k0,k1..kN` are the keys of all bindings in `m`, and `d0,d1..dN` are the associated data.
fold [BatMultiMap] | `fold f m a` computes `(f kN dN ... (f k1 d1 (f k0 d0 a))...)`, where `k0,k1..kN` are the keys of all bindings in `m`, and `d0,d1..dN` are the associated data.
fold [BatMap.PMap] | `fold f m a` computes `(f kN dN ... (f k1 d1 (f k0 d0 a))...)`, where `k0,k1..kN` are the keys of all bindings in `m`, and `d0,d1..dN` are the associated data.
fold [BatMap.S.Labels] |
fold [BatMap.S] | `fold f m a` computes `(f kN dN ... (f k1 d1 (f k0 d0 a))...)`, where `k0,k1..kN` are the keys of all bindings in `m` (in increasing order), and `d1 ... dN` are the associated data.
fold [BatMap] | `fold f m a` computes `(f kN dN ... (f k1 d1 (f k0 d0 a))...)`, where `k0,k1..kN` are the keys of all bindings in `m`, and `d0,d1..dN` are the associated data.
fold [BatInnerWeaktbl] | `Weaktbl.fold f tbl init` computes `(f kN dN ... (f k1 d1 init)...)`, where `k1 ... kN` are the keys of all bindings in `tbl`, and `d1 ... dN` are the associated values.
fold [BatISet] | `fold f t x0` returns the final result of merging each element of `t` into `x0` using merge function `f`
fold [BatIMap] | `fold f t x0` folds all the bindings of `t` into `x0` using `f` to merge.
fold [BatHashtbl.Cap.Labels] |
fold [BatHashtbl.Cap] |
fold [BatHashtbl.S.Labels] |
fold [BatHashtbl.S] |
fold [BatHashtbl.Labels] |
fold [BatHashtbl] | `Hashtbl.fold f tbl init` computes `(f kN dN ... (f k1 d1 (f k0 d0 init))...)`, where `k0,k1..kN` are the keys of all bindings in `tbl`, and `d0,d1..dN` are the associated values.
fold [BatHashcons.Table] | `fold f tab x0` folds `f` across every live hashed object in the table `tab`, starting with value `x0`
fold [BatEnum.Labels] |
fold [BatEnum] | A general loop on an enumeration.
fold [BatAvlTree] |
fold2 [BatEnum.Labels] |
fold2 [BatEnum] | `fold2` is similar to `fold` but will fold over two enumerations at the same time until one of the two enumerations ends.
fold2_range [BatIMap] |
fold2i [BatEnum.Labels] |
fold2i [BatEnum] |
fold_left [BatVect.Make] | `fold_left f a r` computes `f (... (f (f a r0) r1)...) rN-1` where `rn = Vect.get n r` and `N = length r`.
fold_left [BatVect] | `fold_left f a r` computes `f (... (f (f a r0) r1)...) rN-1` where `rn = Vect.get n r` and `N = length r`.
fold_left [BatSubstring] | `foldl f e sus` folds `f` over `sus` from left to right.
fold_left [BatString.Cap] |
fold_left [BatString] | `fold_left f a s` is `f (... (f (f a s.[0]) s.[1]) ...) s.[n-1]`
fold_left [BatSeq] | `fold_left f a (cons b0 (... bn))` is `f (... (f (f a b0) b1) ...) bn`.
fold_left [BatRefList] | `List.fold_left f a (ref [b0; b1; ...; bn])` is `f (... (f (f a b0) b1) ...) bn`.
fold_left [BatList.Labels] |
fold_left [BatList] | `List.fold_left f a [b1; ...; bn]` is `f (... (f (f a b1) b2) ...) bn`.
fold_left [BatLazyList.Labels] |
fold_left [BatLazyList] | Eager fold_left
fold_left [BatFingerTree.S] | `fold_left` is equivalent to `List.fold_left`.
fold_left [BatDynArray] | `fold_left f x darr` computes `f ( ... ( f ( f a0 x) a1) ) ... ) aN`, where `a0,a1..aN` are the indexed elements of `darr`.
fold_left [BatDllist] | Accumulate a value over the entire list.
fold_left [BatDeque] | `fold_left f acc dq` is equivalent to `List.fold_left f acc (to_list dq)`, but more efficient.
fold_left [BatArray.Cap.Labels] |
fold_left [BatArray.Cap] |
fold_left [BatArray.Labels] |
fold_left [BatArray] | `Array.fold_left f x a` computes `f (... (f (f x a.(0)) a.(1)) ...) a.(n-1)`, where `n` is the length of the array `a`.
fold_left2 [BatList.Labels] |
fold_left2 [BatList] | `List.fold_left2 f a [b0; b1; ...; bn] [c0; c1; ...; cn]` is `f (... (f (f a b0 c0) b1 c1) ...) bn cn`.
fold_left2 [BatLazyList] | `fold_left2 f a [^ b0; b1; ...; bn ^] [^ c0; c1; ...; cn ^]` is `f (... (f (f a b0 c0) b1 c1) ...) bn cn`.
fold_lefti [BatArray] | As `fold_left`, but with the index of the element as additional argument
fold_monad [BatEnum.WithMonad] | `fold_monad f init e` does a folding of the enumeration `e` applying step by step the function `f` that gives back results in the `Mon` monad, with the `init` initial element.
fold_range [BatISet] | As fold, but operates on contiguous ranges
fold_range [BatIMap] | `fold_range f t x0` folds all the contiguous ranges of `t` into `x0` using `f` to merge.
fold_right [BatVect.RANDOMACCESS] |
fold_right [BatVect.Make] | `fold_right f r a` computes `f (r0 ... (f rN-2 (f rN-1 a)) ...))` where `rn = Vect.get n r` and `N = length r`.
fold_right [BatVect] | `fold_right f r a` computes `f (r0 ... (f rN-2 (f rN-1 a)) ...))` where `rn = Vect.get n r` and `N = length r`.
fold_right [BatSubstring] | `foldr f e sus` folds `f` over `sus` from right to left.
fold_right [BatString.Cap] |
fold_right [BatString] | `fold_right f s b` is `f s.[0] (f s.[1] (... (f s.[n-1] b) ...))`
fold_right [BatSeq] | `fold_right f (cons a0 (cons a1 (cons a2 ...))) b` is `f a0 (f a1 (f a2 ...))`.
fold_right [BatRefList] | `List.fold_right f (ref [a0; a1; ...; an]) b` is `f a0 (f a1 (... (f an b) ...))`.
fold_right [BatList.Labels] |
fold_right [BatList] | `List.fold_right f [a0; a1; ...; an] b` is `f a0 (f a1 (... (f an b) ...))`.
fold_right [BatLazyList.Labels] |
fold_right [BatLazyList] | Eager fold_right
fold_right [BatFingerTree.S] | `fold_right` is equivalent to `List.fold_right`.
fold_right [BatDynArray] | `fold_right f darr x` computes `f a0 (f a1 ( ... ( f aN x ) ... ) )` , where `a0,a1..aN` are the indexed elements of `darr`.
fold_right [BatDllist] | Accumulate a value over the entire list.
fold_right [BatDeque] | `fold_right f dq acc` is equivalent to `List.fold_right f (to_list dq) acc`, but more efficient.
fold_right [BatArray.Cap.Labels] |
fold_right [BatArray.Cap] |
fold_right [BatArray.Labels] |
fold_right [BatArray] | `Array.fold_right f a x` computes `f a.(0) (f a.(1) ( ... (f a.(n-1) x) ...))`, where `n` is the length of the array `a`.
fold_right2 [BatList.Labels] |
fold_right2 [BatList] | `List.fold_right2 f [a0; a1; ...; an] [b0; b1; ...; bn] c` is `f a0 b0 (f a1 b1 (... (f an bn c) ...))`.
fold_right2 [BatLazyList.Labels] |
fold_right2 [BatLazyList] | `fold_right2 f [^ a0; a1; ...; an ^] [^ b0; b1; ...; bn ^] c` is `f a0 b0 (f a1 b1 (... (f an bn c) ...))`.
fold_righti [BatArray] | As `fold_right`, but with the index of the element as additional argument
foldi [BatVect.Make] | As `fold`, but with the position of each value passed to the folding function
foldi [BatVect] | As `BatVect.fold`, but with the position of each value passed to the folding function
foldi [BatMultiPMap] | Same as `fold`, but the function receives as arguments both the key and the associated value for each binding of the map.
foldi [BatMultiMap] | Same as `fold`, but the function receives as arguments both the key and the associated value for each binding of the map.
foldi [BatMap.PMap] | Same as `fold`, but the function receives as arguments both the key and the associated value for each binding of the map.
foldi [BatMap] | Same as `fold`, but the function receives as arguments both the key and the associated value for each binding of the map.
foldi [BatEnum.Labels] |
foldi [BatEnum] |
foldl [BatStream.StreamLabels] |
foldl [BatStream] | `foldl f init stream` is a lazy fold_left.
foldr [BatStream.StreamLabels] |
foldr [BatStream] | `foldr f init stream` is a lazy fold_right.
for_all [BatVect.Make] | `for_all p [a0; a1; ...; an]` checks if all elements of the vect satisfy the predicate `p`.
for_all [BatVect] | `for_all p [a0; a1; ...; an]` checks if all elements of the vect satisfy the predicate `p`.
for_all [BatSet.PSet] | Returns whether the given predicate applies to all elements in the set
for_all [BatSet.S.Labels] |
for_all [BatSet.S] | `for_all p s` checks if all elements of the set satisfy the predicate `p`.
for_all [BatSet] | Returns whether the given predicate applies to all elements in the set
for_all [BatSeq] | `for_all p (cons a0 (cons a1 ...))` checks if all elements of the given sequence satisfy the predicate `p`.
for_all [BatRefList] | Return `true` if all elements match the specified predicate
for_all [BatPervasives] | `exists f e` returns `true` if for every `x` in `e`, `f x` is true
for_all [BatMap.PMap] | Tests whether all key value pairs satisfy some predicate function
for_all [BatMap.S] | `for_all p m` checks if all the bindings of the map satisfy the predicate `p`.
for_all [BatMap] | Tests whether all key value pairs satisfy some predicate function
for_all [BatList.Labels] |
for_all [BatList] | `for_all p [a1; ...; an]` checks if all elements of the list satisfy the predicate `p`.
for_all [BatLazyList.Labels] |
for_all [BatLazyList] | Eager universal.
for_all [BatISet] | Tests whether a predicate applies to all elements of the set
for_all [BatEnum.Labels] |
for_all [BatEnum] | `for_all f e` returns `true` if for every `x` in `e`, `f x` is true
for_all [BatDllist] | Test whether a given predicate returns true for all members of the given list.
for_all [BatArray.Cap.Labels] |
for_all [BatArray.Cap] |
for_all [BatArray.Labels] |
for_all [BatArray] | `for_all p [|a0; a1; ...; an|]` checks if all elements of the array satisfy the predicate `p`.
for_all2 [BatList.Labels] |
for_all2 [BatList] | Same as `List.for_all`, but for a two-argument predicate.
for_all2 [BatLazyList.Labels] |
for_all2 [BatLazyList] | Same as `BatLazyList.for_all`, but for a two-argument predicate.
for_all2 [BatArray] | As `Array.for_all` but on two arrays.
forall2_range [BatIMap] |
force [BatEnum] | `force e` forces the application of all lazy functions and the enumeration of all elements, exhausting the enumeration.
force_newline [BatFormat] | Forces a newline in the current box.
foreach [BatPervasives] | Imperative loop on an enumeration.
forever [BatPervasives] | `forever f x` invokes `f` on `x` repeatedly (until an exception occurs).
forever [BatInnerPervasives] |
fork [BatUnix] | Fork a new process.
format_from_string [BatScanf] | `format_from_string s fmt` converts a string argument to a format string, according to the given format string `fmt`.
format_timestamp [BatLogger] | `format_timestamp oc timestamp` prints an ISO-8601 formatted timestamp (extended to specify higher-resolution seconds) to the output channel, `oc`.
formatter_of_buffer [BatFormat] | `formatter_of_buffer b` returns a new formatter writing to buffer `b`.
formatter_of_out_channel [BatFormat] | `formatter_of_out_channel oc` returns a new formatter that writes to the corresponding channel `oc`.
formatter_of_output [BatFormat] | `formatter_of_output out` returns a new formatter that writes to the corresponding output `out`.
fortran_layout [BatBigarray] |
fourth [BatTuple.Tuple5] |
fourth [BatTuple.Tuple4] |
fprintf [BatPrintf] | General function.
fprintf [BatFormat] |
frexp [BatFloat.Safe_float] | `frexp f` returns the pair of the significant and the exponent of `f`.
frexp [BatFloat] | `frexp f` returns the pair of the significant and the exponent of `f`.
from [BatStream] | `Stream.from f` returns a stream built from the function `f`.
from [BatLazyList] | `from next` creates a (possibly infinite) lazy list from the successive results of `next`.
from [BatISet] | `from x t` returns the portion of `t` in the range `x, max_int`
from [BatIMap] | Return the sub-map of bindings in the range `x,max_int`
from [BatEnum.Labels] |
from [BatEnum] | `from next` creates an enumeration from the `next` function.
from_channel [BatScanf.Scanning] |
from_channel [BatMarshal] |
from_file [BatScanf.Scanning] | Bufferized file reading in text mode.
from_file_bin [BatScanf.Scanning] | Bufferized file reading in binary mode.
from_function [BatScanf.Scanning] | `Scanning.from_function f` returns a scanning buffer with the given function as its reading method.
from_function [BatLexing] | Create a lexer buffer with the given function as its reading method.
from_hex [BatDigest] | Convert a hexadecimal representation back into the corresponding digest.
from_in_channel [BatIO] |
from_in_chars [BatIO] |
from_input [BatScanf.Scanning] | `Scanning.from_channel ic` returns a scanning buffer which reads from the input channel `ic`, starting at the current reading position.
from_input [BatLexing] | Create a lexer buffer on the given input `Lexing.from_input inp` returns a lexer buffer which reads from the input `inp`, at the current reading position.
from_loop [BatLazyList] | `from_loop data next` creates a (possibly infinite) lazy list from the successive results of applying `next` to `data`, then to the result, etc.
from_loop [BatEnum.Labels] |
from_loop [BatEnum] | `from_loop data next` creates a (possibly infinite) enumeration from the successive results of applying `next` to `data`, then to the result, etc.
from_out_channel [BatIO] |
from_out_chars [BatIO] |
from_string [BatScanf.Scanning] | `Scanning.from_string s` returns a scanning buffer which reads from the given string.
from_string [BatMarshal] | `Marshal.from_string buff ofs` unmarshals a structured value like `Marshal.from_channel` does, except that the byte representation is not read from a channel, but taken from the string `buff`, starting at position `ofs`.
from_string [BatLexing] | Create a lexer buffer which reads from the given string.
from_while [BatLazyList] | `from next` creates a (possibly infinite) lazy list from the successive results of `next`.
from_while [BatEnum.Labels] |
from_while [BatEnum] | `from_while next` creates an enumeration from the `next` function.
front [BatFingerTree.S] | `front t` returns `None` when `t` is empty, or `Some (tl, hd)` when `hd` is the first element of the sequence and `tl` is the rest of the sequence.
front [BatDeque] | `front dq` returns `Some (x, dq')` iff `x` is at the front of `dq` and `dq'` is the rest of `dq` excluding `x`, and `None` if `dq` has no elements.
front_exn [BatFingerTree.S] | `front_exn t` returns `(tl, hd)` when `hd` is the first element of the sequence and `tl` is the rest of the sequence.
fscanf [BatScanf] | Same as `Scanf.bscanf`, but reads from the given channel.
fstat [BatUnix.LargeFile] |
fstat [BatUnix] | Return the information for the file associated with the given descriptor.
fsum [BatList] | `fsum l` returns the sum of the floats of `l`
fsum [BatEnum] |
fsum [BatArray] | `fsum l` returns the sum of the floats of `l`
ftruncate [BatUnix.LargeFile] |
ftruncate [BatUnix] | Truncates the file corresponding to the given descriptor to the given size.
full_init [BatRandom] | Same as `Random.init` but takes more data as seed.
full_major [BatGc] | Do a minor collection, finish the current major collection cycle, and perform a complete new cycle.
full_range_int [BatRandom] | `full_range_int ()` returns the maximum entropy possible in a single int: 31 bits on 32-bit platforms and 63 bits on 64-bit platforms.
G
gcd_big_int [BatBig_int] | Greatest common divisor of two big integers.
ge_big_int [BatBig_int] |
ge_num [BatNum] |
genarray_of_array1 [BatBigarray] | Return the generic big array corresponding to the given one-dimensional big array.
genarray_of_array2 [BatBigarray] | Return the generic big array corresponding to the given two-dimensional big array.
genarray_of_array3 [BatBigarray] | Return the generic big array corresponding to the given three-dimensional big array.
get [BatVect.RANDOMACCESS] |
get [BatVect.Make] | `get v n` returns the (n+1)th element from the vect `v`; i.e.
get [BatVect] | `get v n` returns the (n+1)th element from the vect `v`; i.e.
get [BatUTF8] | `get s n` returns `n`-th Unicode character of `s`.
get [BatText] | `get r n` returns the (n+1)th character from the rope `r`; i.e.
get [BatSubstring] | `sub sus k` returns the k'th character of the substring; that is, s(i+k) where sus = (s, i, n).
get [BatString.Cap] |
get [BatString] | `String.get s n` returns character number `n` in string `s`.
get [BatResult] | `get (Ok x)` returns `x`, and `get (Bad e)` raises `e`.
get [BatRef] | As `!`
get [BatPervasives] | `get e` returns `None` if `e` is empty or `Some x` where `x` is the next element of `e`, in which case the element is removed from the enumeration.
get [BatPathGen.StringType] | Usual get function.
get [BatOption] | `get (Some x)` returns `x`.
get [BatOptParse.Opt] | Get the value of an option.
get [BatLazyList] | `get l` returns the head and tail of `l`, if `l` is not empty.
get [BatGlobal] | Return `None` if the global is undefined, else `Some v` where `v` is the current global value contents.
get [BatGc] | Return the current values of the GC parameters in a `control` record.
get [BatFingerTree] | `get t i` returns the `i`-th element of `t`.
get [BatEnum] | `get e` returns `None` if `e` is empty or `Some x` where `x` is the next element of `e`, in which case the element is removed from the enumeration.
get [BatDynArray] | `get darr idx` gets the element in `darr` at index `idx`.
get [BatDllist] | Given a node, get the data associated with that node.
get [BatBigarray.Array3] | `Array3.get a x y z`, also written `a.{x,y,z}`, returns the element of `a` at coordinates (`x`, `y`, `z`).
get [BatBigarray.Array2] | `Array2.get a x y`, also written `a.{x,y}`, returns the element of `a` at coordinates (`x`, `y`).
get [BatBigarray.Array1] | `Array1.get a x`, or alternatively `a.{x}`, returns the element of `a` at index `x`.
get [BatBigarray.Genarray] | Read an element of a generic big array.
get [BatArray.Cap] |
get [BatArray] | `Array.get a n` returns the element number `n` of array `a`.
get12 [BatTuple.Tuple5] |
get12 [BatTuple.Tuple4] |
get12 [BatTuple.Tuple3] |
get123 [BatTuple.Tuple5] |
get123 [BatTuple.Tuple4] |
get1234 [BatTuple.Tuple5] |
get1235 [BatTuple.Tuple5] |
get124 [BatTuple.Tuple5] |
get124 [BatTuple.Tuple4] |
get1245 [BatTuple.Tuple5] |
get125 [BatTuple.Tuple5] |
get13 [BatTuple.Tuple5] |
get13 [BatTuple.Tuple4] |
get13 [BatTuple.Tuple3] |
get134 [BatTuple.Tuple5] |
get1345 [BatTuple.Tuple5] |
get135 [BatTuple.Tuple5] |
get14 [BatTuple.Tuple5] |
get14 [BatTuple.Tuple4] |
get145 [BatTuple.Tuple5] |
get15 [BatTuple.Tuple5] |
get23 [BatTuple.Tuple5] |
get23 [BatTuple.Tuple4] |
get23 [BatTuple.Tuple3] |
get234 [BatTuple.Tuple5] |
get234 [BatTuple.Tuple4] |
get2345 [BatTuple.Tuple5] |
get235 [BatTuple.Tuple5] |
get24 [BatTuple.Tuple5] |
get24 [BatTuple.Tuple4] |
get245 [BatTuple.Tuple5] |
get25 [BatTuple.Tuple5] |
get34 [BatTuple.Tuple5] |
get34 [BatTuple.Tuple4] |
get345 [BatTuple.Tuple5] |
get35 [BatTuple.Tuple5] |
get45 [BatTuple.Tuple5] |
get_all_formatter_output_functions [BatFormat] | Return the current output functions of the pretty-printer, including line breaking and indentation functions.
get_backtrace [BatPrintexc] | `Printexc.get_backtrace ()` returns a string containing the same exception backtrace that `Printexc.print_backtrace` would print.
get_cmp [BatSet.PSet] | get the comparison function used for a polymorphic map
get_cmp [BatMap.PMap] | returns the comparison function of the given map
get_dec_eq [BatIMap] | Get the equality function used in an IMap.t
get_ellipsis_text [BatFormat] | Return the text of the ellipsis.
get_exn [BatOption] | `get_exn (Some x) e` returns `x` and `get_exn None e` raises `e`.
get_exn [BatGlobal] | Get the global value contents - raise Global_not_initialized if not defined.
get_exn [BatEnum] | `get_exn e` returns the first element of `e`.
get_formatter_output_functions [BatFormat] | Return the current output functions of the pretty-printer.
get_formatter_tag_functions [BatFormat] | Return the current tag functions of the pretty-printer.
get_margin [BatFormat] | Returns the position of the right margin.
get_mark_tags [BatFormat] | Return the current status of tags printing and tags marking.
get_max_boxes [BatFormat] | Returns the maximum number of boxes allowed before ellipsis.
get_max_indent [BatFormat] | Return the value of the maximum indentation limit (in characters).
get_method [BatOo.Internal] |
get_method_label [BatOo.Internal] |
get_method_labels [BatOo.Internal] |
get_print_tags [BatFormat] |
get_public_method [BatOo.Internal] |
get_resizer [BatDynArray] | Get the current resizer function for a given array
get_state [BatRandom] | Return the current state of the generator used by the basic functions.
get_state [BatParserCo.Source] |
get_variable [BatOo.Internal] |
get_variables [BatOo.Internal] |
getaddrinfo [BatUnix] | `getaddrinfo host service opts` returns a list of `Unix.addr_info` records describing socket parameters and addresses suitable for communicating with the given host and service.
getc [BatSubstring] | `getc sus` returns `Some(c, rst)` where `c` is the first character and `rst` the remainder of `sus`, if `sus` is non-empty; otherwise returns `None`.
getcwd [BatUnix] | Return the name of the current working directory.
getcwd [BatSys] | Return the current working directory of the process.
getegid [BatUnix] | Return the effective group id under which the process runs.
getenv [BatUnix] | Return the value associated to a variable in the process environment.
getenv [BatSys] | Return the value associated to a variable in the process environment.
geteuid [BatUnix] | Return the effective user id under which the process runs.
getgid [BatUnix] | Return the group id of the user executing the process.
getgrgid [BatUnix] | Find an entry in `group` with the given group id.
getgrnam [BatUnix] | Find an entry in `group` with the given name.
getgroups [BatUnix] | Return the list of groups to which the user executing the process belongs.
gethostbyaddr [BatUnix] | Find an entry in `hosts` with the given address.
gethostbyname [BatUnix] | Find an entry in `hosts` with the given name.
gethostname [BatUnix] | Return the name of the local host.
getitimer [BatUnix] | Return the current status of the given interval timer.
getlogin [BatUnix] | Return the login name of the user executing the process.
getnameinfo [BatUnix] | `getnameinfo addr opts` returns the host name and service name corresponding to the socket address `addr`.
getpeername [BatUnix] | Return the address of the host connected to the given socket.
getpid [BatUnix] | Return the pid of the process.
getppid [BatUnix] | Return the pid of the parent process.
getprotobyname [BatUnix] | Find an entry in `protocols` with the given name
getprotobynumber [BatUnix] | Find an entry in `protocols` with the given protocol number.
getpwnam [BatUnix] | Find an entry in `passwd` with the given name.
getpwuid [BatUnix] | Find an entry in `passwd` with the given user id.
getservbyname [BatUnix] | Find an entry in `services` with the given name.
getservbyport [BatUnix] | Find an entry in `services` with the given service number.
getsockname [BatUnix] | Return the address of the given socket.
getsockopt [BatUnix] | Return the current status of a boolean-valued option in the given socket.
getsockopt_error [BatUnix] | Return the error condition associated with the given socket, and clear it.
getsockopt_float [BatUnix] | Same as `Unix.getsockopt` for a socket option whose value is a floating-point number.
getsockopt_int [BatUnix] | Same as `Unix.getsockopt` for an integer-valued socket option.
getsockopt_optint [BatUnix] | Same as `Unix.getsockopt` for a socket option whose value is an `int option`.
gettimeofday [BatUnix] | Same as `Unix.time`, but with resolution better than 1 second.
getuid [BatUnix] | Return the user id of the user executing the process.
gmtime [BatUnix] | Convert a time in seconds, as returned by `Unix.time`, into a date and a time.
group [BatList] | `group cmp l` returns list of groups and each group consists of elements judged equal by comparison function `cmp`.
group [BatEnum] | `group test e` divides `e` into an enumeration of enumerations, where each sub-enumeration is the longest continuous enumeration of elements whose `test` results are the same.
group_by [BatEnum] | `group_by eq e` divides `e` into an enumeration of enumerations, where each sub-enumeration is the longest continuous enumeration of elements that are equal, as judged by `eq`.
group_consecutive [BatList] | The `group_consecutive` function takes a list and returns a list of lists such that the concatenation of the result is equal to the argument.
group_exec [BatFile] | Give the permission to execute the file to the group containing the user.
group_read [BatFile] | Give the permission to read the file to the group containing the user.
group_write [BatFile] | Give the permission to write the file to the group containing the user.
gt_big_int [BatBig_int] | Usual boolean comparisons between two big integers.
gt_num [BatNum] |
H
handle_unix_error [BatUnix] | `handle_unix_error f x` applies `f` to `x` and returns the result.
hard_count [BatEnum] | `hard_count` returns the number of remaining in elements in `e`, consuming the whole enumeration somewhere along the way.
hash [BatInnerIO.Output] | A hash function for outputs
hash [BatInnerIO.Input] | A hash function for inputs
hash [BatHashtbl.HashedType] | A hashing function on keys.
hash [BatHashtbl] | `Hashtbl.hash x` associates a positive integer to any value of any type.
hash [BatChar] |
hash_param [BatHashtbl] | `Hashtbl.hash_param n m x` computes a hash value for `x`, with the same properties as for `hash`.
hashcons [BatHashcons.Table] | `hashcons tab k` returns either `k`, adding it to the table `tab` as a side effect, or if `k` is already in the table then it returns the hashed object corresponding to that entry.
hc0 [BatHashcons.H] | `hc0 ho` is the hashcode of a first constructor applied to the hashed object `ho`
hc0_ [BatHashcons.H] | `hc0_ h` corresponds to the hashcode of a first constructor applied to an object of hashcode `h`
hc1 [BatHashcons.H] | `hc1 ho k` corresponds to the hashcode of the `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 [BatList] | Similar to `first`, but
hd [BatLazyList] | Return the first element of the given list.
head [BatText] | as `BatText.left`
head [BatString.Cap] |
head [BatString] | as `BatString.left`
head [BatFingerTree.S] | `head t` returns `None` if `t` is empty, or `Some hd` otherwise, where `hd` is the first element of the sequence.
head [BatArray] | as `BatArray.left`
head_exn [BatFingerTree.S] | `head_exn t` returns the first element of the sequence.
header_size [BatMarshal] | The bytes representing a marshaled value are composed of a fixed-size header and a variable-sized data part, whose size can be determined from the header.
height [BatVect.Make] | Returns the height (depth) of the vect.
height [BatVect] | Returns the height (depth) of the vect.
height [BatText] | Returns the height (depth) of the rope.
height [BatAvlTree] |
help_option [BatOptParse.StdOpt] | `help_option ()` returns the standard help option which displays a usage message and exits the program when encountered on the command line.
hex [BatCharParser] | Recognizes one hexadecimal digit (case-insensitive)
I
i [BatComplex] | The complex number `i`.
i16s_of [BatIO.BigEndian] | Read an enumartion of signed 16-bit words.
i16s_of [BatIO] | Read an enumartion of signed 16-bit words.
i32s_of [BatIO.BigEndian] | Read an enumeration of signed 32-bit integers.
i32s_of [BatIO] | Read an enumeration of signed 32-bit integers.
i64s_of [BatIO.BigEndian] | Read an enumeration of signed 64-bit integers as OCaml `int64`s.
i64s_of [BatIO] | Read an enumeration of signed 64-bit integers as OCaml `int64`s.
icompare [BatString.Cap] |
icompare [BatString] | Compare two strings, case-insensitive.
id [BatOo] | Return an integer identifying this object, unique for the current execution of the program.
ident [BatGenlex.Languages.Make] | Accepts any non-reserved identifier/operator.
ident_letter [BatGenlex.Languages.Definition] |
ident_start [BatGenlex.Languages.Definition] |
identifier [BatGenlex.Languages.Make] |
identity [BatPervasives] | The identity function.
identity [BatInnerPervasives] |
ifprintf [BatPrintf] | As `BatPrintf.fprintf` but doesn't actually print anything.
ifprintf [BatFormat] | Same as `fprintf` above, but does not print anything.
ignore_exceptions [BatPervasives] | `ignore_exceptions f x` invokes `f` on `x`, ignoring both the returned value and the exceptions that may be raised.
ignore_exceptions [BatInnerPervasives] |
ignore_ok [BatPervasives] | `ignore_ok (f x)` ignores the result of `f x` if it's ok, but throws the exception contained if `Bad` is returned.
ignore_ok [BatInnerPervasives] |
ignore_one_plus [BatParserCo] | Ignore a (non-empty) list of expressions.
ignore_zero_plus [BatParserCo] | Ignore a (possibly empty) list of expressions.
ikfprintf [BatFormat] | Same as `kfprintf` above, but does not print anything.
implode [BatText] | `implode cs` returns a rope resulting from concatenating the characters in the list `cs`.
implode [BatString.Cap] |
implode [BatString] | `implode cs` returns a string resulting from concatenating the characters in the list `cs`.
in_channel_of_descr [BatUnix] | Create an input channel reading from the given descriptor.
in_place_mirror [BatString] |
incr_num [BatNum] |
incr_option [BatOptParse.StdOpt] | Exactly identical to `count_option ~dest:dest ~increment:1 ()`.
indented_formatter [BatOptParse.Formatter] | Create an "indented" formatter with the given options.
index [BatText] | `index s c` returns the position of the leftmost occurrence of character `c` in rope `s`.
index [BatSubstring] | `index sus c` returns the index of the first occurence of `c` in `sus` or
index [BatString.Cap.Exceptionless] |
index [BatString.Cap] |
index [BatString.Exceptionless] | `index s c` returns `Some p`, the position of the leftmost occurrence of character `c` in string `s` or `None` if `c` does not occur in `s`.
index [BatString] | `String.index s c` returns the character number of the first occurrence of character `c` in string `s`.
index [BatRefList.Index] | Return the index (position : 0 starting) of an element in a ref list, using the specified comparator raise `Not_found` if no element was found
index_from [BatText] | `index_from r i c` returns the character number of the first occurrence of character `c` in rope `r` after position `i`.
index_from [BatSubstring] | `index_from sus i c` returns the index of the first occurence of `c` in `sus` after the index `i` or
index_from [BatString.Cap.Exceptionless] |
index_from [BatString.Cap] |
index_from [BatString.Exceptionless] | Same as `String.Exceptionless.index`, but start searching at the character position given as second argument.
index_from [BatString] | `String.index_from s i c` returns the character number of the first occurrence of character `c` in string `s` after position `i`.
index_of [BatRefList.Index] | Return the index (position : 0 starting) of an element in a ref list, using ( = ) for testing element equality raise `Not_found` if no element was found
index_of [BatList] | `index_of e l` returns the index of the first occurrence of `e` in `l`, or `None` if there is no occurrence of `e` in `l`
index_of [BatLazyList] | `index_of e l` returns the index of the first occurrence of `e` in `l`, or `None` if there is no occurrence of `e` in `l`
index_of [BatDynArray] | `index_of f darr` returns the index of the first element `x` in darr such as `f x` returns `true` or raise `Not_found` if not found.
index_ofq [BatList] | `index_ofq e l` behaves as `index_of e l` except it uses physical equality
index_ofq [BatLazyList] | `index_ofq e l` behaves as `index_of e l` except it uses physical equality
inet6_addr_any [BatUnix] | A special IPv6 address, for use only with `bind`, representing all the Internet addresses that the host machine possesses.
inet6_addr_loopback [BatUnix] | A special IPv6 address representing the host machine (`::1`).
inet_addr_any [BatUnix] | A special IPv4 address, for use only with `bind`, representing all the Internet addresses that the host machine possesses.
inet_addr_loopback [BatUnix] | A special IPv4 address representing the host machine (`127.0.0.1`).
inet_addr_of_string [BatUnix] | Conversion from the printable representation of an Internet address to its internal representation.
infinity [BatFloat.Safe_float] | Positive infinity.
infinity [BatFloat] | Positive infinity.
inherit_in [BatInnerIO] | Simplified and optimized version of `BatInnerIO.wrap_in` whenever only one input appears as dependency.
inherit_in [BatIO] | Simplified and optimized version of `BatIO.wrap_in` which may be used whenever only one input appears as dependency.
inherit_out [BatInnerIO] | Simplified and optimized version of `BatInnerIO.wrap_out` whenever only one output appears as dependency.
inherit_out [BatIO] | Simplified and optimized version of `BatIO.wrap_out` whenever only one output appears as dependency.
inherits [BatOo.Internal] |
init [BatVect.Make] | `init n f` returns a fresh vect of length `n`, with element number `i` initialized to the result of `f i`.
init [BatVect] | `init n f` returns a fresh vect of length `n`, with element number `i` initialized to the result of `f i`.
init [BatUTF8] | `init len f` returns a new string which contains `len` Unicode characters.
init [BatText] | `init l f` returns the rope of length `l` with the chars f 0 , f 1 , f 2 ...
init [BatString.Cap] |
init [BatString] | `init l f` returns the string of length `l` with the chars f 0 , f 1 , f 2 ...
init [BatSeq] | `init n f` returns the sequence returning the results of `f 0`, `f 1`....
init [BatRandom] | Initialize the generator, using the argument as a seed.
init [BatLogger] | `init name_level_list formatter` initializes the logging system enabling the specified levels for each named logger.
init [BatList.Labels] |
init [BatList] | Similar to `Array.init`, `init n f` returns the list containing the results of (f 0),(f 1)....
init [BatLazyList] | Similar to `Array.init`, `init n f` returns the lazy list containing the results of (f 0),(f 1)....
init [BatFingerTree.S] | `init t` returns `None` if `t` is empty, or `Some init` where `init` is the sequence `t` where the last element has been removed.
init [BatEnum.Labels] |
init [BatEnum] | `init n f` creates a new enumeration over elements `f 0, f 1, ..., f (n-1)`
init [BatDynArray] | `init n f` returns an array of `n` elements filled with values returned by `f 0 , f 1, ... f (n-1)`.
init [BatArray.Cap.Labels] |
init [BatArray.Cap] |
init [BatArray.Labels] |
init [BatArray] | `Array.init n f` returns a fresh array of length `n`, with element number `i` initialized to the result of `f i`.
init_class [BatOo.Internal] |
init_exn [BatFingerTree.S] | `init_exn t` returns the sequence `t` where the last element has been removed.
init_from_string [BatLogger] | `init_from_string name_level_string formatter` initializes the logging system enabling the specified levels for each named logger.
initgroups [BatUnix] | `initgroups user group` initializes the group access list by reading the group database /etc/group and using all groups of which `user` is a member.
input [BatPervasives] | `input ic buf pos len` reads up to `len` characters from the given channel `ic`, storing them in string `buf`, starting at character number `pos`.
input [BatMarshal] | `input inp` reads from `inp` the byte representation of a structured value, as produced by one of the `Marshal.to_*` functions, and reconstructs and returns the corresponding value.
input [BatInnerIO] | `input i s p l` reads up to `l` characters from the given input, storing them in string `s`, starting at character number `p`.
input [BatIO] | `input i s p l` reads up to `l` characters from the given input, storing them in string `s`, starting at character number `p`.
input [BatDigest] | Read a digest from the given input.
input_all [BatPervasives] | Return the whole contents of an input channel as a single string.
input_binary_float [BatPervasives] | Read a float encoded in binary format (8 bytes, IEEE 754 double format) from the given input channel.
input_binary_int [BatPervasives] | Read an integer encoded in binary format (4 bytes, big-endian) from the given input channel.
input_bits [BatIO] | Read bits from an input
input_byte [BatPervasives] | Same as `Pervasives.input_char`, but return the 8-bit integer representing the character.
input_channel [BatInnerIO] | Create an input that will read from a channel.
input_channel [BatIO] | Create an input that will read from a channel.
input_char [BatPervasives] | Read one character from the given input channel.
input_chars [BatPervasives] | Returns an enumeration over characters of an input channel.
input_enum [BatIO] | Create an input that will read from an `enum`.
input_file [BatPervasives] | returns the data of a given filename.
input_line [BatPervasives] | Read characters from the given input channel, until a newline character is encountered.
input_lines [BatPervasives] | Returns an enumeration over lines of an input channel, as read by the `input_line` function.
input_list [BatPervasives] | Returns the list of lines read from an input channel.
input_of_descr [BatUnix] | Create an `input` reading from the given descriptor.
input_string [BatInnerIO] | Create an input that will read from a string.
input_string [BatIO] | Create an input that will read from a string.
input_value [BatPervasives] | Read the representation of a structured value, as produced by `BatPervasives.output_value`, and return the corresponding value.
insert [BatVect.Make] | `insert n r u` returns a copy of the `u` vect where `r` has been inserted between the elements with index `n` and `n + 1` in the original vect.
insert [BatVect] | `insert n r u` returns a copy of the `u` vect where `r` has been inserted between the elements with index `n` and `n + 1` in the original vect.
insert [BatText] | `insert n r u` returns a copy of the `u` rope where `r` has been inserted between the characters with index `n` and `n + 1` in the original rope.
insert [BatHeap.H] | 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.Incubator.Private_state_enums.State] |
int [BatRandom.State] |
int [BatRandom] | `Random.int bound` returns a random integer between 0 (inclusive) and `bound` (exclusive).
int [BatBigarray] | See `Bigarray.char`.
int16_signed [BatBigarray] | See `Bigarray.char`.
int16_unsigned [BatBigarray] | See `Bigarray.char`.
int32 [BatRandom.Incubator.Private_state_enums.State] |
int32 [BatRandom.State] |
int32 [BatRandom] | `Random.int32 bound` returns a random integer between 0 (inclusive) and `bound` (exclusive).
int32 [BatBigarray] | See `Bigarray.char`.
int32_of_big_int [BatBig_int] | Convert a big integer to a 32-bit integer.
int64 [BatRandom.Incubator.Private_state_enums.State] |
int64 [BatRandom.State] |
int64 [BatRandom] | `Random.int64 bound` returns a random integer between 0 (inclusive) and `bound` (exclusive).
int64 [BatBigarray] | See `Bigarray.char`.
int64_of_big_int [BatBig_int] | Convert a big integer to a 64-bit integer.
int8_signed [BatBigarray] | See `Bigarray.char`.
int8_unsigned [BatBigarray] | See `Bigarray.char`.
int_callback [BatOptParse.StdOpt] | `int_callback ?metavar f` returns an option which takes a single integer argument and calls `f` with that argument when encountered on the command line.
int_dynarray [BatteriesPrint] |
int_enum [BatteriesPrint] |
int_int_pmap [BatteriesPrint] |
int_of [BatUChar] | Alias of `code`
int_of_big_int [BatBig_int] | Convert a big integer to a small integer (type `int`).
int_of_num [BatNum] |
int_option [BatOptParse.StdOpt] | `int_option ?default ?metavar ()` returns an option which takes a single integer argument.
int_pset [BatteriesPrint] |
int_set [BatteriesPrint] |
int_str_pmap [BatteriesPrint] |
integer [BatGenlex.Languages.Make] | Parse an integer.
integer_num [BatNum] |
inter [BatSet.S] | Set intersection.
inter [BatISet] | Compute the intersection of two sets.
inter [BatBitSet] | `inter s t` returns the intersection of sets `s` and `t`.
interactive [BatSys] | This reference is initially set to `false` in standalone programs and to `true` if the code is being executed under the interactive toplevel system `ocaml`.
interleave [BatList] | `interleave ~first ~last sep [a0;a1;a2;...;an]` returns `first; a0; sep; a1; sep; a2; sep; ...; sep; an; last`
intersect [BatSet.PSet] | `intersect s t` returns a new set of those elements that are in both `s` and `t`.
intersect [BatSet] | `intersect s t` returns a new set of those elements that are in both `s` and `t`.
intersect [BatMap.PMap] | `intersect merge_f m1 m2` returns a map with bindings only for keys bound in both `m1` and `m2`, and with `k` bound to `merge_f v1 v2`, where `v1` and `v2` are `k`'s bindings in `m1` and `m2`.
intersect [BatMap] | `intersect merge_f m1 m2` returns a map with bindings only for keys bound in both `m1` and `m2`, and with `k` bound to `merge_f v1 v2`, where `v1` and `v2` are `k`'s bindings in `m1` and `m2`.
intersect [BatBitSet] | `intersect s t` sets `s` to the intersection of the sets `s` and `t`.
inv [BatComplex] | Multiplicative inverse (`1/z`).
invpi [BatFloat] | `1. /. pi`
invpi2 [BatFloat] | `2. /. pi`
invsqrt2 [BatFloat] | `1. /. sqrt 2.`
is_absolute [BatPathGen.PathType] |
is_bad [BatResult] | `is_bad (Bad _)` is `true`, otherwise `false`
is_digit [BatChar] | Determine if a character represents a digit.
is_directory [BatUnix] | `is_directory filename` returns true if `filename` refers to a directory (or symlink of a directory)
is_directory [BatSys] | Returns `true` if the given name refers to a directory, `false` if it refers to another kind of file.
is_empty [BatVect.Make] | Returns whether the vect is empty or not.
is_empty [BatVect] | Returns whether the vect is empty or not.
is_empty [BatText] | Returns whether the rope is empty or not.
is_empty [BatSubstring] | `isEmpty (s, i, n)` true if the substring is empty (that is, `n = 0`).
is_empty [BatString.Cap] |
is_empty [BatString] | `is_empty s` returns `true` if `s` is the empty string, `false` otherwise.
is_empty [BatStream] | `is_empty stream` tests whether `stream` is empty.
is_empty [BatStack] | Return `true` if the given stack is empty, `false` otherwise.
is_empty [BatSet.PSet] | Test whether a set is empty or not.
is_empty [BatSet.S] | Test whether a set is empty or not.
is_empty [BatSet] | Test whether a set is empty or not.
is_empty [BatSeq] | `is_empty e` returns true if `e` does not contains any element.
is_empty [BatRefList] | Return `true` if a ref list is empty
is_empty [BatQueue] | Return `true` if the given queue is empty, `false` otherwise.
is_empty [BatMultiPMap] | returns true if the map is empty.
is_empty [BatMultiMap] | returns true if the map is empty.
is_empty [BatMap.PMap] | returns true if the map is empty.
is_empty [BatMap.S] | Test whether a map is empty or not.
is_empty [BatMap] | returns true if the map is empty.
is_empty [BatList] | `is_empty e` returns true if `e` does not contains any element.
is_empty [BatLazyList] | Returns `true` if the list is empty, false otherwise.
is_empty [BatISet] | Test whether a set is empty, returns `true` if the set is empty.
is_empty [BatIMap] | Test whether a map is empty (i.e.
is_empty [BatHashtbl.Cap] |
is_empty [BatHashtbl.S] |
is_empty [BatHashtbl] | `Hashtbl.is_empty tbl` returns `true` if there are no bindings in `tbl`, false otherwise.
is_empty [BatFingerTree.S] | `is_empty t` returns `true` when the sequence has no elements.
is_empty [BatEnum] | `is_empty e` returns true if `e` does not contains any element.
is_empty [BatDeque] | `is_empty dq` returns `false` iff `dq` has no elements.
is_empty [BatAvlTree] |
is_exn [BatResult] | `is_exn e1 r` is `true` iff `r` is `Bad e2` with `e1=e2`
is_finite [BatFloat] | `is_finite f` returns `true` if `f` is not `nan` or `+/- infinity`, `false` otherwise.
is_int_big_int [BatBig_int] | Test whether the given big integer is small enough to be representable as a small integer (type `int`) without loss of precision.
is_integer [BatNum] | `is_integer x` returns `true` if `x` represents an integer value, `false` otherwise
is_integer_num [BatNum] |
is_latin1 [BatChar] | Determine if a character is a Latin 1 letter.
is_letter [BatChar] | Determine if a character represents a ASCII letter.
is_lowercase [BatChar] | Determine if a character is lowercase ASCII.
is_lowercase_latin1 [BatChar] | Determine if a character is lowercase Latin 1.
is_nan [BatFloat.Safe_float] | `is_nan f` returns `true` if `f` is `nan`, `false` otherwise.
is_nan [BatFloat] | `is_nan f` returns `true` if `f` is `nan`, `false` otherwise.
is_newline [BatChar] | Determine if a character is a newline.
is_none [BatOption] | `is_none None` returns `true` otherwise it returns `false`.
is_ok [BatResult] | `is_ok (Ok _)` is `true`, otherwise `false`.
is_prefix [BatSubstring] | `is_prefix s1 s2` is true if `s1` is a prefix of `s2`.
is_relative [BatPathGen.PathType] |
is_set [BatOptParse.Opt] | Find out if the option has a value (either by default or from the command line).
is_some [BatOption] | `is_some (Some x)` returns `true` otherwise it returns `false`.
is_special [BatFloat] | `is_special f` returns `true` if `f` is `nan` or `+/- infinity`, `false` otherwise.
is_symbol [BatChar] | Determine if a character represents a (OCaml-style) symbol.
is_uppercase [BatChar] | Determine if a character is uppercase ASCII.
is_uppercase_latin1 [BatChar] | Determine if a character is uppercase Latin 1.
is_whitespace [BatChar] | Determine if a character is a whitespace.
isatty [BatUnix] | Return `true` if the given file descriptor refers to a terminal or console window, `false` otherwise.
isdef [BatGlobal] | Return `true` if the global value has been set.
iter [BatVect.RANDOMACCESS] |
iter [BatVect.Make] | `iter f r` applies `f` to all the elements in the `r` vect, in order.
iter [BatVect] | `iter f r` applies `f` to all the elements in the `r` vect, in order.
iter [BatUTF8] | `iter f s` applies `f` to all Unicode characters in `s`.
iter [BatText] | `iter f r` applies `f` to all the characters in the `r` rope, in order.
iter [BatSubstring] | `iter f sus` applies `f` to all characters of `sus`, from left to right.
iter [BatString.Cap] |
iter [BatString] | `String.iter f s` applies function `f` in turn to all the characters of `s`.
iter [BatStream.StreamLabels] |
iter [BatStream] | `Stream.iter f s` scans the whole stream s, applying function `f` in turn to each stream element encountered.
iter [BatStack] | `iter f s` applies `f` in turn to all elements of `s`, from the element at the top of the stack to the element at the bottom of the stack.
iter [BatSet.PSet] | `iter f s` applies `f` in turn to all elements of `s`.
iter [BatSet.S.Labels] |
iter [BatSet.S] | `iter f s` applies `f` in turn to all elements of `s`.
iter [BatSet] | `iter f s` applies `f` in turn to all elements of `s`.
iter [BatSeq] | `iter f s` applies `f` to all the elements of the sequence.
iter [BatRefList] | Apply the given function to all elements of the ref list, in respect with the order of the list
iter [BatQueue] | `iter f q` applies `f` in turn to all elements of `q`, from the least recently entered to the most recently entered.
iter [BatPervasives] | Imperative loop on an enumeration.
iter [BatPathGen.StringType] |
iter [BatMultiPMap] | `iter f m` applies `f` to all bindings in map `m`.
iter [BatMultiMap] | `iter f m` applies `f` to all bindings in map `m`.
iter [BatMap.PMap] | `iter f m` applies `f` to all bindings in map `m`.
iter [BatMap.S.Labels] |
iter [BatMap.S] | `iter f m` applies `f` to all bindings in map `m`.
iter [BatMap] | `iter f m` applies `f` to all bindings in map `m`.
iter [BatList.Labels] |
iter [BatList] | `List.iter f [a1; ...; an]` applies function `f` in turn to `a1; ...; an`.
iter [BatLazyList.Labels] |
iter [BatLazyList] | Eager iteration
iter [BatInnerWeaktbl] | `Weaktbl.iter f tbl` applies `f` to all bindings in table `tbl`.
iter [BatISet] | `iter f t` calls `f` once for each element of `t`
iter [BatIMap] | `iter f t` calls `f` on every binding
iter [BatHashtbl.Cap.Labels] |
iter [BatHashtbl.Cap] |
iter [BatHashtbl.S.Labels] |
iter [BatHashtbl.S] |
iter [BatHashtbl.Labels] |
iter [BatHashtbl] | `Hashtbl.iter f tbl` applies `f` to all bindings in table `tbl`.
iter [BatHashcons.Table] | `iter f tab` applies `f` to every live hashed object in the table `tab`.
iter [BatFingerTree.S] | `iter` is equivalent to `List.iter`.
iter [BatEnum.Labels] |
iter [BatEnum] | `iter f e` calls the function `f` with each elements of `e` in turn.
iter [BatDynArray] | `iter f darr` calls the function `f` on every element of `darr`.
iter [BatDllist] | `iter f n` Apply `f` to every element in the list, starting at `n`.
iter [BatDeque] | `iter f dq` calls `f x` on each element `x` of `dq`.
iter [BatBigarray.Genarray] | `iter f a` applies function `f` in turn to all the elements of `a`.
iter [BatAvlTree] |
iter [BatArray.Cap.Labels] |
iter [BatArray.Cap] |
iter [BatArray.Labels] |
iter [BatArray] | `Array.iter f a` applies function `f` in turn to all the elements of `a`.
iter2 [BatList.Labels] |
iter2 [BatList] | `List.iter2 f [a0; a1; ...; an] [b0; b1; ...; bn]` calls in turn `f a0 b0; f a1 b1; ...; f an bn`.
iter2 [BatLazyList.Labels] |
iter2 [BatLazyList] | `iter2 f [^ a0; ...; an ^] [^ b0; ...; bn ^]` calls in turn `f a0 b0; ...; f an bn`.
iter2 [BatEnum.Labels] |
iter2 [BatEnum] | `iter2 f e1 e2` calls the function `f` with the next elements of `e1` and `e2` repeatedly until one of the two enumerations ends.
iter2 [BatArray.Cap.Labels] |
iter2 [BatArray.Cap] |
iter2 [BatArray.Labels] |
iter2 [BatArray] | `Array.iter2 f [|a0; a1; ...; an|] [|b0; b1; ...; bn|]` performs calls `f a0 b0; f a1 b1; ...; f an bn` in that order.
iter2i [BatEnum.Labels] |
iter2i [BatEnum] |
iter2i [BatArray.Cap.Labels] |
iter2i [BatArray.Cap] |
iter2i [BatArray.Labels] |
iter2i [BatArray] | `Array.iter2i f [|a0; a1; ...; an|] [|b0; b1; ...; bn|]` performs calls `f 0 a0 b0; f 1 a1 b1; ...; f n an bn` in that order.
iter_range [BatISet] | `iter_range f t` calls `f` once for each contiguous range of `t`.
iter_range [BatIMap] | `iter_range f t` calls `f` on every contiguous range.
iter_right [BatFingerTree.S] | `iter_right` is equivalent to `List.iter o List.rev`.
iteri [BatVect.Make] | Operates like iter, but also passes the index of the character to the given function.
iteri [BatVect] | Operates like iter, but also passes the index of the character to the given function.
iteri [BatText] | Operates like `iter`, but also passes the index of the character to the given function.
iteri [BatSubstring] | Same as `BatSubstring.iter`, but the function is applied to the index of the element as first argument (counting from 0), and the character itself as second argument.
iteri [BatString] | Same as `String.iter`, but the function is applied to the index of the element as first argument (counting from 0), and the character itself as second argument.
iteri [BatPathGen.StringType] |
iteri [BatList.Labels] |
iteri [BatList] | `iteri f l` will call `(f 0 a0);(f 1 a1) ... (f n an)` where `a0..an` are the elements of the list `l`.
iteri [BatLazyList.Labels] |
iteri [BatLazyList] | Eager iteration, with indices
iteri [BatEnum.Labels] |
iteri [BatEnum] |
iteri [BatDynArray] | `iter f darr` calls the function `f` on every element of `darr`.
iteri [BatDeque] | `iteri f dq` calls `f n x` on each element `x` of `dq`.
iteri [BatBigarray.Genarray] | Same as `BatBigarray.Genarray.iter`, but the function is applied to the index of the element as the first argument, and the element itself as the second argument.
iteri [BatArray.Cap.Labels] |
iteri [BatArray.Cap] |
iteri [BatArray.Labels] |
iteri [BatArray] | Same as `Array.iter`, but the function is applied to the index of the element as first argument, and the element itself as second argument.
J
join [BatText] | Same as `BatText.concat`
join [BatString.Cap] |
join [BatString] | Same as `BatString.concat`
join [BatPathGen.PathType] | Create a path from given components.
junk [BatStream] | Remove the first element of the stream, possibly unfreezing it before.
junk [BatPervasives] | `junk e` removes the first element from the enumeration, if any.
junk [BatEnum] | `junk e` removes the first element from the enumeration, if any.
K
kbprintf [BatPrintf] | Same as `bprintf`, but instead of returning immediately, passes the buffer to its first argument at the end of printing.
kbprintf2 [BatPrintf] | Same as `bprintf2`, but instead of returning immediately, passes the buffer to its first argument at the end of printing.
keep [BatDynArray] | `keep p darr` removes in place all the element `x` of `darr` such that `p x = false`
keys [BatMap.PMap] | Return an enumeration of all the keys of a map.
keys [BatMap.S] | Return an enumeration of all the keys of a map.
keys [BatMap] | Return an enumeration of all the keys of a map.
keys [BatHashtbl.Cap] |
keys [BatHashtbl.S] |
keys [BatHashtbl] | Return an enumeration of all the keys of a hashtable.
keyword [BatGenlex.Languages.Make] |
kfprintf [BatPrintf] | Same as `fprintf`, but instead of returning immediately, passes the `output` to its first argument at the end of printing.
kfprintf [BatFormat] | Same as `fprintf` above, but instead of returning immediately, passes the formatter to its first argument at the end of printing.
kill [BatUnix] | `kill pid sig` sends signal number `sig` to the process with id `pid`.
kind [BatBigarray.Array3] | Return the kind of the given big array.
kind [BatBigarray.Array2] | Return the kind of the given big array.
kind [BatBigarray.Array1] | Return the kind of the given big array.
kind [BatBigarray.Genarray] | Return the kind of the given big array.
kprintf [BatPrintf] |
kprintf [BatFormat] | A deprecated synonym for `ksprintf`.
kscanf [BatScanf] | Same as `Scanf.bscanf`, but takes an additional function argument `ef` that is called in case of error: if the scanning process or some conversion fails, the scanning function aborts and calls the error handling function `ef` with the scanning buffer and the exception that aborted the scanning process.
ksprintf [BatPrintf] | Same as `sprintf` above, but instead of returning the string, passes it to the first argument.
ksprintf [BatFormat] | Same as `sprintf` above, but instead of returning the string, passes it to the first argument.
ksprintf2 [BatPrintf] | Same as `sprintf2` above, but instead of returning the string, passes it to the first argument.
kwd [BatGenlex.Languages.Make] | Accepts any identifier.
L
label [BatReturn] | `label f` creates a new label `x` and invokes `f x`.
label [BatParserCo] | Give a name to a parser, for debugging purposes.
last [BatVect.Make] | These return the first and last values in the vector
last [BatVect] | These return the first and last values in the vector
last [BatUTF8] | The position of the head of the last Unicode character.
last [BatSeq.Exceptionless] |
last [BatSeq] | Returns the last element of the sequence, or raise `Invalid_argument` if the sequence is empty.
last [BatRefList] | Returns the last element - O(n) or raises `Empty_list` if the ref list is empty
last [BatList.Exceptionless] | `last l` returns either `Some x` where `x` is the last element of the list, or `None` if the list is empty.
last [BatList] | Returns the last element of the list, or
last [BatLazyList] | Returns the last element of the list.
last [BatFingerTree.S] | `last t` returns `None` if `t` is empty, or `Some hd` otherwise, where `hd` is the last element of the sequence.
last [BatDynArray] | `last darr` returns the last element of `darr`.
last_exn [BatFingerTree.S] | `last_exn t` returns the last element of the sequence.
latin1 [BatCharParser] | Recognizes one lower- or upper-case Latin1 character, including accentuated characters.
layout [BatBigarray.Array3] | Return the layout of the given big array.
layout [BatBigarray.Array2] | Return the layout of the given big array.
layout [BatBigarray.Array1] | Return the layout of the given big array.
layout [BatBigarray.Genarray] | Return the layout of the given big array.
lazy_fold_right [BatLazyList] | Lazy fold_right `lazy_fold_right f (Cons (a0, Cons (a1, Cons (a2, nil)))) b` is `lazy (f a0 (lazy (f a1 (lazy (f a2 b)))))`.
lchop [BatText] | Returns the same rope but without the first character.
lchop [BatString.Cap] |
lchop [BatString] | Returns the same string but without the first `n` characters.
ldexp [BatFloat.Safe_float] | `ldexp x n` returns `x *. 2 ** n`.
ldexp [BatFloat] | `ldexp x n` returns `x *. 2 ** n`.
le_big_int [BatBig_int] |
le_num [BatNum] |
left [BatText] | `left r len` returns the rope containing the `len` first characters of `r`
left [BatString.Cap] |
left [BatString] | `left r len` returns the string containing the `len` first characters of `r`.
left [BatArray] | `left r len` returns the array containing the `len` first characters of `r`.
left_branch [BatAvlTree] |
length [BatVect.RANDOMACCESS] |
length [BatVect.Make] | Returns the length of the vect (`O(1)`).
length [BatVect] | Returns the length of the vect (`O(1)`).
length [BatUTF8] | `length s` returns the number of Unicode characters contained in s
length [BatText] | Returns the length of the rope (`O(1)`).
length [BatSubstring] | Equivalent to `BatSubstring.size`.
length [BatString.Cap] |
length [BatString] | Return the length (number of characters) of the given string.
length [BatStack] | Return the number of elements in a stack.
length [BatSeq] | Return the number of elements of the given sequence.
length [BatRefList] | Returns the number of elements - O(n)
length [BatQueue] | Return the number of elements in a queue.
length [BatPathGen.StringType] | Length - number of indexing units
length [BatList] | Return the length (number of elements) of the given list.
length [BatLazyList] | Return the length (number of elements) of the given list.
length [BatInnerWeaktbl] | `Weaktbl.length tbl` returns the number of bindings in `tbl`.
length [BatHashtbl.Cap] |
length [BatHashtbl.S] |
length [BatHashtbl] | `Hashtbl.length tbl` returns the number of bindings in `tbl`.
length [BatDynArray] | Return the number of elements in the array.
length [BatDllist] | Returns the length of the list.
length [BatBuffer] | Return the number of characters currently contained in the buffer.
length [BatArray.Cap] |
length [BatArray] | Return the length (number of elements) of the given array.
letter [BatPathGen.StringType.Parse] |
letter [BatCharParser] | Recognizes one lower- or upper-case ASCII character, including accentuated characters.
level [BatLog.Make_lev] |
level [BatLog.Easy] | Set this ref to the lowest level of log you want logged.
level_of_name [BatLogger] | `level_of_name str` returns the `level` associated with `str`.
lexeme [BatLexing] | `Lexing.lexeme lexbuf` returns the string matched by the regular expression.
lexeme_char [BatLexing] | `Lexing.lexeme_char lexbuf i` returns character number `i` in the matched string.
lexeme_end [BatLexing] | `Lexing.lexeme_end lexbuf` returns the offset in the input stream of the character following the last character of the matched string.
lexeme_end_p [BatLexing] | Like `lexeme_end`, but return a complete `position` instead of an offset.
lexeme_start [BatLexing] | `Lexing.lexeme_start lexbuf` returns the offset in the input stream of the first character of the matched string.
lexeme_start_p [BatLexing] | Like `lexeme_start`, but return a complete `position` instead of an offset.
lift [BatPathGen.StringType] | Convert from UTF-8 string of primitive `string` type.
lift_char [BatPathGen.StringType] | Convert Latin-1 character to `tchar`.
line_comment [BatGenlex.Languages.Make] |
line_comment_start [BatGenlex.Languages.Definition] |
lines_of [BatText] | offer the lines of a UTF-8 encoded input as an enumeration
lines_of [BatIO] | Read an enumeration of LF or CRLF terminated strings.
lines_of [BatFile] | `line_of name` reads the contents of file `name` as an enumeration of lines.
lines_of2 [BatIO] |
link [BatUnix] | `link source dest` creates a hard link named `dest` to the file named `source`.
listen [BatUnix] | Set up a socket for receiving connection requests.
ln10 [BatFloat] | `log 10`
ln2 [BatFloat] | `log 2`
localtime [BatUnix] | Convert a time in seconds, as returned by `Unix.time`, into a date and a time.
lock [BatUnix] | A lock used to synchronize internal operations.
lock [BatRMutex] | Lock the given mutex.
lock [BatPervasives] | A lock used to synchronize internal operations.
lock [BatInnerPervasives] |
lock [BatIO] | A lock used to synchronize internal operations.
lock [BatConcurrent.BaseLock] |
lock [BatConcurrent.Lock] |
lock_factory [BatIO] | A factory used to create locks.
lockf [BatUnix] | `lockf fd cmd size` puts a lock on a region of the file opened as `fd`.
log [BatLogger] | `log logger level event_fun` raises a log event if if the specified level is currently enabled for the logger.
log [BatLog.Make_lev] |
log [BatLog.Easy] | `log lev msg` logs the message `msg` if the current logging level is `lev` or lower.
log [BatLog.Make] | `print s` logs the message s, returning unit.
log [BatLog] | `log s` logs the message s, returning unit.
log [BatFloat.Safe_float] | Natural logarithm.
log [BatFloat] | Natural logarithm.
log [BatComplex] | Natural logarithm (in base `e`).
log10 [BatFloat.Safe_float] | Base 10 logarithm.
log10 [BatFloat] | Base 10 logarithm.
log10e [BatFloat] | `log10 e`
log2e [BatFloat] | `Math.log2 e`
log_enable [BatLogger] | `log_enable logger level` enables a log level for a logger.
log_enabled [BatLogger] | `log_enabled logger level` returns true if the specified level is currently enabled for the logger.
log_level [BatLogger] | `log_level logger` returns the currently enabled level for a logger.
log_name [BatLogger] | `log_name logger` returns the name of the logger.
logand [BatNativeint] | Bitwise logical and.
logand [BatInt64] | Bitwise logical and.
logand [BatInt32] | Bitwise logical and.
logf [BatLog.Make_lev] |
logf [BatLog.Easy] | As `log`, but instead of a string message, a printf format is allowed with whatever arguments are appropriate.
logf [BatLog.Make] | As `Printf.printf`, only the message is printed to the logging output and prefixed with status information per the current flags and the currently set prefix.
logf [BatLog] | As `Printf.printf`, only the message is printed to the logging output and prefixed with status information per the current flags and the currently set prefix.
lognot [BatNativeint] | Bitwise logical negation
lognot [BatInt64] | Bitwise logical negation
lognot [BatInt32] | Bitwise logical negation
logor [BatNativeint] | Bitwise logical or.
logor [BatInt64] | Bitwise logical or.
logor [BatInt32] | Bitwise logical or.
logxor [BatNativeint] | Bitwise logical exclusive or.
logxor [BatInt64] | Bitwise logical exclusive or.
logxor [BatInt32] | Bitwise logical exclusive or.
look [BatUTF8] | `look s i` returns the Unicode character of the location `i` in the string `s`.
lookahead [BatParserCo] | `lookahead p` behaves as `maybe p` but without consuming anything
lookup [BatFingerTree.Generic] | `lookup p t`, when `p` is monotonic, returns the first element of the sequence for which the measure of its predecessors in the sequence (itself included) satisfies `p`.
lookup_tables [BatOo.Internal] |
lowercase [BatString.Cap] |
lowercase [BatString] | Return a copy of the argument, with all uppercase letters translated to lowercase, including accented letters of the ISO Latin-1 (8859-1) character set.
lowercase [BatCharParser] | Recognizes one lower-case ASCII character, including accentuated characters.
lowercase [BatChar] | Convert the given character to its equivalent lowercase character.
lowercase_latin1 [BatCharParser] | Recognizes one lower-case Latin-1 character, including accentuated characters.
lru_cache [BatCache] |
lseek [BatUnix.LargeFile] |
lseek [BatUnix] | Set the current position for a file descriptor
lstat [BatUnix.LargeFile] |
lstat [BatUnix] | Same as `Unix.stat`, but in case the file is a symbolic link, return the information for the link itself.
lt_big_int [BatBig_int] |
lt_num [BatNum] |
M
major [BatGc] | Do a minor collection and finish the current major collection cycle.
major_slice [BatGc] | Do a minor collection and a slice of major collection.
make [BatVect.RANDOMACCESS] |
make [BatVect.Make] | `make i c` returns a vect of length `i` whose elements are all equal to `c`; it is similar to Array.make
make [BatVect] | `make i c` returns a vect of length `i` whose elements are all equal to `c`; it is similar to Array.make
make [BatText] | `make i c` returns a rope of length `i` consisting of `c` chars; it is similar to String.make
make [BatSubstring] |
make [BatString.Cap] |
make [BatString] | `String.make n c` returns a fresh string of length `n`, filled with the character `c`.
make [BatSeq] | `make n e` returns the sequence of length `n` where all elements are `e`
make [BatRandom.Incubator.Private_state_enums.State] | Create a new state and initialize it with the given seed.
make [BatRandom.State] | Create a new state and initialize it with the given seed.
make [BatRMutex] | Create a new abstract lock based on Reentrant Mutexes.
make [BatOptParse.OptParser] | Creates a new option parser with the given options.
make [BatMutex] | Create a new abstract lock based on Mutexes.
make [BatList] | Similar to `String.make`, `make n x` returns a list containing `n` elements `x`.
make [BatLazyList] | Similar to `String.make`, `make n x` returns a list containing `n` elements `x`.
make [BatEnum] | This function creates a fully defined enumeration.
make [BatDynArray] | `make count` returns an array with some memory already allocated so up to `count` elements can be stored into it without resizing.
make [BatConcurrent.Lock] |
make [BatBounded.S] | `make x` will return a value of type `BatBounded.S.t` derived from `x`.
make [BatArray.Cap.Labels] |
make [BatArray.Cap] |
make [BatArray] | `Array.make n x` returns a fresh array of length `n`, initialized with `x`.
make_class [BatOo.Internal] |
make_class_store [BatOo.Internal] |
make_dbg_formatter [BatLogger] | `make_dbg_formatter oc` constructs a debug formatter from an output channel.
make_decoding_table [BatBase64] | Create a valid decoding table from an encoding one.
make_formatter [BatFormat] | `make_formatter out flush` returns a new formatter that writes according to the output function `out`, and the flushing function `flush`.
make_ht [BatCache] | Make a manual cache backed by a hashtable.
make_lexer [BatGenlex] | Construct the lexer function.
make_log [BatLogger] | `make_log name` returns a new logger.
make_logger [BatLog] |
make_map [BatCache] | Make a manual cache for function `~gen` backed by a Set.t.
make_matrix [BatArray.Cap.Labels] |
make_matrix [BatArray.Cap] |
make_matrix [BatArray.Labels] |
make_matrix [BatArray] | `Array.make_matrix dimx dimy e` returns a two-dimensional array (an array of arrays) with first dimension `dimx` and second dimension `dimy`.
make_self_init [BatRandom.Incubator.Private_state_enums.State] | Create a new state and initialize it with a system-dependent low-entropy seed.
make_self_init [BatRandom.State] | Create a new state and initialize it with a system-dependent low-entropy seed.
make_std_formatter [BatLogger] | `make_std_formatter oc` constructs a formatter from an output channel.
make_tree [BatAvlTree] |
map [BatVect.RANDOMACCESS] |
map [BatVect.Make] | `map f v` returns a vect isomorphic to `v` where each element of index `i` equals `f (get v i)`.
map [BatVect] | `map f v` returns a vect isomorphic to `v` where each element of index `i` equals `f (get v i)`.
map [BatTuple.Tuple5] |
map [BatTuple.Tuple4] |
map [BatTuple.Tuple3] |

map [BatTuple.Tuple2]

Equivalent to `BatPervasives.`

| (***)

``.

map [BatText] | `map f s` returns a rope where all characters `c` in `s` have been replaced by `f c`.
map [BatString.Cap] |
map [BatString] | `String.map f s` applies function `f` in turn to all the characters of `s` and stores the results in a new string that is returned.
map [BatStream.StreamLabels] |
map [BatStream] | `map f stream` applies `f` in turn to elements from `stream` and return the results as a stream in the same order.
map [BatSet.PSet] | `map f x` creates a new set with elements `f a0`, `f a1`...
map [BatSet.S.Labels] |
map [BatSet.S] | `map f x` creates a new set with elements `f a0`, `f a1`...
map [BatSet] | `map f x` creates a new set with elements `f a0`, `f a1`...
map [BatSeq] | `map f s` returns the sequence where elements are elements of `s` mapped with `f`.
map [BatRefList] | Apply a function to all elements and return the ref list constructed with the function returned values
map [BatPervasives] | Transformation loop on an enumeration, used to build an enumeration from another enumeration.
map [BatPathGen.PathType] | Map a path through a function that operates on separate components.
map [BatOption.Labels] |
map [BatOption] | `map f (Some x)` returns `Some (f x)` and `map f None` returns `None`.
map [BatMultiPMap] | `map f m` returns a map with same domain as `m`, where the associated value `a` of all bindings of `m` has been replaced by the result of the application of `f` to `a`.
map [BatMultiMap] | `map f m` returns a map with same domain as `m`, where the associated value `a` of all bindings of `m` has been replaced by the result of the application of `f` to `a`.
map [BatMap.PMap] | `map f m` returns a map with same domain as `m`, where the associated value `a` of all bindings of `m` has been replaced by the result of the application of `f` to `a`.
map [BatMap.S.Labels] |
map [BatMap.S] | `map f m` returns a map with same domain as `m`, where the associated value `a` of all bindings of `m` has been replaced by the result of the application of `f` to `a`.
map [BatMap] | `map f m` returns a map with same domain as `m`, where the associated value `a` of all bindings of `m` has been replaced by the result of the application of `f` to `a`.
map [BatList.Labels] |
map [BatList] | `map f [a0; a1; ...; an]` applies function `f` to `a0, a1, ..., an`, and builds the list `[f a0; f a1; ...; f an]` with the results returned by `f`.
map [BatLazyList.Labels] |
map [BatLazyList] | Lazy map
map [BatInterfaces.Mappable] | `map f e` applies `f` to every element of `e` and returns the corresponding data structure
map [BatIMap] | Create a new map by modifying each `y` by the given function.
map [BatHashtbl.Cap.Labels] |
map [BatHashtbl.Cap] |
map [BatHashtbl.S.Labels] |
map [BatHashtbl.S] |
map [BatHashtbl.Labels] |
map [BatHashtbl] | `map f x` creates a new hashtable with the same keys as `x`, but with the function `f` applied to all the values
map [BatFingerTree.S] | `map` is equivalent to `List.map`.
map [BatEnum.Labels] |
map [BatEnum] | `map f e` returns an enumeration over `(f a0, f a1, ...)` where `a0,a1...` are the elements of `e`.
map [BatDynArray] | `map f darr` applies the function `f` to every element of `darr` and creates a dynamic array from the results - similar to `List.map` or `Array.map`.
map [BatDllist] | Allocate a new list, with entirely new nodes, whose values are the transforms of the values of the original list.
map [BatDeque] | `map f dq` returns a deque where every element `x` of `dq` has been replaces with `f x`.
map [BatBounded.S] | `map f x` applies `f` to `x`.
map [BatBigarray.Array3] | `Array3.map f a` applies function `f` to all the elements of `a`, and builds a `Bigarray.Array3.t` with the results returned by `f`.
map [BatBigarray.Array2] | `Array2.map f a` applies function `f` to all the elements of `a`, and builds a `Bigarray.Array2.t` with the results returned by `f`.
map [BatBigarray.Array1] | `Array1.map f a` applies function `f` to all the elements of `a`, and builds a `Bigarray.Array1.t` with the results returned by `f`.
map [BatBigarray.Genarray] | `map f kind a` applies function `f` to all the elements of `a`, and builds a `Bigarray.t` of kind `kind` with the results returned by `f`.
map [BatArray.Cap.Labels] |
map [BatArray.Cap] |
map [BatArray.Labels] |
map [BatArray] | `Array.map f a` applies function `f` to all the elements of `a`, and builds an array with the results returned by `f`: `[| f a.(0); f a.(1); ...; f a.(Array.length a - 1) |]`.
map1 [BatTuple.Tuple5] |
map1 [BatTuple.Tuple4] |
map1 [BatTuple.Tuple3] |
map1 [BatTuple.Tuple2] | `map1 f (x,y)` returns (f x,y)
map2 [BatTuple.Tuple5] |
map2 [BatTuple.Tuple4] |
map2 [BatTuple.Tuple3] |
map2 [BatTuple.Tuple2] | `map2 f (x,y)` returns (x,f y)
map2 [BatStream.StreamLabels] |
map2 [BatStream] | `map2 f streama streamb` applies `f` in turn to elements of corresponding positions from `streama` and `streamb`.
map2 [BatList.Labels] |
map2 [BatList] | `List.map2 f [a0; a1; ...; an] [b0; b1; ...; bn]` is `[f a0 b0; f a1 b1; ...; f an bn]`.
map2 [BatLazyList.Labels] |
map2 [BatLazyList] | `map2 f [^ a0; a1; ...^] [^ b0; b1; ... ^]` is `[^ f a0 b0; f a1 b1; ... ^]`.
map2 [BatBounded.S] | `map f x y` applies `f` to `x` and `y`.
map2 [BatArray] | As `Array.map` but on two arrays.
map2_exn [BatBounded.S] | `map f x y` applies `f` to `x` and `y`.
map3 [BatTuple.Tuple5] |
map3 [BatTuple.Tuple4] |
map3 [BatTuple.Tuple3] |
map4 [BatTuple.Tuple5] |
map4 [BatTuple.Tuple4] |
map5 [BatTuple.Tuple5] |
map_comp [BatOrd] |
map_default [BatResult] | `map_default d f r` evaluates to `d` if `r` is `Bad` else `f x` when `r` is `Ok x`
map_default [BatOption.Labels] |
map_default [BatOption] | `map_default f x (Some v)` returns `f v` and `map_default f x None` returns `x`.
map_default_delayed [BatOption] | Like `BatOption.map_default`, but the default value is passed as a thunk that is only computed if needed.
map_eq [BatOrd] |
map_exn [BatBounded.S] | `map_exn f x` applies `f` to `x`.
map_ext [BatPathGen.PathType] | `map_ext fu path` returns `path` but with the name with extension given by `fu (``BatPathGen.PathType.ext` `path)`.
map_file [BatBigarray.Array3] | Memory mapping of a file as a three-dimensional big array.
map_file [BatBigarray.Array2] | Memory mapping of a file as a two-dimensional big array.
map_file [BatBigarray.Array1] | Memory mapping of a file as a one-dimensional big array.
map_file [BatBigarray.Genarray] | Memory mapping of a file as a big array.
map_inplace [BatHashtbl.Cap.Labels] |
map_inplace [BatHashtbl.Cap] |
map_inplace [BatHashtbl.S.Labels] |
map_inplace [BatHashtbl.S] |
map_inplace [BatHashtbl.Labels] |
map_inplace [BatHashtbl] | `map_inplace f x` replace all values currently bound in `x` by `f` applied to each value.
map_list [BatRefList] | Apply a function to all elements and return the list constructed with the function returned values
map_name [BatPathGen.PathType] | `map_name fu path` returns `path` with the name replaced by `fu (``BatPathGen.PathType.name` `path)`.
map_ord [BatOrd] | These functions extend an existing equality/comparison/ordering to a new domain through a mapping function.
map_range [BatIMap] | Create a new map by modifying each `y` using the given function.
map_right [BatFingerTree.S] | `map_right` is equivalent to `List.rev o List.map o List.rev`.
map_to_set [BatIMap] | `map_to_set p t` returns the set of keys of `t` where `p` evaluates as true
mapi [BatVect.Make] | Same as `map`, but the function is applied to the index of the element as first argument, and the element itself as second argument.
mapi [BatVect] | Same as `BatVect.map`, but the function is applied to the index of the element as first argument, and the element itself as second argument.
mapi [BatMultiPMap] | Same as `map`, but the function receives as arguments both the key and the associated value for each binding of the map.
mapi [BatMultiMap] | Same as `map`, but the function receives as arguments both the key and the associated value for each binding of the map.
mapi [BatMap.PMap] | Same as `map`, but the function receives as arguments both the key and the associated value for each binding of the map.
mapi [BatMap.S.Labels] |
mapi [BatMap.S] | Same as `Map.S.map`, but the function receives as arguments both the key and the associated value for each binding of the map.
mapi [BatMap] | Same as `map`, but the function receives as arguments both the key and the associated value for each binding of the map.
mapi [BatList.Labels] |
mapi [BatList] | `mapi f l` will build the list containing `(f 0 a0);(f 1 a1) ... (f n an)` where `a0..an` are the elements of the list `l`.
mapi [BatLazyList.Labels] |
mapi [BatLazyList] | Lazy map, with indices
mapi [BatIMap] | Create a new map by computing new values based on key and value of the existing bindings.
mapi [BatEnum.Labels] |
mapi [BatEnum] | `mapi` is similar to `map` except that `f` is passed one extra argument which is the index of the element in the enumeration, starting from 0 : mapi f e returns an enumeration over `(f 0 a0, f 1 a1, ...)` where `a0,a1...` are the elements of `e`.
mapi [BatDynArray] | `mapi f darr` applies the function `f` to every element of `darr` and creates a dynamic array from the results - similar to `List.mapi` or `Array.mapi`.
mapi [BatDeque] | `map f dq` returns a deque where every element `x` of `dq` has been replaces with `f n x`, where `n` is the position of `x` from the front of `dq`.
mapi [BatBigarray.Array1] | Same as `Bigarray.Array1.map`, but the function is applied to the index of the element as the first argument, and the element itself as the second argument.
mapi [BatBigarray.Genarray] | Same as `BatBigarray.Genarray.map`, but the function is applied to the index of the coordinates as the first argument, and the element itself as the second argument.
mapi [BatArray.Cap.Labels] |
mapi [BatArray.Cap] |
mapi [BatArray.Labels] |
mapi [BatArray] | Same as `Array.map`, but the function is applied to the index of the element as first argument, and the element itself as second argument.
mapij [BatBigarray.Array2] | Same as `Bigarray.Array2.map`, but the function is applied to the index of the element as the first two arguments, and the element itself as the third argument.
mapijk [BatBigarray.Array3] | Same as `Bigarray.Array3.map`, but the function is applied to the index of the element as the first three arguments, and the element itself as the fourth argument.
mapn [BatTuple.Tuple5] | Like `BatTuple.Tuple5.map` but specialized for tuples with elements of the same type.
mapn [BatTuple.Tuple4] | Like `BatTuple.Tuple4.map` but specialized for tuples with elements of the same type.
mapn [BatTuple.Tuple3] | Like `BatTuple.Tuple3.map` but specialized for tuples with elements of the same type.
mapn [BatTuple.Tuple2] | Like `BatTuple.Tuple2.map` but specialized for tuples with elements of the same type.
max [BatSeq.Exceptionless] |
max [BatSeq] | `max s` returns the largest value in `s` as judged by `Pervasives.compare`
max [BatOrd] | `max ord` will choose the biggest element according to `ord`.
max [BatList] | `max l` returns the largest value in `l` as judged by `Pervasives.compare`
max [BatInt] | The maximum of two integers.
max [BatFloat] |
max [BatArray] | `max a` returns the largest value in `a` as judged by `Pervasives.compare`
max_array_length [BatteriesConfig] |
max_array_length [BatSys] | Maximum length of a normal array.
max_big_int [BatBig_int] | Return the greater of its two arguments.
max_binding [BatMap.PMap] | returns the binding with the largest key
max_binding [BatMap.S] | return the `(key,value)` pair with the largest key
max_binding [BatMap] | returns the binding with the largest key
max_comp [BatOrd] |
max_elt [BatSet.PSet] | returns the largest element of the set.
max_elt [BatSet.S.Exceptionless] |
max_elt [BatSet.S] | Same as `Set.S.min_elt`, but returns the largest element of the given set.
max_elt [BatSet] | returns the largest element of the set.
max_elt [BatISet] | Returns the maximum element in the set
max_int [BatNativeint] | The greatest representable native integer, either 231 - 1 on a 32-bit platform, or 263 - 1 on a 64-bit platform.
max_int [BatInt64] | The greatest representable 64-bit integer, 263 - 1.
max_int [BatInt32] | The greatest representable 32-bit integer, 231 - 1.
max_length [BatVect.Make] | Maximum length of the vect.
max_length [BatVect] | Maximum length of the vect.
max_length [BatText] | Maximum length of the rope (number of UTF-8 characters).
max_num [BatNumber.Bounded] |
max_num [BatNum] |
max_num [BatNativeint] |
max_num [BatInt32] |
max_num [BatInt.Safe_int] | The greatest representable integer, which is either 230-1 or 262-1.
max_num [BatInt] | The greatest representable integer, which is either 230-1 or 262-1.
max_num [BatFloat.Safe_float] |
max_num [BatFloat] |
max_num [BatBool] |
max_ord [BatOrd] |
max_string_length [BatteriesConfig] |
max_string_length [BatSys] | Maximum length of a string.
may [BatOption.Labels] |
may [BatOption] | `may f (Some x)` calls `f x` and `may f None` does nothing.
maybe [BatParserCo] | Accept an optional argument.
measure [BatFingerTree.Generic] | `measure m` gives the measure of the whole tree, whose meaning depends on the measure chosen.
mem [BatVect.Make] | `mem m a` is true if and only if `m` is equal to an element of `a`.
mem [BatVect] | `mem m a` is true if and only if `m` is equal to an element of `a`.
mem [BatSet.PSet] | `mem x s` tests whether `x` belongs to the set `s`.
mem [BatSet.S] | `mem x s` tests whether `x` belongs to the set `s`.
mem [BatSet] | `mem x s` tests whether `x` belongs to the set `s`.
mem [BatSeq] | `mem a l` is true if and only if `a` is equal to an element of `l`.
mem [BatMultiPMap] | `mem x m` returns `true` if `m` contains at least a binding for `x`, and `false` otherwise.
mem [BatMultiMap] | `mem x m` returns `true` if `m` contains at least a binding for `x`, and `false` otherwise.
mem [BatMap.PMap] | `mem x m` returns `true` if `m` contains a binding for `x`, and `false` otherwise.
mem [BatMap.S] | `mem x m` returns `true` if `m` contains a binding for `x`, and `false` otherwise.
mem [BatMap] | `mem x m` returns `true` if `m` contains a binding for `x`, and `false` otherwise.
mem [BatList] | `mem a l` is true if and only if `a` is equal to an element of `l`.
mem [BatLazyList] | `mem x l` determines if `x` is part of `l`.
mem [BatInnerWeaktbl] | `Weaktbl.mem tbl x` checks if `x` is bound in `tbl`.
mem [BatISet] | test whether a given int is a member of the set
mem [BatIMap] | Test whether there is a binding from the given int
mem [BatHashtbl.Cap] |
mem [BatHashtbl.S] |
mem [BatHashtbl] | `Hashtbl.mem tbl x` checks if `x` is bound in `tbl`.
mem [BatBitSet] | `mem s n` returns true if nth-bit in the bitset `s` is set, or false otherwise.
mem [BatArray.Cap] |
mem [BatArray] | `mem m a` is true if and only if `m` is equal to an element of `a`.
mem_assoc [BatList] | Same as `List.assoc`, but simply return true if a binding exists, and false if no bindings exist for the given key.
mem_assoc [BatLazyList] | As `BatLazyList.assoc` but simply returns `true` if a binding exists, `false` otherwise.
mem_assq [BatList] | Same as `List.mem_assoc`, but uses physical equality instead of structural equality to compare keys.
mem_assq [BatLazyList] | As `BatLazyList.mem_assoc` but with physical equality.
memq [BatVect.Make] | Same as `Vect.mem` but uses physical equality instead of structural equality to compare vect elements.
memq [BatVect] | Same as `Vect.mem` but uses physical equality instead of structural equality to compare vect elements.
memq [BatList] | Same as `List.mem`, but uses physical equality instead of structural equality to compare list elements.
memq [BatLazyList] | As `mem`, but with physical equality
memq [BatArray.Cap] |
memq [BatArray] | Same as `Array.mem` but uses physical equality instead of structural equality to compare array elements.
merge [BatStream.StreamLabels] |
merge [BatStream] | `merge test (streama, streamb)` merge the elements from `streama` and `streamb` into a single stream.
merge [BatMap.PMap] | `merge f m1 m2` computes a map whose keys is a subset of keys of `m1` and of `m2`.
merge [BatMap.S] | `merge f m1 m2` computes a map whose keys is a subset of keys of `m1` and of `m2`.
merge [BatMap] | `merge f m1 m2` computes a map whose keys is a subset of keys of `m1` and of `m2`.
merge [BatList.Labels] |
merge [BatList] | Merge two lists: Assuming that `l1` and `l2` are sorted according to the comparison function `cmp`, `merge cmp l1 l2` will return a sorted list containting all the elements of `l1` and `l2`.
merge [BatIMap] |
merge [BatHeap.H] | 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 [BatMap.PMap] | Same as merge, but assumes the comparison function of both maps are equal.
mid [BatInt] | Midpoint function; `mid a b` returns `floor((a+b)/2)`, but done correctly to compensate for numeric overflows.
min [BatSeq.Exceptionless] |
min [BatSeq] | `min s` returns the smallest value in `s` as judged by `Pervasives.compare`
min [BatOrd] | `min ord` will choose the smallest element, according to `ord`.
min [BatList] | `min l` returns the smallest value in `l` as judged by `Pervasives.compare`
min [BatInt] | The minimum of two integers.
min [BatFloat] |
min [BatArray] | `min a` returns the smallest value in `a` as judged by `Pervasives.compare`
min_big_int [BatBig_int] | Return the smaller of its two arguments.
min_binding [BatMap.PMap] | returns the binding with the smallest key
min_binding [BatMap.S] | return the (`key,value`) pair with the smallest key
min_binding [BatMap] | returns the binding with the smallest key
min_comp [BatOrd] |
min_elt [BatSet.PSet] | returns the smallest element of the set.
min_elt [BatSet.S.Exceptionless] |
min_elt [BatSet.S] | Return the smallest element of the given set (with respect to the `Ord.compare` ordering).
min_elt [BatSet] | returns the smallest element of the set.
min_elt [BatISet] | Returns the minimum element in the set
min_int [BatNativeint] | The greatest representable native integer, either -231 on a 32-bit platform, or -263 on a 64-bit platform.
min_int [BatInt64] | The smallest representable 64-bit integer, -263.
min_int [BatInt32] | The smallest representable 32-bit integer, -231.
min_max [BatList] | `min_max l` returns the pair (smallest, largest) from `l` as judged by `Pervasives.compare` (by default).
min_num [BatNumber.Bounded] |
min_num [BatNum] |
min_num [BatNativeint] |
min_num [BatInt32] |
min_num [BatInt.Safe_int] | The smallest representable integer, -230 or 262.
min_num [BatInt] | The smallest representable integer, -230 or -262.
min_num [BatFloat.Safe_float] |
min_num [BatFloat] |
min_num [BatBool] |
min_ord [BatOrd] |
minor [BatGc] | Trigger a minor collection.
minus_big_int [BatBig_int] | Unary negation.
minus_num [BatNum] |
minus_one [BatNativeint] | The native integer -1.
minus_one [BatInt64] | The 64-bit integer -1.
minus_one [BatInt32] | The 32-bit integer -1.
minus_one [BatInt.Safe_int] | The integer `-1`.
minus_one [BatInt] | The integer `-1`.
mkdir [BatUnix] | Create a directory with the given permissions.
mkfifo [BatUnix] | Create a named pipe with the given permissions.
mktime [BatUnix] | Convert a date and time, specified by the `tm` argument, into a time in seconds, as returned by `Unix.time`.
mod_big_int [BatBig_int] | Euclidean modulus of two big integers.
mod_num [BatNum] |
modf [BatFloat.Safe_float] | `modf f` returns the pair of the fractional and integral part of `f`.
modf [BatFloat] | `modf f` returns the pair of the fractional and integral part of `f`.
modify [BatVect.Make] | `modify v n f` is equivalent to `set v n (f (get v n))`, but more efficient.
modify [BatVect] | `modify v n f` is equivalent to `set v n (f (get v n))`, but more efficient.
modify [BatMultiPMap] | `modify x f m` replaces the binding for `x` with `f` applied to these values.
modify [BatMultiMap] | `modify x f m` replaces the binding for `x` with `f` applied to these values.
modify [BatMap.PMap] | `modify k f m` replaces the previous binding for `k` with `f` applied to that value.
modify [BatMap.S] | `modify k f m` replaces the previous binding for `k` with `f` applied to that value.
modify [BatMap] | `modify k f m` replaces the previous binding for `k` with `f` applied to that value.
modify [BatList] | `modify a f l` returns the same list as `l` but with value associated to key `a` replaced with `f a`.
modify [BatIMap] | `modify x f t` replaces the `y` that is bound to `x` in `t` by `f y`.
modify [BatHashtbl.Cap.Exceptionless] |
modify [BatHashtbl.S.Labels] |
modify [BatHashtbl.S.Exceptionless] |
modify [BatHashtbl.S] |
modify [BatHashtbl.Labels] |
modify [BatHashtbl.Exceptionless] |
modify [BatHashtbl] | `Hashtbl.modify k f tbl` replaces the first binding for `k` in `tbl` with `f` applied to that value.
modify [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 [BatMultiPMap] | `modify_def dfl x f m` performs as `modify x f m` but it adds `f dfl` in `m` instead of raising `Not_found` if `x` was unbound.
modify_def [BatMultiMap] | `modify_def dfl x f m` performs as `modify x f m` but it adds `f dfl` in `m` instead of raising `Not_found` if `x` was unbound.
modify_def [BatMap.PMap] | `modify_def v0 k f m` replaces the previous binding for `k` with `f` applied to that value.
modify_def [BatMap.S] | `modify_def v0 k f m` replaces the previous binding for `k` with `f` applied to that value.
modify_def [BatMap] | `modify_def v0 k f m` replaces the previous binding for `k` with `f` applied to that value.
modify_def [BatList] | `modify_def dfl a f l` performs as `modify a f l` except that it add an association from `a` to `f dfl` instead of raising `Not_found`.
modify_def [BatIMap] | `modify_def dft x f t` does the same as `modify x f t` but binds `x` to `f dft` if `x` was not bound.
modify_def [BatHashtbl.S.Labels] |
modify_def [BatHashtbl.S] |
modify_def [BatHashtbl.Labels] |
modify_def [BatHashtbl] | `Hashtbl.modify_def v k f tbl` does the same as `Hashtbl.modify k f tbl` but `f v` is inserted in `tbl` if `k` was unbound.
modify_opt [BatMultiPMap] | `modify_opt x f m` allows to modify the bindings for `k` in `m` or absence thereof.
modify_opt [BatMultiMap] | `modify_opt x f m` allows to modify the bindings for `k` in `m` or absence thereof.
modify_opt [BatMap.PMap] | `modify_opt k f m` allow to modify the binding for `k` in `m` or absence thereof.
modify_opt [BatMap.S] | `modify_opt k f m` allows to modify the binding for `k` in `m` or absence thereof.
modify_opt [BatMap] | `modify_opt k f m` allow to modify the binding for `k` in `m` or absence thereof.
modify_opt [BatList] | `modify_opt a f l` allows to modify the binding for `a` in `l` or absence thereof.
modify_opt [BatIMap] | `modify_opt x f t` allows to modify the binding for `x` in `t` or absence thereof.
modify_opt [BatHashtbl.S.Labels] |
modify_opt [BatHashtbl.S] |
modify_opt [BatHashtbl.Labels] |
modify_opt [BatHashtbl] | `Hashtbl.modify_opt k f tbl` allows to remove, modify or add a binding for `k` in `tbl`.
modifyi [BatBigarray.Array1] | Same as `Bigarray.Array1.modify`, but the function is applied to the index of the element as the first argument, and the element itself as the second argument.
modifyi [BatBigarray.Genarray] | Same as `BatBigarray.Genarray.modify`, but the function is applied to the index of the coordinates as the first argument, and the element itself as the second argument.
modifyi [BatArray.Cap.Labels] |
modifyi [BatArray.Cap] |
modifyi [BatArray.Labels] |
modifyi [BatArray] | Same as `BatArray.modify`, but the function is applied to the index of the element as the first argument, and the element itself as the second argument.
modifyij [BatBigarray.Array2] | Same as `Bigarray.Array2.modify`, but the function is applied to the index of the element as the first two arguments, and the element itself as the third argument.
modifyijk [BatBigarray.Array3] | Same as `Bigarray.Array3.modify`, but the function is applied to the index of the coordinates as the first three arguments, and the element itself as the fourth argument.
modulo [BatNumber.Numeric] |
modulo [BatNum] |
modulo [BatNativeint] |
modulo [BatInt64] |
modulo [BatInt32] |
modulo [BatInt.Safe_int] | `modulo a b` computes the remainder of the integer division of `a` by `b`.
modulo [BatInt] | `modulo a b` computes the remainder of the integer division of `a` by `b`.
modulo [BatFloat.Safe_float] |
modulo [BatFloat] |
modulo [BatComplex] |
modulo [BatBool] |
modulo [BatBig_int] |
move [BatUTF8] | `move s i n` returns `n`-th Unicode character after `i` if n >= 0, `n`-th Unicode character before `i` if n < 0.
mul [BatNumber.Numeric] |
mul [BatNum] |
mul [BatNativeint] | Multiplication.
mul [BatInt64] | Multiplication.
mul [BatInt32] | Multiplication.
mul [BatInt.Safe_int] | Multiplication.
mul [BatInt] | Multiplication.
mul [BatFloat.Safe_float] |
mul [BatFloat] |
mul [BatComplex] | Multiplication
mul [BatBool] |
mul [BatBig_int] |
mult_big_int [BatBig_int] | Multiplication of two big integers.
mult_int_big_int [BatBig_int] | Multiplication of a big integer by a small integer
mult_num [BatNum] |
multi_choice [BatRandom] | `multi_choice n e` returns an enumeration of `n` randomly-chosen elements of `e`.
multiline_comment [BatGenlex.Languages.Make] |
must [BatParserCo] | Prevent backtracking.
N
n_cartesian_product [BatList] | Given n lists, return the n-way cartesian product of these lists.
name [BatPathGen.PathType] | Returns name of the object the pathname points to, i.e.
name [BatGlobal] | Retrieve the name of a global.
name_core [BatPathGen.PathType] | Returns part of the name to the left of rightmost dot.
name_of_input [BatScanf.Scanning] | `Scanning.file_name_of_input ib` returns the name of the character source for the scanning buffer `ib`.
name_of_level [BatLogger] | `name_of_level level` returns the name of the specified `level`.
nan [BatFloat.Safe_float] | A special floating-point value denoting the result of an undefined operation such as `0.0 /. 0.0`.
nan [BatFloat] | A special floating-point value denoting the result of an undefined operation such as `0.0 /. 0.0`.
narrow [BatOo.Internal] |
nat_of_num [BatNum] | Coercions between numerical types
nativeint [BatRandom.Incubator.Private_state_enums.State] |
nativeint [BatRandom.State] |
nativeint [BatRandom] | `Random.nativeint bound` returns a random integer between 0 (inclusive) and `bound` (exclusive).
nativeint [BatBigarray] | See `Bigarray.char`.
nativeint_of_big_int [BatBig_int] | Convert a big integer to a native integer.
neg [BatPervasives] | `neg p` returns a new predicate that is the negation of the given predicate.
neg [BatNumber.Numeric] |
neg [BatNum] |
neg [BatNativeint] | Unary negation.
neg [BatInt64] | Unary negation.
neg [BatInt32] | Unary negation.
neg [BatInt.Safe_int] | Unary negation.
neg [BatInt] | Unary negation.
neg [BatInnerPervasives] |
neg [BatFloat.Safe_float] |
neg [BatFloat] | Returns the negation of the input, i.e.
neg [BatComplex] | Unary negation.
neg [BatBool] |
neg [BatBig_int] |
neg2 [BatPervasives] | as `neg` but for predicates with two arguments
neg2 [BatInnerPervasives] |
neg_infinity [BatFloat.Safe_float] | Negative infinity.
neg_infinity [BatFloat] | Negative infinity.
nested_comments [BatGenlex.Languages.Definition] |
new_line [BatLexing] | Update the `lex_curr_p` field of the lexbuf to reflect the start of a new line.
new_method [BatOo.Internal] |
new_methods_variables [BatOo.Internal] |
new_variable [BatOo.Internal] |
newline [BatCharParser] | Recognizes a newline
next [BatUTF8] | `next s i` returns the position of the head of the Unicode character located immediately after `i`.
next [BatStream] | Return the first element of the stream and remove it from the stream.
next [BatLazyList] | Compute and return the next value of the list
next [BatDllist] | Given a node, get the next element in the list after the node.
next_set_bit [BatBitSet] | `next_set_bit s n` returns `Some m` when `m` is the next set element with index greater than or equal `n`, or None if no such element exists (i.e.
nice [BatUnix] | Change the process priority.
nil [BatSeq] | `nil = fun () -> Nil`
nil [BatLazyList] | The empty list.
nolock [BatConcurrent] | A lock which does nothing.
none_of [BatParserCo] | Accept any value not in a list Faster and more convenient than combining `satisfy` and `either`.
none_of [BatCharParser] | Accept any value not in a list As `ParserCo.none_of`, just with improved error message.
norm [BatComplex] | Norm: given `x + i.y`, returns `sqrt(x^2 + y^2)`.
norm2 [BatComplex] | Norm squared: given `x + i.y`, returns `x^2 + y^2`.
normalize [BatPathGen.PathType] | Deprecated name for `normalize_in_tree`
normalize_filepath [BatPathGen.PathType] | Consumes single dots where possible, e.g.:
normalize_in_graph [BatPathGen.PathType] | Another name for `normalize_filepath`.
normalize_in_tree [BatPathGen.PathType] | Consumes single dots and applies double dots where possible, e.g.:
not [BatBool] | The boolean negation.
not_char [BatCharParser] | Accept any value not a given char As `none_of`.
npeek [BatStream] | `npeek n` returns the list of the `n` first elements of the stream, or all its remaining elements if less than `n` elements are available.
npop [BatRefList] | Removes and returns the n first elements or raises `Empty_list` if the ref list does not contain enough elements
nread [BatInnerIO] | `nread i n` reads a string of size up to `n` from an input.
nread [BatIO] | `nread i n` reads a string of size up to `n` from an input.
nreplace [BatString.Cap] |
nreplace [BatString] | `nreplace ~str ~sub ~by` returns a string obtained by iteratively replacing each occurrence of `sub` by `by` in `str`, from right to left.
nsplit [BatText] | `nsplit s sep` splits the rope `s` into a list of ropes which are separated by `sep`.
nsplit [BatString.Cap] |
nsplit [BatString] | `nsplit s sep` splits the string `s` into a list of strings which are separated by `sep` (excluded).
nsplit [BatList] | `nsplit`, applied to a predicate `p` and a list `xs`, returns a list of lists.
nth [BatUTF8] | `nth s n` returns the position of the `n`-th Unicode character.
nth [BatList] | Obsolete.
nth [BatLazyList] | Obsolete.
nth [BatBuffer] | get the n-th character of the buffer.
nth_dim [BatBigarray.Genarray] | `Genarray.nth_dim a n` returns the `n`-th dimension of the big array `a`.
null_formatter [BatLogger] | `null_formatter` is a formatter that does not output any events, but simply discards them.
num_digits_big_int [BatBig_int] | Return the number of machine words used to store the given big integer.
num_dims [BatBigarray.Genarray] | Return the number of dimensions of the given big array.
num_of_big_int [BatNum] |
num_of_int [BatNum] |
num_of_nat [BatNum] |
num_of_ratio [BatNum] |
num_of_string [BatNum] |
number [BatGenlex.Languages.Make] | Parse either an integer or a floating-point number.
numeric_compare [BatString] | Compare two strings, sorting "abc32def" before "abc210abc".
nwrite [BatInnerIO] | Write a string to an output.
nwrite [BatIO] | Write a string to an output.
O
ocaml_version [BatSys] | `ocaml_version` is the version of OCaml.
of_array [BatVect.Make] | `of_array s` returns a vect corresponding to the array `s`.
of_array [BatVect] | `of_array s` returns a vect corresponding to the array `s`.
of_array [BatLazyList] | Eager conversion from array
of_array [BatDynArray] | `of_array arr` returns an array with the elements of `arr` in it in order.
of_array [BatBigarray.Array3] | Build a three-dimensional big array initialized from the given array of arrays of arrays.
of_array [BatBigarray.Array2] | Build a two-dimensional big array initialized from the given array of arrays.
of_array [BatBigarray.Array1] | Build a one-dimensional big array initialized from the given array.
of_array [BatArray.Cap] | Adopt a regular array as a capability array, allowing to decrease capabilities if necessary.
of_backwards [BatVect.RANDOMACCESS] |
of_backwards [BatVect.Make] | Build a vector from an enumeration, from last to first.
of_backwards [BatVect] | Build a vector from an enumeration, from last to first.
of_backwards [BatString.Cap] |
of_backwards [BatString] | Build a string from an enumeration, starting with last character, ending with first.
of_backwards [BatRefList] | Creates a ref list from an enumeration, going from last to first
of_backwards [BatList] | Build a list from an enumeration.
of_backwards [BatFingerTree.S] | `of_backward e` is equivalent to `reverse (of_enum e)`.
of_backwards [BatArray.Cap] |
of_backwards [BatArray] | Build an array from an enumeration, with the first element of the enumeration as the last element of the array and vice versa.
of_byte [BatInt32] |
of_channel [BatStream] | Return the stream of the characters read from the input channel.
of_char [BatUChar] | `of_char c` returns the Unicode character of the Latin-1 character `c`
of_char [BatText] | `of_char c` returns a rope containing exactly Latin-1 character `c`.
of_char [BatString.Cap] |
of_char [BatString] | Returns a string containing one given character.
of_container [BatVect.Make] | `of_container s` returns a vect corresponding to the container `s`.
of_digit [BatChar] | Return the character representing a given digit.
of_enum [BatVect.RANDOMACCESS] |
of_enum [BatVect.Make] | Build a vector from an enumeration.
of_enum [BatVect] | Build a vector from an enumeration.
of_enum [BatTuple.Tuple5] |
of_enum [BatTuple.Tuple4] |
of_enum [BatTuple.Tuple3] |
of_enum [BatTuple.Tuple2] |
of_enum [BatString.Cap] |
of_enum [BatString] | Creates a string from a character enumeration.
of_enum [BatStream] | Convert an enumeration to a stream.
of_enum [BatStack] | `of_enum e` returns a new stack containing all the elements of `e`.
of_enum [BatSet.PSet] |
of_enum [BatSet.S] |
of_enum [BatSet] |
of_enum [BatRefList] | Creates a ref list from an enumeration
of_enum [BatQueue] | `of_enum e` returns a new queue containing all the elements of `e`.
of_enum [BatParserCo.Source] |
of_enum [BatOption] | `of_enum e` consumes the first element of `e`, if it exists, and returns `Some e`.
of_enum [BatMultiPMap] | creates a map from an enumeration, using the specified function for key comparison or `compare` by default.
of_enum [BatMultiMap] | creates a map from an enumeration, using the specified function for key comparison or `compare` by default.
of_enum [BatMap.PMap] | creates a map from an enumeration, using the specified function for key comparison or `compare` by default.
of_enum [BatMap.S] | Create a map from a (key, value) enumeration.
of_enum [BatMap] | Creates a map from an enumeration
of_enum [BatList] | Build a list from an enumeration.
of_enum [BatLazyList] | Lazy conversion from enum.
of_enum [BatISet] |
of_enum [BatIMap] | `of_enum e` returns the set of given ranges
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 [BatFingerTree.S] | `of_enum e` build the sequence containing the elements of `e` in the same order.
of_enum [BatEnum.Enumerable] | Build a data structure from an enumeration
of_enum [BatEnum] | identity : added for consistency with the other data structures
of_enum [BatDynArray] | `of_enum e` returns an array that holds, in order, the elements of `e`.
of_enum [BatDllist] | Create a dllist from an enum.
of_enum [BatDeque] | `of_enum e` is a deque representation of the elements of `e`.
of_enum [BatBuffer] | Creates a buffer from a character enumeration.
of_enum [BatBitSet] | `of_enum ~cap e` builds a bitset of capacity `cap` an enumeration of ints `e`.
of_enum [BatBigarray.Array1] | `Array1.of_enum kind layout enum` returns a new one-dimensional big array of kind `kind` and layout `layout`, with elements taken from the enumeration `enum` in order.
of_enum [BatArray.Cap] |
of_enum [BatArray] | Build an array from an enumeration.
of_enum_cmp [BatSet.PSet] |
of_float [BatString.Cap] |
of_float [BatString] | Returns the string representation of an float.
of_float [BatNumber.Numeric] |
of_float [BatNum] |
of_float [BatNativeint] | Convert the given floating-point number to a native integer, discarding the fractional part (truncate towards 0).
of_float [BatInt64] | Convert the given floating-point number to a 64-bit integer, discarding the fractional part (truncate towards 0).
of_float [BatInt32] | Convert the given floating-point number to a 32-bit integer, discarding the fractional part (truncate towards 0).
of_float [BatInt.Safe_int] | Convert the given floating-point number to integer, discarding the fractional part (truncate towards 0).
of_float [BatInt] | Convert the given floating-point number to integer integer, discarding the fractional part (truncate towards 0).
of_float [BatFloat.Safe_float] |
of_float [BatFloat] |
of_float [BatComplex] | `Complex.of_float x` returns the complex number `x+0i`
of_float [BatBool] | `0.`, `nan` `+infinity` and `-infiity` are `false`.
of_float [BatBig_int] | rounds to the nearest integer
of_float_string [BatNum] | Convert a simple floating point literal to a num.
of_fun [BatStream] | `Stream.of_fun f` returns a stream built from the function `f`.
of_input [BatSubstring] |
of_input [BatStream] | Convert an `input` to a stream.
of_int [BatUChar] | Alias of `chr`
of_int [BatString.Cap] |
of_int [BatString] | Returns the string representation of an int.
of_int [BatNumber.Numeric] |
of_int [BatNum] |
of_int [BatNativeint] | Convert the given integer (type `int`) to a native integer (type `nativeint`).
of_int [BatInt64] | Convert the given integer (type `int`) to a 64-bit integer (type `int64`).
of_int [BatInt32] | Convert the given integer (type `int`) to a 32-bit integer (type `int32`).
of_int [BatInt.Safe_int] |
of_int [BatInt] |
of_int [BatFloat.Safe_float] |
of_int [BatFloat] |
of_int [BatComplex] |
of_int [BatBool] | anything but `0` is `true`
of_int [BatBig_int] |
of_int32 [BatNativeint] | Convert the given 32-bit integer (type `int32`) to a native integer.
of_int32 [BatInt64] | Convert the given 32-bit integer (type `int32`) to a 64-bit integer (type `int64`).
of_int64 [BatNativeint] | Convert the given 64-bit integer (type `int64`) to a native integer.
of_int64 [BatInt32] | Convert the given 64-bit integer (type `int64`) to a 32-bit integer (type `int32`).
of_latin1 [BatText] | Constructs a unicode rope from a latin-1 string.
of_list [BatVect.Make] |
of_list [BatVect] |
of_list [BatString.Cap] |
of_list [BatString] | Converts a list of characters to a string.
of_list [BatStream] | Return the stream holding the elements of the list in the same order.
of_list [BatSplay.Map] |
of_list [BatSet.PSet] | builds a set from the given list, using the default comparison function
of_list [BatSet] | builds a set from the given list, using the default comparison function
of_list [BatRefList] | Creates a ref list from a list - O(1)
of_list [BatLazyList] | Lazy conversion from lists
of_list [BatISet] | Build a ISet.t out of a list or enum of ranges
of_list [BatHeap.H] | 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 [BatFingerTree.S] | `of_list l` is equivalent to `of_enum (BatList.enum l)`.
of_list [BatDynArray] | `of_list lst` returns a dynamic array with the elements of `lst` in it in order.
of_list [BatDllist] | Converts from a normal list to a Dllist and returns the first node.
of_list [BatDeque] | `of_list l` is a deque representation of the elements of `l`.
of_list [BatBitSet] | As `of_enum`, but from a list
of_list [BatArray.Cap] |
of_list [BatArray] | `Array.of_list l` returns a fresh array containing the elements of `l`.
of_list_backwards [BatFingerTree.S] | `of_list_backwards l` is equivalent to `of_enum_backwards (BatList.enum l)`.
of_nativeint [BatInt64] | Convert the given native integer (type `nativeint`) to a 64-bit integer (type `int64`).
of_nativeint [BatInt32] | Convert the given native integer (type `nativeint`) to a 32-bit integer (type `int32`).
of_object [BatEnum] | `of_object e` returns a representation of an object as an enumeration
of_option [BatResult] | Convert an `option` to a `result`
of_stream [BatLazyList] | Lazy conversion from stream.
of_string [BatUnit] | Convert the given string to a unit.
of_string [BatText] | `of_string s` returns a rope corresponding to the UTF-8 encoded string `s`.
of_string [BatSubstring] |
of_string [BatString.Cap] | Adopt a regular string.
of_string [BatStream] | Return the stream of the characters of the string parameter.
of_string [BatPathGen.PathType] | Parse path in a given string.
of_string [BatNumber.Numeric] |
of_string [BatNum] |
of_string [BatNativeint] | Convert the given string to a native integer.
of_string [BatInt64] | Convert the given string to a 64-bit integer.
of_string [BatInt32] | Convert the given string to a 32-bit integer.
of_string [BatInt.Safe_int] | Convert the given string to an integer The string is read in decimal (by default) or in hexadecimal, octal or binary if the string begins with `0x`, `0o` or `0b` respectively.
of_string [BatInt] | Convert the given string to an integer The string is read in decimal (by default) or in hexadecimal, octal or binary if the string begins with `0x`, `0o` or `0b` respectively.
of_string [BatFloat.Safe_float] |
of_string [BatFloat] |
of_string [BatComplex] | `of_string s` accepts strings with the following formats:
of_string [BatBool] | Convert the given string to a boolean.
of_string [BatBig_int] |
of_table [BatHashtbl.Cap] | Adopt a regular hashtable as a capability hashtble, allowing to decrease capabilities if necessary.
of_uchar [BatText] | `of_uchar c` returns a rope containing exactly character `c`.
oget_exn [BatRef] | Get a value from an option ref;
ok [BatPervasives] | `f x |> ok` unwraps the `Ok` result of `f x` and returns it, or throws the exception contained if `Bad` is returned.
ok [BatInnerPervasives] |
on_close_out [BatInnerIO] | Register a function to be triggered just before an output is closed.
on_output [BatStream] | Convert an `output` to a stream.
one [BatNumber.Numeric] |
one [BatNum] |
one [BatNativeint] | The native integer 1.
one [BatInt64] | The 64-bit integer 1.
one [BatInt32] | The 32-bit integer 1.
one [BatInt.Safe_int] | The integer `1`.
one [BatInt] | The integer `1`.
one [BatFloat.Safe_float] | Floating number one.
one [BatFloat] | Floating number one.
one [BatComplex] | The complex number `1`.
one [BatBool] |
one [BatBig_int] |
one_of [BatParserCo] | Accept one of several values.
one_plus [BatParserCo] | Accept a (non-empty) list of expressions
op_letter [BatGenlex.Languages.Definition] |
op_map [BatSet.Incubator] | Order Preserving map; as `map`, but `f` must be order preserving; i.e.
op_start [BatGenlex.Languages.Definition] |
open_box [BatFormat] | `open_box d` opens a new pretty-printing box with offset `d`.
open_connection [BatUnix] | Connect to a server at the given address.
open_hbox [BatFormat] | `open_hbox ()` opens a new pretty-printing box.
open_hovbox [BatFormat] | `open_hovbox d` opens a new pretty-printing box with offset `d`.
open_hvbox [BatFormat] | `open_hvbox d` opens a new pretty-printing box with offset `d`.
open_in [BatPervasives] | Open the named file for reading.
open_in [BatFile] | `open_in file_name` opens the file named `file_name` for reading.
open_in_bin [BatPervasives] | Same as `Pervasives.open_in`, but the file is opened in binary mode, so that no translation takes place during reads.
open_in_gen [BatPervasives] | `open_in mode perm filename` opens the named file for reading, as described above.
open_out [BatPervasives] | Open the named file for writing, and return a new output channel on that file.
open_out [BatFile] | `open_out file_name` opens the file named `file_name` for writing.
open_out_bin [BatPervasives] | Same as `BatPervasives.open_out`, but the file is opened in binary mode, so that no translation takes place during writes.
open_out_gen [BatPervasives] | `open_out_gen mode perm filename` opens the named file for writing, as described above.
open_process [BatUnix] | Same as `Unix.open_process_out`, but redirects both the standard input and standard output of the command to pipes connected to the two returned `input`/`output`.
open_process_full [BatUnix] | Similar to `Unix.open_process`, but the second argument specifies the environment passed to the command.
open_process_in [BatUnix] | High-level pipe and process management.
open_process_out [BatUnix] | Same as `Unix.open_process_in`, but redirect the standard input of the command to a pipe.
open_tag [BatFormat] | `open_tag t` opens the tag named `t`; the `print_open_tag` function of the formatter is called with `t` as argument; the tag marker `mark_open_tag t` will be flushed into the output device of the formatter.
open_tbox [BatFormat] | Opens a tabulation box.
open_temporary_out [BatFile] | `open_temporary_out ()` opens a new temporary file for writing.
open_vbox [BatFormat] | `open_vbox d` opens a new pretty-printing box with offset `d`.
opendir [BatUnix] | Open a descriptor on a directory
openfile [BatUnix] | Open the named file with the given flags.
operations [BatNumber.Numeric] |
operations [BatNum] |
operations [BatNativeint] |
operations [BatInt64] |
operations [BatInt.Safe_int] |
operations [BatInt] |
operations [BatFloat.Safe_float] |
operations [BatFloat] |
operations [BatComplex] |
operations [BatBool] |
operations [BatBig_int] |
opt [BatOptParse.Opt] | Get the value of an option as an optional value.
opt_of_ord [BatBounded] | `opt_of_ord ~bounds:(low, high) ord` will returning a bounding function using `ord` for value comparison and `None` for values which fall outside of the requested range.
or_big_int [BatBig_int] | Bitwise logical ``or''.
ord [BatVect] |
ord [BatUnit] | Always returns `BatOrd.Eq`
ord [BatTuple.Tuple5] |
ord [BatTuple.Tuple4] |
ord [BatTuple.Tuple3] |
ord [BatTuple.Tuple2] |
ord [BatString] | Ordering function for strings, see `BatOrd`
ord [BatRef] |
ord [BatOrd] | Returns a variant ordering from a legacy comparison
ord [BatNumber.Numeric] |
ord [BatNum] |
ord [BatNativeint] |
ord [BatList] |
ord [BatInt64] |
ord [BatInt32] |
ord [BatInt.Safe_int] |
ord [BatInt] |
ord [BatISet] | Same as `compare` but returns `BatOrd.Lt | BatOrd.Eq | BatOrd.Gt` instead of an int.
ord [BatFloat] |
ord [BatEnum] | Same as `compare` but returning a `BatOrd.order` instead of an interger.
ord [BatComplex] |
ord [BatOrd.Ord] |
ord [BatChar] |
ord [BatBool] |
ord [BatBitSet] | `ord s1 s2` returns `BatOrd.Lt`, `BatOrd.Eq` or `BatOrd.Gt` if `compare s1 s2` is, respectively, `< 0`, `0` or `> 0`.
ord [BatBig_int] |
ord [BatArray.Incubator.Ord] |
ord [BatArray.Cap] |
ord [BatArray] | Hoist an element comparison function to compare arrays of those elements, with shorter arrays less than longer ones, and lexicographically for arrays of the same size.
ord0 [BatOrd] |
ord_by [BatOrd.Incubator] | Build a `eq`, `cmp` or `ord` function from a projection function.
os_type [BatSys] | Operating system currently executing the OCaml program.
oset [BatRef] | Set the given option ref to `Some x`
other_exec [BatFile] | Give the permission to execute the file to the rest of the world.
other_read [BatFile] | Give the permission to read the file to the rest of the world.
other_write [BatFile] | Give the permission to modify the file to the rest of the world.
out [BatLog.Config] |
out_channel_of_descr [BatUnix] | Create an output channel writing on the given descriptor.
out_of_range [BatUTF8] | `out_of_range s i` tests whether `i` is a position inside of `s`.
output [BatPervasives] | `output oc buf pos len` writes `len` characters from string `buf`, starting at offset `pos`, to the given output channel `oc`.
output [BatMarshal] | `output out v` writes the representation of `v` on `chan`.
output [BatLog.Make_lev] |
output [BatLog.Easy] |
output [BatLog] | This ref holds the output channel for simple logging.
output [BatInnerIO] | `output o s p l` writes up to `l` characters from string `s`, starting at offset `p`.
output [BatIO] | `output o s p l` writes up to `l` characters from string `s`, starting at offset `p`.
output [BatDigest] | Write a digest on the given output.
output_binary_float [BatPervasives] | Write one float in binary format (8 bytes, IEEE 754 double format) on the given output channel.
output_binary_int [BatPervasives] | Write one integer in binary format (4 bytes, big-endian) on the given output channel.
output_bits [BatIO] | Write bits to an output
output_buffer [BatBuffer] | `output_buffer b` creates an output channel that writes to that buffer, and when closed, returns the contents of the buffer.
output_byte [BatPervasives] | Write one 8-bit integer (as the single character with that code) on the given output channel.
output_channel [BatInnerIO] | Create an output that will write into a channel.
output_channel [BatIO] | Create an output that will write into a channel.
output_char [BatPervasives] | Write the character on the given output channel.
output_enum [BatIO] | Create an output that will write into an `enum`.
output_file [BatPervasives] | creates a filename, write text into it and close it.
output_of_descr [BatUnix] | Create an `output` writing on the given descriptor.
output_string [BatPervasives] | Write the string on the given output channel.
output_string [BatInnerIO] | Create an output that will write into a string in an efficient way.
output_string [BatIO] | Create an output that will write into a string in an efficient way.
output_text [BatText] | Write the text on the given output channel.
output_value [BatPervasives] | Write the representation of a structured value of any type to a channel.
over_max_boxes [BatFormat] | Tests if the maximum number of boxes allowed have already been opened.
P
p [BatPathGen.PathType] | = `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.Internal] |
parent [BatPathGen.PathType] | Returns parent path, i.e.
parse [BatOptParse.OptParser] | Parse arguments as if the arguments `args.(first)`, `args.(first+1)`, ..., `args.(last)` had been given on the command line.
parse [BatCharParser] | Apply a parser to a string.
parse_argv [BatOptParse.OptParser] | Parse all the arguments in `Sys.argv`.
partition [BatVect.Make] | `partition p v` returns a pair of vects `(v1, v2)`, where `v1` is the vect of all the elements of `v` that satisfy the predicate `p`, and `v2` is the vect of all the elements of `v` that do not satisfy `p`.
partition [BatVect] | `partition p v` returns a pair of vects `(v1, v2)`, where `v1` is the vect of all the elements of `v` that satisfy the predicate `p`, and `v2` is the vect of all the elements of `v` that do not satisfy `p`.
partition [BatSet.PSet] | returns two disjoint subsets, those that satisfy the given predicate and those that don't
partition [BatSet.S.Labels] |
partition [BatSet.S] | `partition p s` returns a pair of sets `(s1, s2)`, where `s1` is the set of all the elements of `s` that satisfy the predicate `p`, and `s2` is the set of all the elements of `s` that do not satisfy `p`.
partition [BatSet] | returns two disjoint subsets, those that satisfy the given predicate and those that don't
partition [BatMap.PMap] | `partition p m` returns a pair of maps `(m1, m2)`, where `m1` contains all the bindings of `s` that satisfy the predicate `p`, and `m2` is the map with all the bindings of `s` that do not satisfy `p`.
partition [BatMap.S] | `partition p m` returns a pair of maps `(m1, m2)`, where `m1` contains all the bindings of `s` that satisfy the predicate `p`, and `m2` is the map with all the bindings of `s` that do not satisfy `p`.
partition [BatMap] | `partition p m` returns a pair of maps `(m1, m2)`, where `m1` contains all the bindings of `s` that satisfy the predicate `p`, and `m2` is the map with all the bindings of `s` that do not satisfy `p`.
partition [BatList.Labels] |
partition [BatList] | `partition p l` returns a pair of lists `(l1, l2)`, where `l1` is the list of all the elements of `l` that satisfy the predicate `p`, and `l2` is the list of all the elements of `l` that do not satisfy `p`.
partition [BatISet] | partitions the input set into two sets with elements that satisfy the predicate and those that don't
partition [BatEnum] | as `switch`
partition [BatArray.Cap] |
partition [BatArray] | `partition p a` returns a pair of arrays `(a1, a2)`, where `a1` is the array of all the elements of `a` that satisfy the predicate `p`, and `a2` is the array of all the elements of `a` that do not satisfy `p`.
pass [BatPrintexc] | `Printexc.pass fn x` applies `fn` to `x` and returns the result.
pause [BatUnix] | Wait until a non-ignored, non-blocked signal is delivered.
peek [BatStream] | Return `Some` of "the first element" of the stream, or `None` if the stream is empty.
peek [BatQueue.Exceptionless] |
peek [BatQueue] | `peek q` returns the first element in queue `q`, without removing it from the queue, or raises `Empty` if the queue is empty.
peek [BatPervasives] | `peek e` returns `None` if `e` is empty or `Some x` where `x` is the next element of `e`.
peek [BatLazyList] | `peek l` returns the first element of `l`, if it exists.
peek [BatEnum] | `peek e` returns `None` if `e` is empty or `Some x` where `x` is the next element of `e`.
perm [BatFile] | Join permissions
perturb [BatRandom.Incubator.Private_state_enums.State] | `perturb s` returns a new state based on the given state that is, in a sense, the hash of the input state.
pi [BatFloat.Safe_float] | The constant pi (3.14159...)
pi [BatFloat] | The constant pi (3.14159...)
pi2 [BatFloat] | `pi /. 2.`
pi4 [BatFloat] | `pi /. 4.`
pipe [BatUnix] | Create a pipe.
pipe [BatInnerIO] | Create a pipe between an input and an ouput.
pipe [BatIO] | Create a pipe between an input and an ouput.
polar [BatComplex] | `polar norm arg` returns the complex having norm `norm` and argument `arg`.
poly [BatOrd] | Polymorphic comparison functions, based on the `Pervasives.compare` function from inria's stdlib, have polymorphic types: they claim to be able to compare values of any type.
poly_comp [BatOrd] |
poly_ord [BatOrd] |
pop [BatVect.Make] | Return the last element of a vector and its first `n-1` elements.
pop [BatVect] | Return the last element of a vector and its first `n-1` elements.
pop [BatStack.Exceptionless] |
pop [BatStack] | `pop s` removes and returns the topmost element in stack `s`, or
pop [BatSet.PSet] | returns one element of the set and the set without that element.
pop [BatSet.S] | returns one element of the set and the set without that element.
pop [BatSet] | returns one element of the set and the set without that element.
pop [BatRefList] | Removes and returns the first element or raises `Empty_list` if the ref list is empty
pop [BatQueue] | `pop` is a synonym for `take`.
pop [BatMap.PMap] | `pop m` returns a binding from `m` and `m` without that binding.
pop [BatMap.S] | `pop m` returns a binding from `m` and `m` without that binding.
pop [BatMap] | `pop m` returns a binding from `m` and `m` without that binding.
popcount [BatInt] | Returns the number of 1 bits set in the binary representation of the number.
pos_in [BatIO] | Create an input that provide a count function of the number of bytes read from it.
pos_out [BatIO] | Create an output that provide a count function of the number of bytes written through it.
post [BatRef] | Perform an operation on a reference and return the previous value of that reference.
post_decr [BatRef] | Decrement an integer, return the old value.
post_incr [BatRef] | Increment an integer, return the old value.
post_map [BatParserCo] | Pass the (successful) result of some parser through a map.
pow [BatNumber.Numeric] |
pow [BatNum] |
pow [BatNativeint] |
pow [BatInt64] |
pow [BatInt32] |
pow [BatInt.Safe_int] | `pow a b` computes ab.
pow [BatInt] | `pow a b` computes ab.
pow [BatFloat.Safe_float] |
pow [BatFloat] |
pow [BatComplex] | Power function.
pow [BatBool] |
pow [BatBig_int] |
power_big_int_positive_big_int [BatBig_int] | Exponentiation functions.
power_big_int_positive_int [BatBig_int] |
power_int_positive_big_int [BatBig_int] |
power_int_positive_int [BatBig_int] |
power_num [BatNum] |
pp_close_box [BatFormat] |
pp_close_tag [BatFormat] |
pp_close_tbox [BatFormat] |
pp_force_newline [BatFormat] |
pp_get_all_formatter_output_functions [BatFormat] |
pp_get_ellipsis_text [BatFormat] |
pp_get_formatter_output_functions [BatFormat] |
pp_get_formatter_tag_functions [BatFormat] | These functions are the basic ones: usual functions operating on the standard formatter are defined via partial evaluation of these primitives.
pp_get_margin [BatFormat] |
pp_get_mark_tags [BatFormat] |
pp_get_max_boxes [BatFormat] |
pp_get_max_indent [BatFormat] |
pp_get_print_tags [BatFormat] |
pp_open_box [BatFormat] |
pp_open_hbox [BatFormat] |
pp_open_hovbox [BatFormat] |
pp_open_hvbox [BatFormat] |
pp_open_tag [BatFormat] |
pp_open_tbox [BatFormat] |
pp_open_vbox [BatFormat] |
pp_over_max_boxes [BatFormat] |
pp_print_as [BatFormat] |
pp_print_bool [BatFormat] |
pp_print_break [BatFormat] |
pp_print_char [BatFormat] |
pp_print_cut [BatFormat] |
pp_print_float [BatFormat] |
pp_print_flush [BatFormat] |
pp_print_if_newline [BatFormat] |
pp_print_int [BatFormat] |
pp_print_newline [BatFormat] |
pp_print_space [BatFormat] |
pp_print_string [BatFormat] |
pp_print_tab [BatFormat] |
pp_print_tbreak [BatFormat] |
pp_set_all_formatter_output_functions [BatFormat] |
pp_set_ellipsis_text [BatFormat] |
pp_set_formatter_out_channel [BatFormat] |
pp_set_formatter_output [BatFormat] |
pp_set_formatter_output_functions [BatFormat] |
pp_set_formatter_tag_functions [BatFormat] |
pp_set_margin [BatFormat] |
pp_set_mark_tags [BatFormat] |
pp_set_max_boxes [BatFormat] |
pp_set_max_indent [BatFormat] |
pp_set_print_tags [BatFormat] |
pp_set_tab [BatFormat] |
pp_set_tags [BatFormat] |
pre [BatRef] | Perform an operation on a reference and return the new value of that reference.
pre_decr [BatRef] | Increment an integer, return the new value.
pre_incr [BatRef] | Increment an integer, return the new value.
pred [BatNumber.Discrete] |
pred [BatNumber.Numeric] |
pred [BatNum] |
pred [BatNativeint] | Predecessor.
pred [BatInt64] | Predecessor.
pred [BatInt32] | Predecessor.
pred [BatInt.Safe_int] | Predecessor.
pred [BatInt] | Predecessor.
pred [BatFloat.Safe_float] | Substract `1.` from a floating number.
pred [BatFloat] | Substract `1.` from a floating number.
pred [BatComplex] | Remove `BatComplex.one` from this number.
pred [BatBool] |
pred [BatBig_int] |
pred_big_int [BatBig_int] | Predecessor (subtract 1).
pred_num [BatNum] |
prefix [BatLog.Config] |
prefix [BatLog] | This ref holds the text printed before each log message.
prefix_action [BatEnum] | `prefix_action f e` will behave as `e` but guarantees that `f ()` will be invoked exactly once before the current first element of `e` is read.
prepend [BatVect.Make] | `prepend c r` returns a new vect with the `c` character at the beginning in amortized `O(1)` time.
prepend [BatVect] | `prepend c r` returns a new vect with the `c` character at the beginning in amortized `O(1)` time.
prepend [BatDllist] | `prepend n a` Creates a new node containing data `a` and inserts it into the list before node `n`.
prepend_char [BatText] | `prepend_char c r` returns a new rope with the `c` character at the beginning in amortized `O(1)` time.
prepend_list [BatDeque] | `prepent_list l dq` is equivalent to `append (of_list l) dq`, but more efficient.
prerr_all [BatPervasives] | Print the contents of an input to the error output.
prerr_bool [BatPervasives] | Print a boolean to stderr.
prerr_guess [BatPervasives] | Attempt to print the representation of a runtime value on the error output.
prev [BatUTF8] | `prev s i` returns the position of the head of the Unicode character located immediately before `i`.
prev [BatDllist] | Given a node, get the previous element in the list before the node.
print [BatVect.Make] |
print [BatVect] |
print [BatUref] | Print the uref.
print [BatUnit] | Printing
print [BatTuple.Tuple5] |
print [BatTuple.Tuple4] |
print [BatTuple.Tuple3] |
print [BatTuple.Tuple2] |
print [BatText] | Prints a rope to the given out_channel
print [BatSubstring] | `print oc ss` prints `ss` to the output channel `oc`
print [BatString.Cap] |
print [BatString] | Print a string.
print [BatStack] |
print [BatSet.PSet] |
print [BatSet.S] |
print [BatSet] |
print [BatSeq] | Print the contents of a sequence
print [BatResult] | Print a result as Ok(x) or Bad(exn)
print [BatRef] |
print [BatQueue] |
print [BatPrintexc] | Print an exception.
print [BatPervasives] | Print and consume the contents of an enumeration.
print [BatOption] |
print [BatNum] | Printing
print [BatNativeint] |
print [BatMultiPMap] |
print [BatMultiMap] |
print [BatMap.PMap] |
print [BatMap.S] |
print [BatMap] |
print [BatList] | Print the contents of a list
print [BatLazyList] |
print [BatInt64] | prints as decimal string
print [BatInt.Safe_int] |
print [BatInt] | prints as decimal string
print [BatISet] |
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 [BatFingerTree.S] |
print [BatEnum] | Print and consume the contents of an enumeration.
print [BatDynArray] |
print [BatDllist] |
print [BatDigest] | Write a digest on the given output in hexadecimal.
print [BatDeque] | Print the contents of the deque.
print [BatComplex] | Printing
print [BatChar] |
print [BatBuffer] |
print [BatBool] | Printing
print [BatBitSet] |
print [BatBig_int] |
print [BatArray.Cap] |
print [BatArray] | Print the contents of an array, with `~first` preceeding the first item (default: "`|"), [~last] following the last item (default: "|`") and `~sep` separating items (default: "; ").
print_all [BatPervasives] | Print the contents of an input to the standard output.
print_any [BatPervasives] | Attempt to print a value to an output.
print_as [BatFormat] | `print_as len str` prints `str` in the current box.
print_as_list [BatSplay.Map] |
print_backtrace [BatPrintexc] | `print_backtrace oc` Prints the an exception backtrace on the output channel `oc`.
print_bool [BatPervasives] | Print a boolean on standard output.
print_bool [BatFormat] | Prints a boolean in the current box.
print_break [BatFormat] | Inserts a break hint in a pretty-printing box.
print_char [BatFormat] | Prints a character in the current box.
print_cut [BatFormat] | `print_cut ()` is used to mark a good break position.
print_float [BatFormat] | Prints a floating point number in the current box.
print_flush [BatFormat] | Flushes the pretty printer: all opened boxes are closed, and all pending text is displayed.
print_guess [BatPervasives] | Attempt to print the representation of a runtime value on the standard output.
print_hex [BatInt64] | prints as hex string
print_hex [BatInt] | prints as hex string
print_if_newline [BatFormat] | Executes the next formatting command if the preceding line has just been split.
print_int [BatFormat] | Prints an integer in the current box.
print_newline [BatFormat] | Equivalent to `print_flush` followed by a new line.
print_quoted [BatString.Cap] |
print_quoted [BatString] | Print a string, with quotes as added by the `quote` function.
print_rope [BatteriesPrint] |
print_space [BatFormat] | `print_space ()` is used to separate items (typically to print a space between two words).
print_stat [BatGc] | Print the current values of the memory management counters (in human-readable form) into the channel argument.
print_string [BatFormat] | `print_string str` prints `str` in the current box.
print_string_cap_ro [BatteriesPrint] |
print_string_cap_rw [BatteriesPrint] |
print_tab [BatFormat] | `print_tab ()` is equivalent to `print_tbreak 0 0`.
print_tbreak [BatFormat] | Break hint in a tabulation box.
print_uchar [BatteriesPrint] |
print_ustring [BatteriesPrint] |
printf [BatPrintf] | The usual `printf` function, prints to the standard output `stdout`, i.e.
printf [BatFormat] | Same as `fprintf` above, but output on `std_formatter`.
println [BatString.Cap] |
println [BatString] | Print a string, end the line.
printn [BatTuple.Tuple5] |
printn [BatTuple.Tuple4] |
printn [BatTuple.Tuple3] |
printn [BatTuple.Tuple2] |
progress_in [BatIO] | `progress_in inp f` create an input that calls `f ()` whenever some content is succesfully read from it.
progress_out [BatIO] | `progress_out out f` create an output that calls `f ()` whenever some content is succesfully written to it.
promote [BatDllist] | `promote n` Swaps `n` with `next n`.
protect [BatRef] | Assign a reference temporarily.
public_method_label [BatOo.Internal] |
push [BatStack] | `push x s` adds the element `x` at the top of stack `s`.
push [BatRefList] | Adds an element at the head - O(1)
push [BatQueue] | `push` is a synonym for `add`.
push [BatPervasives] | `push e x` will add `x` at the beginning of `e`.
push [BatEnum] | `push e x` will add `x` at the beginning of `e`.
put [BatBitSet] | `put s v n` sets the nth-bit in the bitset `s` to `v`.
putenv [BatUnix] | `Unix.putenv name value` sets the value associated to a variable in the process environment.
Q
quick_stat [BatGc] | Same as `stat` except that `live_words`, `live_blocks`, `free_words`, `free_blocks`, `largest_free`, and `fragments` are set to 0.
quo [BatNum] | Additional operations
quo_num [BatNum] |
quomod_big_int [BatBig_int] | Euclidean division of two big integers.
quote [BatString.Cap] |
quote [BatString] | Add quotes around a string and escape any quote or escape appearing in that string.
R
range [BatParserCo] | Accept any element from a given range.
range [BatLazyList] | Compute lazily a range of integers a ..
range [BatEnum] | `range p until:q` creates an enumeration of integers `[p, p+1, ..., q]`.
range [BatChar] | `range from ?until` produces an enumeration of the characters from `from` to `until` included `until` defaults to `'\255'`
range [BatArray] | `range a` returns an enumeration of all valid indexes into the given array.
range_iter [BatText] | `rangeiter f m n r` applies `f` to all the characters whose indices `k` satisfy `m` <= `k` < `m + n`.
range_iteri [BatText] | As `range_iter`, but passes base + index of the character in the subrope defined by next to arguments.
rangeiter [BatVect.Make] | `rangeiter f m n r` applies `f` to all the elements whose indices `k` satisfy `m` <= `k` < `m + n`.
rangeiter [BatVect] | `rangeiter f m n r` applies `f` to all the elements whose indices `k` satisfy `m` <= `k` < `m + n`.
ranges [BatISet] | Returns a list of all contiguous ranges in the set
ratio_of_num [BatNum] |
rchop [BatText] | Returns the same rope but without the last character.
rchop [BatString.Cap] |
rchop [BatString] | Returns the same string but without the last `n` characters.
rcontains_from [BatText] | `rcontains_from s stop c` tests if character `c` appears in the subrope of `s` starting from the beginning of `s` to index `stop`.
rcontains_from [BatString.Cap] |
rcontains_from [BatString] | `String.rcontains_from s stop c` tests if character `c` appears in `s` before position `stop+1`.
read [BatUnix] | `read fd buff ofs len` reads `len` characters from descriptor `fd`, storing them in string `buff`, starting at position `ofs` in string `buff`.
read [BatInnerIO] | Read a single char from an input or raise `No_more_input` if no input available.
read [BatIO] | Read a single char from an input or raise `No_more_input` if no input is available.
read_all [BatText] | Read the whole contents of a UTF-8 encoded input
read_all [BatInnerIO] | read all the contents of the input until `No_more_input` is raised.
read_all [BatIO] | read all the contents of the input until `No_more_input` is raised.
read_bits [BatIO] | Read up to 31 bits, raise Bits_error if n < 0 or n > 31
read_byte [BatInnerIO] | Read an unsigned 8-bit integer.
read_byte [BatIO] | Read an unsigned 8-bit integer.
read_char [BatText] | Read one Unicode char from a UTF-8 encoded input
read_double [BatInnerIO] | Read an IEEE double precision floating point value.
read_double [BatIO.BigEndian] | Read an IEEE double precision floating point value.
read_double [BatIO] | Read an IEEE double precision floating point value.
read_float [BatInnerIO] | Read an IEEE single precision floating point value.
read_float [BatIO.BigEndian] | Read an IEEE single precision floating point value.
read_float [BatIO] | Read an IEEE single precision floating point value.
read_i16 [BatInnerIO] | Read a signed 16-bit word.
read_i16 [BatIO.BigEndian] | Read a signed 16-bit word.
read_i16 [BatIO] | Read a signed 16-bit word.
read_i32 [BatInnerIO] | Read a signed 32-bit integer.
read_i32 [BatIO.BigEndian] | Read a signed 32-bit integer.
read_i32 [BatIO] | Read a signed 32-bit integer.
read_i64 [BatInnerIO] | Read a signed 64-bit integer as an OCaml int64.
read_i64 [BatIO.BigEndian] | Read a signed 64-bit integer as an OCaml int64.
read_i64 [BatIO] | Read a signed 64-bit integer as an OCaml int64.
read_line [BatText] | Read a line of UTF-8
read_line [BatInnerIO] | Read a LF or CRLF terminated string.
read_line [BatIO] | Read a LF or CRLF terminated string.
read_only [BatString.Cap] | Drop capabilities to read only.
read_only [BatHashtbl.Cap] | Drop to read-only permissions.
read_only [BatArray.Cap] | Drop to read-only permissions.
read_real_i32 [BatInnerIO] | Read a signed 32-bit integer as an OCaml int32.
read_real_i32 [BatIO.BigEndian] | Read a signed 32-bit integer as an OCaml int32.
read_real_i32 [BatIO] | Read a signed 32-bit integer as an OCaml int32.
read_signed_byte [BatInnerIO] | Read an signed 8-bit integer.
read_signed_byte [BatIO] | Read an signed 8-bit integer.
read_string [BatInnerIO] | Read a null-terminated string.
read_string [BatIO] | Read a null-terminated string.
read_text [BatText] | Read up to n chars from a UTF-8 encoded input
read_ui16 [BatInnerIO] | Read an unsigned 16-bit word.
read_ui16 [BatIO.BigEndian] | Read an unsigned 16-bit word.
read_ui16 [BatIO] | Read an unsigned 16-bit word.
readdir [BatUnix] | Return the next entry in a directory.
readdir [BatSys] | Return the names of all files present in the given directory.
readlink [BatUnix] | Read the contents of a link.
real_i32s_of [BatIO.BigEndian] | Read an enumeration of signed 32-bit integers as OCaml `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 [BatFingerTree.S] | `rear t` returns `None` when `t` is empty, or `Some (init, last)` where `last` is the last element of the sequence and `init` is the rest of the sequence.
rear [BatDeque] | `rear dq` returns `Some (dq', x)` iff `x` is at the rear of `dq` and `dq'` is the rest of `dq` excluding `x`, and `None` if `dq` has no elements.
rear_exn [BatFingerTree.S] | `rear t` returns `(init, last)` when `last` is the last element of the sequence and `init` is the rest of the sequence.
record_backtrace [BatPrintexc] | `Printexc.record_backtrace b` turns recording of exception backtraces on (if `b = true`) or off (if `b = false`).
recv [BatUnix] | Receive data from a connected socket.
recvfrom [BatUnix] | Receive data from an unconnected socket.
reduce [BatVect.Make] | as `fold_left`, but no initial value - just applies reducing function to elements from left to right.
reduce [BatVect] | as `BatVect.fold_left`, but no initial value - just applies reducing function to elements from left to right.
reduce [BatSeq.Exceptionless] |
reduce [BatSeq] | `reduce f (cons e s)` is `fold_left f e s`.
reduce [BatPervasives] | Transformation loop on an enumeration, used to build a single value from an enumeration.
reduce [BatList] | `List.reduce f h::t` is `fold_left f h t`.
reduce [BatEnum] | A simplified version of `fold`, which uses the first element of the enumeration as a default value.
reduce [BatArray] | `Array.reduce f a` is `fold_left f a.(0) [|a.(1); ..; a.(n-1)|]`.
ref [BatRef] | Return a fresh reference containing the given value.
register_formatter [BatLogger] | `register_formatter name formatter` registers a named log formatter.
register_printer [BatPrintexc] | `Printexc.register_printer fn` registers `fn` as an exception printer.
relative_to_any [BatPathGen.PathType] | `relative_to_any base sub` returns relative path `rel` such that `normalize (base/:rel) = normalize sub`, i.e.
relative_to_parent [BatPathGen.PathType] | `relative_to_parent parent sub` returns relative path `rel` such that `(normalize parent)/:rel = normalize sub`.
rem [BatNativeint] | Integer remainder.
rem [BatInt64] | Integer remainder.
rem [BatInt32] | Integer remainder.
rem [BatInt.Safe_int] | Integer remainder.
rem [BatInt] | Integer remainder.
remove [BatVect.Make] | `remove m n r` returns the vect resulting from deleting the elements with indexes ranging from `m` to `m + n - 1` (included) from the original vect `r`.
remove [BatVect] | `remove m n r` returns the vect resulting from deleting the elements with indexes ranging from `m` to `m + n - 1` (included) from the original vect `r`.
remove [BatText] | `remove m n r` returns the rope resulting from deleting the characters with indexes ranging from `m` to `m + n - 1` (included) from the original rope `r`.
remove [BatSys] | Remove the given file name from the file system.
remove [BatSet.PSet] | `remove x s` returns a set containing all elements of `s`, except `x`.
remove [BatSet.S] | `remove x s` returns a set containing all elements of `s`, except `x`.
remove [BatSet] | `remove x s` returns a set containing all elements of `s`, except `x`.
remove [BatRefList] | Remove an element from the ref list raise `Not_found` if the element is not found
remove [BatMultiPMap] | `remove k d m` returns a map containing the same bindings as `m`, except for `k` which is not bound to `d` anymore in the returned map.
remove [BatMultiMap] | `remove k d m` returns a map containing the same bindings as `m`, except for `k` which is not bound to `d` anymore in the returned map.
remove [BatMap.PMap] | `remove x m` returns a map containing the same bindings as `m`, except for `x` which is unbound in the returned map.
remove [BatMap.S] | `remove x m` returns a map containing the same bindings as `m`, except for `x` which is unbound in the returned map.
remove [BatMap] | `remove x m` returns a map containing the same bindings as `m`, except for `x` which is unbound in the returned map.
remove [BatList] | `remove l x` returns the list `l` without the first element `x` found or returns `l` if no element is equal to `x`.
remove [BatLazyList] | `remove l x` returns the list `l` without the first element `x` found or returns `l` if no element is equal to `x`.
remove [BatInnerWeaktbl] | `Weaktbl.remove tbl x` removes the current binding of `x` in `tbl`, restoring the previous binding if it exists.
remove [BatISet] | Remove an element from the given set, returning a new set
remove [BatIMap] | Remove any bindings from the given value.
remove [BatHashtbl.Cap] |
remove [BatHashtbl.S] |
remove [BatHashtbl] | `Hashtbl.remove tbl x` removes the current binding of `x` in `tbl`, restoring the previous binding if it exists.
remove [BatDllist] | Remove node from the list no matter where it is.
remove [BatBitSet] | `remove n s` returns a copy of `s` with bit `n` false.
remove_all [BatRefList] | Remove all elements equal to the specified element from the ref list
remove_all [BatMultiPMap] | `remove_all x m` returns a map containing the same bindings as `m`, except for `x` which is unbound in the returned map.
remove_all [BatMultiMap] | `remove_all x m` returns a map containing the same bindings as `m`, except for `x` which is unbound in the returned map.
remove_all [BatList] | `remove_all l x` is similar to `remove` but removes all elements that are equal to `x` and not only the first one.
remove_all [BatLazyList] | `remove_all l x` is similar to `remove` but removes all elements that are equal to `x` and not only the first one.
remove_all [BatHashtbl.Cap] |
remove_all [BatHashtbl.S] |
remove_all [BatHashtbl] | Remove all bindings for the given key
remove_all_such [BatLazyList.Labels] |
remove_all_such [BatLazyList] | `remove_all l x` is similar to `remove` but removes all elements that are equal to `x` and not only the first one.
remove_assoc [BatList] | `remove_assoc a l` returns the list of pairs `l` without the first pair with key `a`, if any.
remove_assq [BatList] | Same as `List.remove_assoc`, but uses physical equality instead of structural equality to compare keys.
remove_at [BatRefList.Index] | Remove the element at the specified index raise `Invalid_index` if the index is outside `0 ; length-1`
remove_if [BatRefList] | Remove the first element matching the specified predicate raise `Not_found` if no element has been removed
remove_if [BatList.Labels] |
remove_if [BatList] | `remove_if cmp l` is similar to `remove`, but with `cmp` used instead of ( = ).
remove_if [BatLazyList.Labels] |
remove_if [BatLazyList] | `remove_if cmp l` is similar to `remove`, but with `cmp` used instead of ( = ).
remove_range [BatISet] | `remove_range lo hi t` removes a range of elements from the given set, returning a new set
remove_range [BatIMap] | Remove any bindings within the given range
rename [BatUnix] | `rename old new` changes the name of a file from `old` to `new`.
rename [BatSys] | Rename a file.
repeat [BatString.Cap] |
repeat [BatString] | `repeat s n` returns `s ^ s ^ ... ^ s`
repeat [BatEnum] | `repeat ~times:n x` creates a enum sequence filled with `n` times of `x`.
replace [BatText] | `replace ~str ~sub ~by` returns a tuple constisting of a boolean and a rope where the first occurrence of the rope `sub` within `str` has been replaced by the rope `by`.
replace [BatString.Cap] |
replace [BatString] | `replace ~str ~sub ~by` returns a tuple consisting of a boolean and a string where the first occurrence of the string `sub` within `str` has been replaced by the string `by`.
replace [BatInnerWeaktbl] | `Weaktbl.replace tbl x y` replaces the current binding of `x` in `tbl` by a binding of `x` to `y`.
replace [BatHashtbl.Cap.Labels] |
replace [BatHashtbl.Cap] |
replace [BatHashtbl.S.Labels] |
replace [BatHashtbl.S] |
replace [BatHashtbl.Labels] |
replace [BatHashtbl] | `Hashtbl.replace tbl x y` replaces the current binding of `x` in `tbl` by a binding of `x` to `y`.
replace_chars [BatString.Cap] |
replace_chars [BatString] | `replace_chars f s` returns a string where all chars `c` of `s` have been replaced by the string returned by `f c`.
reserved_names [BatGenlex.Languages.Definition] |
reset [BatUTF8.Buf] | Empty the buffer and de-allocate the internal storage.
reset [BatBuffer] | Empty the buffer and deallocate the internal string holding the buffer contents, replacing it with the initial internal string of length `n` that was allocated by `Buffer.create` `n`.
reshape [BatBigarray] | `reshape b [|d1;...;dN|]` converts the big array `b` to a `N`-dimensional array of dimensions `d1`...
reshape_1 [BatBigarray] | Specialized version of `Bigarray.reshape` for reshaping to one-dimensional arrays.
reshape_2 [BatBigarray] | Specialized version of `Bigarray.reshape` for reshaping to two-dimensional arrays.
reshape_3 [BatBigarray] | Specialized version of `Bigarray.reshape` for reshaping to three-dimensional arrays.
restart_on_EINTR [BatUnix] | `restart_on_EINTR f x` invokes `f` on `x` repetedly until the function returns a value or raises another exception than EINTR.
return [BatReturn] | Return to a label.
return [BatResult.Monad] | Monadic return, just encapsulates the given value with Ok
return [BatParserCo] | A parser which always succeds
return [BatOption.Monad] | `return x` puts a value in the Option monad, that is, returns `Some x`.
return [BatInterfaces.Monad] | Return a value, that is, put a value in the monad.
return [BatEnum.Monad] | This function puts a single value in the BatEnum monad, that is to say it creates an enumeration containing a single element.
rev [BatString] | `string s` returns the reverse of string `s`
rev [BatRefList] | Reverses the ref list - O(n)
rev [BatOrd] | Reverse a given ordering.
rev [BatList] | List reversal.
rev [BatLazyList] | Eager list reversal.
rev [BatDllist] | List reversal.
rev [BatDeque] | `rev dq` reverses `dq`.
rev [BatArray.Cap] |
rev [BatArray] | Array reversal.
rev_append [BatList] | `List.rev_append l1 l2` reverses `l1` and concatenates it to `l2`.
rev_append [BatLazyList] | Eager reverse-and-append
rev_comp [BatOrd] |
rev_comp0 [BatOrd] |
rev_drop [BatDllist] | Remove node from the list no matter where it is.
rev_enum [BatDllist] | Create a reverse enum of the list.
rev_in_place [BatString] | `rev_in_place s` mutates the string `s`, so that its new value is the mirror of its old one: for instance if s contained `"Example!"`, after the mutation it will contain `"!elpmaxE"`.
rev_in_place [BatArray.Cap] |
rev_in_place [BatArray] | In-place array reversal.
rev_map [BatList.Labels] |
rev_map [BatList] | `List.rev_map f l` gives the same result as `List.rev``(``List.map` `f l)`.
rev_map2 [BatList.Labels] |
rev_map2 [BatList] | `List.rev_map2 f l1 l2` gives the same result as `List.rev``(``List.map2` `f l1 l2)`, but is tail-recursive and more efficient.
rev_ord [BatOrd] |
rev_ord0 [BatOrd] |
reverse [BatFingerTree.S] | `reverse t` is equivalent to `of_list (List.rev (to_list t))`.
rewinddir [BatUnix] | Reposition the descriptor to the beginning of the directory
rfind [BatText] | `rfind s x` returns the starting index of the last occurrence of rope `x` within rope `s`.
rfind [BatString.Cap.Exceptionless] |
rfind [BatString.Cap] |
rfind [BatString.Exceptionless] | `rfind s x` returns `Some i`, the starting index of the last occurrence of string `x` within string `s`, or `None` if `x` is not a substring of `s`.
rfind [BatString] | `rfind s x` returns the starting index of the last occurrence of string `x` within string `s`.
rfind [BatRefList] | Find the first element in the reversed ref list matching the specified predicate raise `Not_found` if no element is found
rfind [BatList.Labels.LExceptionless] |
rfind [BatList.Labels] |
rfind [BatList.Exceptionless] | `rfind p l` returns `Some x` where `x` is the last element of `l` such that `p x` returns `true` or `None` if such element as not been found.
rfind [BatList] | `rfind p l` returns the last element `x` of `l` such as `p x` returns `true` or
rfind [BatLazyList.Labels.Exceptionless] |
rfind [BatLazyList.Labels] |
rfind [BatLazyList.Exceptionless] | `rfind p l` returns `Some x` where `x` is the last element of `l` such that `p x` returns `true` or `None` if such element as not been found.
rfind [BatLazyList] | `rfind p l` returns the last element `x` of `l` such as `p x` returns `true`.
rfind_exn [BatLazyList.Labels] |
rfind_exn [BatLazyList] | `find_exn p e l` returns the last element of `l` such as `p x` returns `true` or raises `e` if such an element has not been found.
rfind_from [BatText] | `rfind_from s ofs x` behaves as `rfind s x` but starts searching at offset `ofs`.
rfind_from [BatString.Cap.Exceptionless] |
rfind_from [BatString.Cap] |
rfind_from [BatString.Exceptionless] | `rfind_from s ofs x` behaves as `rfind s x` but starts searching at offset `ofs`.
rfind_from [BatString] | `rfind_from s pos x` behaves as `rfind s x` but starts searching from the right at position `pos + 1`.
rfindi [BatLazyList.Labels.Exceptionless] |
rfindi [BatLazyList.Labels] |
rfindi [BatLazyList.Exceptionless] | `findi p e l` returns `Some (i, ai)` where `ai` and `i` are respectively the last element of `l` and its index, such that `p i ai` is true, or `None` if no such element has been found.
rfindi [BatLazyList] | `findi p e l` returns the last element `ai` of `l` along with its index `i` such that `p i ai` is true.
right [BatText] | `left r len` returns the rope containing the `len` last characters of `r`
right [BatString.Cap] |
right [BatString] | `left r len` returns the string containing the `len` last characters of `r`.
right [BatArray] | `left r len` returns the array containing the `len` last characters of `r`.
right_branch [BatAvlTree] |
rindex [BatText] | `Rope.rindex s c` returns the position of the rightmost occurrence of character `c` in rope `s`.
rindex [BatSubstring] | `rindex sus c` returns the index of the last occurence of `c` in `sus` or
rindex [BatString.Cap.Exceptionless] |
rindex [BatString.Cap] |
rindex [BatString.Exceptionless] | `rindex s c` returns `Some p`, the position of the rightmost occurrence of character `c` in string `s` or `None` if `c` does not occur in `s`.
rindex [BatString] | `String.rindex s c` returns the character number of the last occurrence of character `c` in string `s`.
rindex [BatPathGen.StringType] |
rindex_from [BatText] | Same as `BatText.rindex`, but start searching at the character position given as second argument.
rindex_from [BatSubstring] | `index_from sus i c` returns the index of the last occurence of `c` in `sus` before the index `i` or
rindex_from [BatString.Cap.Exceptionless] |
rindex_from [BatString.Cap] |
rindex_from [BatString.Exceptionless] | Same as `String.Exceptionless.rindex`, but start searching at the character position given as second argument.
rindex_from [BatString] | `String.rindex_from s i c` returns the character number of the last occurrence of character `c` in string `s` before position `i+1`.
rindex_of [BatList] | `rindex_of e l` returns the index of the last occurrence of `e` in `l`, or `None` if there is no occurrence of `e` in `l`
rindex_of [BatLazyList] | `index_of e l` returns the index of the last occurrence of `e` in `l`, or `None` if there is no occurrence of `e` in `l`
rindex_ofq [BatList] | `rindex_ofq e l` behaves as `rindex_of e l` except it uses physical equality
rindex_ofq [BatLazyList] | `rindex_ofq e l` behaves as `rindex_of e l` except it uses physical equality
rmdir [BatUnix] | Remove an empty directory.
root [BatPathGen.PathType] | Root of the filesystem (`[""]`).
root [BatFloat] | `root x n` calculates the nth root of x.
root [BatAvlTree] |
rope_enum [BatteriesPrint] |
rope_pset [BatteriesPrint] |
round [BatNum] |
round [BatFloat] | `round x` rounds `x` to the nearest integral floating-point (the nearest of `floor x` and `ceil x`).
round_num [BatNum] |
round_to_int [BatFloat] | `round_to_int x` is `int_of_float (round x)`.
round_to_string [BatFloat] | `round_to_string ~digits:d x` will return a string representation of `x` -- in base 10 -- rounded to `d` digits after the decimal point.
rsplit [BatText] | `rsplit s sep` splits the rope `s` between the last occurrence of `sep`.
rsplit [BatString.Cap.Exceptionless] |
rsplit [BatString.Cap] |
rsplit [BatString.Exceptionless] | `rsplit s sep` splits the string `s` between the last occurrence of `sep`, or returns `None` if the separator is not found.
rsplit [BatString] | `rsplit s sep` splits the string `s` between the last occurrence of `sep`, and returns the two parts before and after the occurence (excluded).
run [BatParserCo] | `run p s` executes parser `p` on source `s`.
run_initializers [BatOo.Internal] |
run_initializers_opt [BatOo.Internal] |
S
s [BatPathGen.PathType] | = `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`
saturate_of_ord [BatBounded] | `saturate_of_ord ~bounds:(low, high) ord` will returning a bounding function using `ord` for value comparison and `low` and `high` for values which fall outside of the requested range.
scan [BatStream.StreamLabels] |
scan [BatStream] | `scan` is similar to `scanl` but without the `init` value: `scanl f init [< 'e0; 'e1; 'e2; ... >]` is equivalent to `[< 'e0; '(f e0 e1); '(f (f e0 e1) e2); ... >]`
scan [BatParserCo] | Use a parser to extract list of tokens, but return that list of tokens instead of whatever the original parser returned.
scan [BatEnum] | `scan` is similar to `scanl` but without the `init` value: if `e` contains `x0`, `x1`, `x2` ..., `scan f e` is the enumeration containing `x0`, `f x0 x1`, `f (f x0 x1) x2`...
scanf [BatScanf] | Same as `Scanf.bscanf`, but reads from the predefined scanning buffer `Scanf.Scanning.stdib` that is connected to `stdin`.
scanl [BatStream.StreamLabels] |
scanl [BatStream] | `scanl f init stream` returns a stream of successive reduced values from the left: `scanl f init [< 'e0; 'e1; ... >]` is equivalent to `[< 'init; '(f init e0); '(f (f init e0) e1); ... >]`
scanl [BatPervasives] | Functional loop on an enumeration, used to build an enumeration from both an enumeration and an initial value.
scanl [BatEnum] | A variant of `fold` producing an enumeration of its intermediate values.
second [BatTuple.Tuple5] |
second [BatTuple.Tuple4] |
second [BatTuple.Tuple3] |
second [BatTuple.Tuple2] | Equivalent to `Pervasives.snd`.
select [BatUnix] | Wait until some input/output operations become possible on some channels.
self_init [BatRandom] | Initialize the generator with a more-or-less random seed chosen in a system-dependent way.
send [BatUnix] | Send data over a connected socket.
send [BatOo.Internal] |
sendcache [BatOo.Internal] |
sendself [BatOo.Internal] |
sendto [BatUnix] | Send data over an unconnected socket.
seq [BatLazyList] | `seq init step cond` creates a sequence of data, which starts from `init`, extends by `step`, until the condition `cond` fails.
seq [BatEnum.Labels] |
seq [BatEnum] | `seq init step cond` creates a sequence of data, which starts from `init`, extends by `step`, until the condition `cond` fails.
sequence [BatEnum.WithMonad] | `sequence e` evaluates each monadic elements (of type `'a m`) contained in the enumeration `e` to get a monadic enumeration of `'a` elements, of type `'a BatEnum.t m`.
set [BatVect.RANDOMACCESS] |
set [BatVect.Make] | `set v n c` returns a copy of the `v` vect where the (n+1)th element (see also `get`) has been set to `c`.
set [BatVect] | `set v n c` returns a copy of the `v` vect where the (n+1)th element (see also `get`) has been set to `c`.
set [BatText] | `set r n c` returns a copy of rope `r` where the (n+1)th character has been set to `c`.
set [BatString.Cap] |
set [BatString] | `String.set s n c` modifies string `s` in place, replacing the character number `n` by `c`.
set [BatRefList.Index] | Change the element at the specified index raise `Invalid_index` if the index is outside `0 ; length-1`
set [BatRef] | As `:=`
set [BatOptParse.Opt] | Set the value of an option.
set [BatGlobal] | Set the global value contents.
set [BatGc] | `set r` changes the GC parameters according to the `control` record `r`.
set [BatFingerTree] | `set t i v` returns `t` where the `i`-th element is now `v`.
set [BatDynArray] | `set darr idx v` sets the element of `darr` at index `idx` to value `v`.
set [BatDllist] | Given a node, set the data associated with that node.
set [BatBitSet] | `set s n` sets the `n`th-bit in the bitset `s` to true.
set [BatBigarray.Array3] | `Array3.set a x y v`, or alternatively `a.{x,y,z} <- v`, stores the value `v` at coordinates (`x`, `y`, `z`) in `a`.
set [BatBigarray.Array2] | `Array2.set a x y v`, or alternatively `a.{x,y} <- v`, stores the value `v` at coordinates (`x`, `y`) in `a`.
set [BatBigarray.Array1] | `Array1.set a x v`, also written `a.{x} <- v`, stores the value `v` at index `x` in `a`.
set [BatBigarray.Genarray] | Assign an element of a generic big array.
set [BatArray.Cap] |
set [BatArray] | `Array.set a n x` modifies array `a` in place, replacing element number `n` with `x`.
set_all_formatter_output_functions [BatFormat] | `set_all_formatter_output_functions out flush outnewline outspace` redirects the pretty-printer output to the functions `out` and `flush` as described in `set_formatter_output_functions`.
set_browser [BatteriesConfig] |
set_close_on_exec [BatUnix] | Set the ``close-on-exec'' flag on the given descriptor.
set_ellipsis_text [BatFormat] | Set the text of the ellipsis printed when too many boxes are opened (a single dot, `.`, by default).
set_formatter_out_channel [BatFormat] | Redirect the pretty-printer output to the given channel.
set_formatter_output [BatFormat] | Sets the output of the formatter to the given argument
set_formatter_output_functions [BatFormat] | `set_formatter_output_functions out flush` redirects the relevant pretty-printer output functions to the functions `out` and `flush`.
set_formatter_tag_functions [BatFormat] |
set_full_state [BatParserCo.Source] |
set_margin [BatFormat] | `set_margin d` sets the value of the right margin to `d` (in characters): this value is used to detect line overflows that leads to split lines.
set_mark_tags [BatFormat] | `set_print_tags b` turns on or off the printing of tags, while `set_mark_tags b` turns on or off the output of tag markers.
set_max_boxes [BatFormat] | `set_max_boxes max` sets the maximum number of boxes simultaneously opened.
set_max_indent [BatFormat] | `set_max_indent d` sets the value of the maximum indentation limit to `d` (in characters): once this limit is reached, boxes are rejected to the left, if they do not fit on the current line.
set_method [BatOo.Internal] |
set_methods [BatOo.Internal] |
set_nonblock [BatUnix] | Set the ``non-blocking'' flag on the given descriptor.
set_permissions [BatFile] | Set the permissions on a file.
set_print_tags [BatFormat] |
set_resizer [BatDynArray] | Change the resizer for this array.
set_signal [BatSys] | Same as `Sys.signal` but return value is ignored.
set_state [BatRandom] | Set the state of the generator used by the basic functions.
set_tab [BatFormat] | Sets a tabulation mark at the current insertion point.
set_tags [BatFormat] | `set_tags b` turns on or off the treatment of tags (default is off).
set_to_map [BatIMap] | `set_to_map s x` returns a map where every element of `s` is bound to `x`.
setgid [BatUnix] | Set the real group id and effective group id for the process.
setgroups [BatUnix] | `setgroups groups` sets the supplementary group IDs for the calling process.
setitimer [BatUnix] | `setitimer t s` sets the interval timer `t` and returns its previous status.
setsid [BatUnix] | Put the calling process in a new session and detach it from its controlling terminal.
setsockopt [BatUnix] | Set or clear a boolean-valued option in the given socket.
setsockopt_float [BatUnix] | Same as `Unix.setsockopt` for a socket option whose value is a floating-point number.
setsockopt_int [BatUnix] | Same as `Unix.setsockopt` for an integer-valued socket option.
setsockopt_optint [BatUnix] | Same as `Unix.setsockopt` for a socket option whose value is an `int option`.
setuid [BatUnix] | Set the real user id and effective user id for the process.
shift [BatVect.Make] | Return the first element of a vector and its last `n-1` elements.
shift [BatVect] | Return the first element of a vector and its last `n-1` elements.
shift_left [BatNativeint] | `Nativeint.shift_left x y` shifts `x` to the left by `y` bits.
shift_left [BatInt64] | `Int64.shift_left x y` shifts `x` to the left by `y` bits.
shift_left [BatInt32] | `Int32.shift_left x y` shifts `x` to the left by `y` bits.
shift_left_big_int [BatBig_int] | `shift_left_big_int b n` returns `b` shifted left by `n` bits.
shift_right [BatNativeint] | `Nativeint.shift_right x y` shifts `x` to the right by `y` bits.
shift_right [BatInt64] | `Int64.shift_right x y` shifts `x` to the right by `y` bits.
shift_right [BatInt32] | `Int32.shift_right x y` shifts `x` to the right by `y` bits.
shift_right_big_int [BatBig_int] | `shift_right_big_int b n` returns `b` shifted right by `n` bits.
shift_right_logical [BatNativeint] | `Nativeint.shift_right_logical x y` shifts `x` to the right by `y` bits.
shift_right_logical [BatInt64] | `Int64.shift_right_logical x y` shifts `x` to the right by `y` bits.
shift_right_logical [BatInt32] | `Int32.shift_right_logical x y` shifts `x` to the right by `y` bits.
shift_right_towards_zero_big_int [BatBig_int] | `shift_right_towards_zero_big_int b n` returns `b` shifted right by `n` bits.
should [BatParserCo] | Prevent backtracking.
shuffle [BatRandom] | `shuffle e` returns a new array, containing the same set of elements as `e`, but in a random order.
shutdown [BatUnix] | Shutdown a socket connection.
shutdown_connection [BatUnix] | ``Shut down'' a connection established with `Unix.open_connection`; that is, transmit an end-of-file condition to the server reading on the other side of the connection.
sigabrt [BatSys] | Abnormal termination
sigalrm [BatSys] | Timeout
sigchld [BatSys] | Child process terminated
sigcont [BatSys] | Continue
sigfpe [BatSys] | Arithmetic exception
sighup [BatSys] | Hangup on controlling terminal
sigill [BatSys] | Invalid hardware instruction
sigint [BatSys] | Interactive interrupt (ctrl-C)
sigkill [BatSys] | Termination (cannot be ignored)
sign [BatNum] | Return `-1`, `0` or `1` according to the sign of the argument.
sign_big_int [BatBig_int] | Return `0` if the given big integer is zero, `1` if it is positive, and `-1` if it is negative.
sign_num [BatNum] |
signal [BatSys] | Set the behavior of the system on receipt of a given signal.
signbit [BatFloat] |
signed_bytes_of [BatIO] | Read an enumeration of signed 8-bit integers.
sigpending [BatUnix] | Return the set of blocked signals that are currently pending.
sigpipe [BatSys] | Broken pipe
sigprocmask [BatUnix] | `sigprocmask cmd sigs` changes the set of blocked signals.
sigprof [BatSys] | Profiling interrupt
sigquit [BatSys] | Interactive termination
sigsegv [BatSys] | Invalid memory reference
sigstop [BatSys] | Stop
sigsuspend [BatUnix] | `sigsuspend sigs` atomically sets the blocked signals to `sigs` and waits for a non-ignored, non-blocked signal to be delivered.
sigterm [BatSys] | Termination
sigtstp [BatSys] | Interactive stop
sigttin [BatSys] | Terminal read from background process
sigttou [BatSys] | Terminal write from background process
sigusr1 [BatSys] | Application-defined signal 1
sigusr2 [BatSys] | Application-defined signal 2
sigvtalrm [BatSys] | Timeout in virtual time
sin [BatFloat.Safe_float] | See `BatFloat.Safe_float.atan2`.
sin [BatFloat] | See `BatFloat.atan2`.
single_write [BatUnix] | Same as `write`, but attempts to write only once.
singleton [BatVect.Make] | Returns a vect of length 1 holding only the given element.
singleton [BatVect] | Returns a vect of length 1 holding only the given element.
singleton [BatSet.PSet] | Creates a new set with the single given element in it.
singleton [BatSet.S] | `singleton x` returns the one-element set containing only `x`.
singleton [BatSet] | Creates a new set with the single given element in it.
singleton [BatMap.PMap] | creates a new map with a single binding
singleton [BatMap.S] | `singleton x y` returns the one-element map that contains a binding `y` for `x`.
singleton [BatMap] | creates a new map with a single binding
singleton [BatList] | Create a list consisting of exactly one element.
singleton [BatISet] | Return the singleton set containing only the given element
singleton [BatIMap] |
singleton [BatFingerTree.S] | `singleton elt` build the sequence containing `elt` as its sole element.
singleton [BatEnum] | Create an enumeration consisting of exactly one element.
singleton [BatArray] | Create an array consisting of 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 [BatFingerTree.S] | `size t` returns the number of elements in the sequence.
size [BatFingerTree] | `size t` returns the number of elements in the sequence.
size [BatDeque] | `size dq` is the number of elements in the `dq`.
size_of [BatFile] | `size_of name` returns the size of file `name` in bytes.
size_of_big [BatFile] | `size_of_big name` returns the size of file `name` in bytes, as a 64-bit integer.
skip [BatEnum] | `skip n e` removes the first `n` element from the enumeration, if any, then returns `e`.
skip [BatDllist] | `skip n i` Return the node that is `i` nodes after node `n` in the list.
sleep [BatUnix] | Stop execution for the given number of seconds.
slice [BatText] | `slice ?first ?last s` returns a "slice" of the rope which corresponds to the characters `s.[first]`, `s.[first+1]`, ..., `s[last-1]`.
slice [BatSubstring] | `slice sus i' None` returns the substring `(s, i+i', n-i')`, where `sus = (s, i, n)`.
slice [BatString.Cap] |
slice [BatString] | `slice ?first ?last s` returns a "slice" of the string which corresponds to the characters `s.[first]`, `s.[first+1]`, ..., `s[last-1]`.
slice_left [BatBigarray.Array2] | Extract a row (one-dimensional slice) of the given two-dimensional big array.
slice_left [BatBigarray.Genarray] | Extract a sub-array of lower dimension from the given big array by fixing one or several of the first (left-most) coordinates.
slice_left_1 [BatBigarray.Array3] | Extract a one-dimensional slice of the given three-dimensional big array by fixing the first two coordinates.
slice_left_2 [BatBigarray.Array3] | Extract a two-dimensional slice of the given three-dimensional big array by fixing the first coordinate.
slice_right [BatBigarray.Array2] | Extract a column (one-dimensional slice) of the given two-dimensional big array.
slice_right [BatBigarray.Genarray] | Extract a sub-array of lower dimension from the given big array by fixing one or several of the last (right-most) coordinates.
slice_right_1 [BatBigarray.Array3] | Extract a one-dimensional slice of the given three-dimensional big array by fixing the last two coordinates.
slice_right_2 [BatBigarray.Array3] | Extract a two-dimensional slice of the given three-dimensional big array by fixing the last coordinate.
snoc [BatFingerTree.S] | `snoc t elt` adds `elt` to the right of `t`.
snoc [BatDeque] | `snoc x dq` adds `x` to the rear of `dq`.
socket [BatUnix] | Create a new socket in the given domain, and with the given kind.
socketpair [BatUnix] | Create a pair of unnamed sockets, connected together.
sort [BatRefList] | Sort elements using the specified comparator
sort [BatList] | Sort a list in increasing order according to a comparison function.
sort [BatLazyList] | Sort the list using optional comparator (by default `compare`).
sort [BatArray.Cap.Labels] |
sort [BatArray.Cap] |
sort [BatArray.Labels] |
sort [BatArray] | Sort an array in increasing order according to a comparison function.
sort_unique [BatList] | `sort_unique cmp l` returns the list `l` sorted and without any duplicate element.
source [BatPathGen.StringType.Parse] |
source_map [BatParserCo] |
source_of_enum [BatCharParser] | Create a source from a latin-1 character.
source_of_string [BatCharParser] | Create a source from a latin-1 character string.
span [BatSubstring] | `span sus1 sus2` returns a substring spanning from the start of `sus1` to the end of `sus2`, provided this is well-defined: `sus1` and `sus2` must have the same underlying string, and the start of `sus1` must not be to the right of the end of `sus2`; otherwise
span [BatList] | `span`, applied to a predicate `p` and a list `xs`, returns a tuple where first element is longest prefix (possibly empty) of xs of elements that satisfy p and second element is the remainder of the list.
span [BatEnum] | `span test e` produces two enumerations `(hd, tl)`, such that `hd` is the same as `take_while test e` and `tl` is the same as `drop_while test e`.
splice [BatText] | `splice s off len rep` returns the rope in which the section of `s` indicated by `off` and `len` has been cut and replaced by `rep`.
splice [BatString.Cap] |
splice [BatString] | `String.splice s off len rep` cuts out the section of `s` indicated by `off` and `len` and replaces it by `rep`
splice [BatDllist] | `splice n1 n2` Connects `n1` and `n2` so that `next n1 == n2 && prev n2 == n1`.
split [BatText] | `split s sep` splits the rope `s` between the first occurrence of `sep`.
split [BatString.Cap.Exceptionless] |
split [BatString.Cap] | Splitting around
split [BatString.Exceptionless] | `split s sep` splits the string `s` between the first occurrence of `sep`, or returns `None` if the separator is not found.
split [BatString] | `split s sep` splits the string `s` between the first occurrence of `sep`, and returns the two parts before and after the occurence (excluded).
split [BatStream] | `split` is the opposite of `comb`
split [BatSet.PSet] | `split x s` returns a triple `(l, present, r)`, where `l` is the set of elements of `s` that are strictly less than `x`; `r` is the set of elements of `s` that are strictly greater than `x`; `present` is `false` if `s` contains no element equal to `x`, or `true` if `s` contains an element equal to `x`.
split [BatSet.S] | `split x s` returns a triple `(l, present, r)`, where `l` is the set of elements of `s` that are strictly less than `x`; `r` is the set of elements of `s` that are strictly greater than `x`; `present` is `false` if `s` contains no element equal to `x`, or `true` if `s` contains an element equal to `x`.
split [BatSet] | `split x s` returns a triple `(l, present, r)`, where `l` is the set of elements of `s` that are strictly less than `x`; `r` is the set of elements of `s` that are strictly greater than `x`; `present` is `false` if `s` contains no element equal to `x`, or `true` if `s` contains an element equal to `x`.
split [BatSeq] | `split s = (map fst s, map snd s)`.
split [BatPathGen.PathType] | Dissect the path to its components (parent path, core part of name and possibly an extension).
split [BatMap.PMap] | `split x m` returns a triple `(l, data, r)`, where `l` is the map with all the bindings of `m` whose key is strictly less than `x`; `r` is the map with all the bindings of `m` whose key is strictly greater than `x`; `data` is `None` if `m` contains no binding for `x`, or `Some v` if `m` binds `v` to `x`.
split [BatMap.S] | `split x m` returns a triple `(l, data, r)`, where `l` is the map with all the bindings of `m` whose key is strictly less than `x`; `r` is the map with all the bindings of `m` whose key is strictly greater than `x`; `data` is `None` if `m` contains no binding for `x`, or `Some v` if `m` binds `v` to `x`.
split [BatMap] | `split x m` returns a triple `(l, data, r)`, where `l` is the map with all the bindings of `m` whose key is strictly less than `x`; `r` is the map with all the bindings of `m` whose key is strictly greater than `x`; `data` is `None` if `m` contains no binding for `x`, or `Some v` if `m` binds `v` to `x`.
split [BatList] | Transform a list of pairs into a pair of lists: `split [(a0,b0); (a1,b1); ...; (an,bn)]` is `([a0; a1; ...; an], [b0; b1; ...; bn])`.
split [BatFingerTree.Generic] | `split p t`, when `p` is monotonic, returns `(t1, t2)` where `t1` is the longest prefix of `t` whose measure does not satifies `p`, and `t2` is the rest of `t`.
split_at [BatSubstring] | `split_at sus k` returns the pair `(sus1, sus2)` of substrings, where `sus1` contains the first `k` characters of `sus`, and `sus2` contains the rest.
split_at [BatList.Labels.LExceptionless] |
split_at [BatList.Exceptionless] | Whenever `n` is inside of `l` size bounds, `split_at n l` returns `Ok(l1,l2)`, where `l1` contains the first `n` elements of `l` and `l2` contains the others.
split_at [BatList] | `split_at n l` returns two lists `l1` and `l2`, `l1` containing the first `n` elements of `l` and `l2` the others.
split_at [BatLazyList.Labels.Exceptionless] |
split_at [BatLazyList.Exceptionless] | Whenever `n` is inside of `l` size bounds, `split_at n l` returns ``Ok (l1,l2)`, where `l1` contains the first `n` elements of `l` and `l2` contains the others.
split_at [BatLazyList] | `split_at n l` returns two lists `l1` and `l2`, `l1` containing the first `n` elements of `l` and `l2` the others.
split_at [BatFingerTree] | `split_at` is equivalent to `List.split_at`.
split_leftmost [BatAvlTree] |
split_nth [BatList] | Obsolete.
split_nth [BatLazyList] | Obsolete.
split_on_char [BatSubstring] | `split_on_char c ss` returns substrings of input `ss` as divided by `c`
split_on_comma [BatSubstring] |
split_on_dot [BatSubstring] |
split_on_pipe [BatSubstring] |
split_on_slash [BatSubstring] |
split_rightmost [BatAvlTree] |
splitl [BatSubstring] | `splitl p sus` splits `sus` into a pair `(sus1, sus2)` of substrings where `sus1` is the longest prefix (left substring) all of whose characters satisfy `p`, and `sus2` is the rest.
splitr [BatSubstring] | `splitr p sus` splits `sus` into a pair `(sus1, sus2)` of substrings where `sus2` is the longest suffix (right substring) all of whose characters satisfy `p`, and `sus1` is the rest.
sprintf [BatPrintf] | A function which doesn't print its result but returns it as a string.
sprintf [BatFormat] | Same as `printf` above, but instead of printing on a formatter, returns a string containing the result of formatting the arguments.
sprintf2 [BatPrintf] | A function which doesn't print its result but returns it as a string.
sqrt [BatFloat] | Square root.
sqrt [BatComplex] | Square root.
sqrt2 [BatFloat] | `sqrt 2.`
sqrt_big_int [BatBig_int] | `sqrt_big_int a` returns the integer square root of `a`, that is, the largest big integer `r` such that `r * r <= a`.
sqrtpi2 [BatFloat] | `2. *. sqrt pi`
square [BatNum] |
square_big_int [BatBig_int] | Return the square of the given big integer
square_num [BatNum] |
sscanf [BatScanf] | Same as `Scanf.bscanf`, but reads from the given string.
sscanf_format [BatScanf] | Same as `Scanf.bscanf_format`, but reads from the given string.
stable_sort [BatList.Labels] |
stable_sort [BatList] | Same as `List.sort`, but the sorting algorithm is guaranteed to be stable (i.e.
stable_sort [BatLazyList] |
stable_sort [BatArray.Cap.Labels] |
stable_sort [BatArray.Cap] |
stable_sort [BatArray.Labels] |
stable_sort [BatArray] | Same as `Array.sort`, but the sorting algorithm is stable (i.e.
start [BatGenlex.Languages.Make] | Medium-level API
starts_with [BatText] | `starts_with s x` returns `true` if `s` is starting with `x`, `false` otherwise.
starts_with [BatString.Cap] |
starts_with [BatString] | `starts_with s x` returns `true` if `s` is starting with `x`, `false` otherwise.
stat [BatUnix.LargeFile] |
stat [BatUnix] | Return the information for the named file.
stat [BatGc] | Return the current values of the memory management counters in a `stat` record.
state [BatParserCo] | Succeed and return the state of the parser
stats [BatOo.Internal] |
std_formatter [BatFormat] | The standard formatter used by the formatting functions above.
stdbuf [BatFormat] | The string buffer in which `str_formatter` writes.
stderr [BatUnix] | File descriptor for standard error.
stderr [BatPervasives] | Standard error output, as per Unix/Windows conventions.
stderr [BatInnerIO] | Standard error output, as per Unix/Windows conventions.
stderr [BatIO] | Standard error output, as per Unix/Windows conventions.
stderr_formatter [BatLogger] | `stderr_formatter` is a standard formatter that outputs log events to stderr using the same format as `make_std_formatter`.
stdib [BatScanf.Scanning] | The scanning buffer reading from `stdin`.
stdin [BatUnix] | File descriptor for standard input.
stdin [BatPervasives] | Standard input, as per Unix/Windows conventions (by default, keyboard).
stdin [BatInnerIO] | Standard input, as per Unix/Windows conventions (by default, keyboard).
stdin [BatIO] | Standard input, as per Unix/Windows conventions (by default, keyboard).
stdnull [BatPervasives] | An output which discards everything written to it.
stdnull [BatInnerIO] | An output which discards everything written to it.
stdnull [BatIO] | An output which discards everything written to it.
stdout [BatUnix] | File descriptor for standard output.
stdout [BatPervasives] | Standard output, as per Unix/Windows conventions (by default, console).
stdout [BatInnerIO] | Standard output, as per Unix/Windows conventions (by default, console).
stdout [BatIO] | Standard output, as per Unix/Windows conventions (by default, console).
step_resizer [BatDynArray] | The stepwise resizer- another example of a resizer function, this time of a parameterized resizer.
store_const [BatOptParse.StdOpt] | `store_const ?default const` returns a flag option which stores the constant value `const` when the option is encountered on the command line.
store_false [BatOptParse.StdOpt] | `store_false ()` returns an option which is set to false when it is encountered on the command line.
store_true [BatOptParse.StdOpt] | `store_true ()` returns an option which is set to true when it is encountered on the command line.
str_callback [BatOptParse.StdOpt] | See `OptParse.StdOpt.int_callback`.
str_decode [BatBase64] | Decode a string encoded into Base64, raise `Invalid_char` if a character in the input string is not a valid one.
str_encode [BatBase64] | Encode a string into Base64.
str_formatter [BatFormat] | A formatter to use with formatting functions below for output to the `stdbuf` string buffer.
str_int_pmap [BatteriesPrint] |
str_option [BatOptParse.StdOpt] | See `OptParse.StdOpt.int_option`.
str_str_pmap [BatteriesPrint] |
string [BatGenlex.Languages.Make] | As `CharParser.string`, but case-insensitive if specified by `case_sensitive`.
string [BatDigest] | Return the digest of the given string.
string [BatCharParser] | Recognize exactly one string
string_dynarray [BatteriesPrint] |
string_enum [BatteriesPrint] |
string_literal [BatGenlex.Languages.Make] | Accepts a string, i.e.
string_of [BatUnit] | Convert the given unit to a string.
string_of_big_int [BatBig_int] | Return the string representation of the given big integer, in decimal (base 10).
string_of_cap [BatteriesPrint] |
string_of_inet_addr [BatUnix] | Return the printable representation of the given Internet address.
string_of_num [BatNum] |
string_of_token [BatGenlex] |
string_pset [BatteriesPrint] |
string_set [BatteriesPrint] |
strings_of [BatIO] | Read an enumeration of null-terminated strings.
strip [BatText] | Returns the rope without the chars if they are at the beginning or at the end of the rope.
strip [BatString.Cap] |
strip [BatString] | Returns the string without the chars if they are at the beginning or at the end of the string.
sub [BatVect.RANDOMACCESS] |
sub [BatVect.Make] | `sub m n r` returns a sub-vect of `r` containing all the elements whose indexes range from `m` to `m + n - 1` (included).
sub [BatVect] | `sub m n r` returns a sub-vect of `r` containing all the elements whose indexes range from `m` to `m + n - 1` (included).
sub [BatText] | `sub r m n` returns a sub-rope of `r` containing all characters whose indexes range from `m` to `m + n - 1` (included).
sub [BatString.Cap] |
sub [BatString] | `String.sub s start len` returns a fresh string of length `len`, containing the substring of `s` that starts at position `start` and has length `len`.
sub [BatPathGen.StringType] | As `String.sub`, but indexed in specific way.
sub [BatNumber.Numeric] |
sub [BatNum] |
sub [BatNativeint] | Subtraction.
sub [BatInt64] | Subtraction.
sub [BatInt32] | Subtraction.
sub [BatInt.Safe_int] | Substraction.
sub [BatInt] | Subtraction.
sub [BatFloat.Safe_float] |
sub [BatFloat] |
sub [BatDynArray] | `sub darr start len` returns an array holding the subset of `len` elements from `darr` starting with the element at index `idx`.
sub [BatComplex] | Subtraction
sub [BatBuffer] | `Buffer.sub b off len` returns (a copy of) the substring of the current contents of the buffer `b` starting at offset `off` of length `len` bytes.
sub [BatBool] |
sub [BatBigarray.Array1] | Extract a sub-array of the given one-dimensional big array.
sub [BatBig_int] |
sub [BatArray.Cap.Labels] |
sub [BatArray.Cap] |
sub [BatArray.Labels] |
sub [BatArray] | `Array.sub a start len` returns a fresh array of length `len`, containing the elements number `start` to `start + len - 1` of array `a`.
sub_big_int [BatBig_int] | Subtraction.
sub_left [BatBigarray.Array3] | Extract a three-dimensional sub-array of the given three-dimensional big array by restricting the first dimension.
sub_left [BatBigarray.Array2] | Extract a two-dimensional sub-array of the given two-dimensional big array by restricting the first dimension.
sub_left [BatBigarray.Genarray] | Extract a sub-array of the given big array by restricting the first (left-most) dimension.
sub_num [BatNum] |
sub_right [BatBigarray.Array3] | Extract a three-dimensional sub-array of the given three-dimensional big array by restricting the second dimension.
sub_right [BatBigarray.Array2] | Extract a two-dimensional sub-array of the given two-dimensional big array by restricting the second dimension.
sub_right [BatBigarray.Genarray] | Extract a sub-array of the given big array by restricting the last (right-most) dimension.
subset [BatSet.PSet] | `subset a b` returns true if `a` is a subset of `b`.
subset [BatSet.S] | `subset s1 s2` tests whether the set `s1` is a subset of the set `s2`.
subset [BatSet] | `subset a b` returns true if `a` is a subset of `b`.
subset [BatISet] | `subset t u` returns `true` if `t` is a subset of `u`
substring [BatSubstring] | `substring s o l` returns a substring with base-string `s`, offset `o` and length `l`.
substring [BatDigest] | `Digest.substring s ofs len` returns the digest of the substring of `s` starting at character number `ofs` and containing `len` characters.
succ [BatNumber.Discrete] |
succ [BatNumber.Numeric] |
succ [BatNum] |
succ [BatNativeint] | Successor.
succ [BatInt64] | Successor.
succ [BatInt32] | Successor.
succ [BatInt.Safe_int] | Successor.
succ [BatInt] | Successor.
succ [BatFloat.Safe_float] | Add `1.` to a floating number.
succ [BatFloat] | Add `1.` to a floating number.
succ [BatComplex] | Add `BatComplex.one` to this number.
succ [BatBool] |
succ [BatBig_int] |
succ_big_int [BatBig_int] | Successor (add 1).
succ_num [BatNum] |
suffix_action [BatEnum] | `suffix_action f e` will behave as `e` but guarantees that `f ()` will be invoked after the contents of `e` are exhausted.
sum [BatList] | `sum l` returns the sum of the integers of `l`
sum [BatEnum] | `sum` returns the sum of the given int enum.
sum [BatArray] | `sum l` returns the sum of the integers of `l`
suspend [BatParserCo] | `suspend s` returns the state of the parser in a form that can be resumed by calling the returned function.
swap [BatTuple.Tuple2] |
swap [BatRef] | `swap a b` puts `!b` in `a` and `!a` in `b`
switch [BatStream.StreamLabels] |
switch [BatStream] | `switch test stream` split `stream` into two streams, where the first stream have all the elements satisfying `test`, the second stream is opposite.
switch [BatEnum.Labels] |
switch [BatEnum] | `switch test enum` splits `enum` into two enums, where the first enum have all the elements satisfying `test`, the second enum is opposite.
sym_diff [BatSet.PSet] | `sym_diff s t` returns the set of all elements in `s` or `t` but not both.
sym_diff [BatSet.S] | `sym_diff s t` returns the set of all elements in `s` or `t` but not both.
sym_diff [BatSet] | `sym_diff s t` returns the set of all elements in `s` or `t` but not both, also known as the symmetric difference.
sym_diff [BatBitSet] | `sym_diff s t` returns the symmetrical difference of `s` and `t`.
symlink [BatUnix] | `symlink source dest` creates the file `dest` as a symbolic link to the file `source`.
sync [BatConcurrent] | Specialized version of `synchronized`.
synchronize [BatRMutex] | Protect a function.
synchronize [BatMutex] | Protect a function.
synchronize [BatConcurrent.Lock] |
synchronize [BatConcurrent] | `synchronize locker f` returns a function `f'` which behaves as `f` but whose executions are protected by one lock obtained from `locker`.
synchronize_in [BatIO] | `synchronize_in inp` produces a new `BatIO.input` which reads from `input` in a thread-safe way.
synchronize_out [BatIO] | `synchronize_out out` produces a new `BatIO.output` which writes to `output` in a thread-safe way.
system [BatUnix] | Execute the given command, wait until it terminates, and return its termination status.
T
tab_out [BatIO] | Create an output shifted to the right by a number of spaces (or other character as specified by `tab`).
tail [BatText] | `tail r pos` returns the rope containing all but the `pos` first characters of `r`
tail [BatString.Cap] |
tail [BatString] | `tail r pos` returns the string containing all but the `pos` first characters of `r`
tail [BatFingerTree.S] | `tail t` returns `None` when `t` is empty, or `Some tl` where `tl` is the sequence `t` where the first element has been removed.
tail [BatArray] | `tail r pos` returns the array containing all but the `pos` first characters of `r`
tail_exn [BatFingerTree.S] | `tail_exn t` returns the sequence `t` where the first element has been removed.
take [BatStream] | `take n stream` returns the prefix of `stream` of length `n`, or `stream` itself if `n` is greater than the length of `stream`
take [BatSeq] | `take n s` returns up to the `n` first elements from sequence `s`, if available.
take [BatQueue.Exceptionless] |
take [BatQueue] | `take q` removes and returns the first element in queue `q`, or raises `Empty` if the queue is empty.
take [BatList] | `take n l` returns up to the `n` first elements from list `l`, if available.
take [BatLazyList] | `take n l` returns up to the `n` first elements from list `l`, if available.
take [BatEnum] | `take n e` returns the prefix of `e` of length `n`, or `e` itself if `n` is greater than the length of `e`
take_while [BatStream.StreamLabels] |
take_while [BatStream] | `take_while test stream` returns the longest (possibly empty) prefix of `stream` of elements that satisfy `test`.
take_while [BatSeq] | `take_while f s` returns the first elements of sequence `s` which satisfy the predicate `f`.
take_while [BatList.Labels] |
take_while [BatList] | `take_while p xs` returns the (possibly empty) longest prefix of elements of `xs` that satisfy the predicate `p`.
take_while [BatLazyList.Labels] |
take_while [BatLazyList] | `take_while f xs` returns the first elements of list `xs` which satisfy the predicate `f`.
take_while [BatEnum.Labels] |
take_while [BatEnum] | `take_while f e` produces a new enumeration in which only remain the first few elements `x` of `e` such that `f x`
takel [BatSubstring] | `takel p sus` returns the longest prefix (left substring) of `sus` all of whose characters satisfy predicate `p`.
taker [BatSubstring] | `taker p sus` returns the longest suffix (right substring) of `sus` all of whose characters satisfy predicate `p`.
takewhile [BatList] | obsolete, as `BatList.take_while`
tan [BatFloat.Safe_float] | 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 [BatPervasives] | Allows application of a function in the middle of a pipe sequence without disturbing the sequence.
tap [BatInnerPervasives] |
tcdrain [BatUnix] | Waits until all output written on the given file descriptor has been transmitted.
tcflow [BatUnix] | Suspend or restart reception or transmission of data on the given file descriptor, depending on the second argument: `TCOOFF` suspends output, `TCOON` restarts output, `TCIOFF` transmits a STOP character to suspend input, and `TCION` transmits a START character to restart input.
tcflush [BatUnix] | Discard data written on the given file descriptor but not yet transmitted, or data received but not yet read, depending on the second argument: `TCIFLUSH` flushes data received but not read, `TCOFLUSH` flushes data written but not transmitted, and `TCIOFLUSH` flushes both.
tcgetattr [BatUnix] | Return the status of the terminal referred to by the given file descriptor.
tcsendbreak [BatUnix] | Send a break condition on the given file descriptor.
tcsetattr [BatUnix] | Set the status of the terminal referred to by the given file descriptor.
text_set [BatteriesPrint] |
third [BatTuple.Tuple5] |
third [BatTuple.Tuple4] |
third [BatTuple.Tuple3] |
time [BatUnix] | Return the current time since 00:00:00 GMT, Jan.
time [BatSys] | Return the processor time, in seconds, used by the program since the beginning of execution.
times [BatUnix] | Return the execution times of the process.
times [BatParserCo] | `times n p` accepts a list of `n` expressions accepted by `p`
titled_formatter [BatOptParse.Formatter] | Creates a titled formatter which is quite similar to the indented formatter.
tl [BatSeq.Exceptionless] |
tl [BatSeq] | Returns the sequence without its first elements or raise `Invalid_argument` if the sequence is empty.
tl [BatRefList] | Returns a ref list containing the same elements but without the first one or raises `Empty_list` if the ref list is empty
tl [BatList.Exceptionless] | `tl l` returns `Some x` such that `x` is the given list `l` without its first element.
tl [BatList] | Return the given list without its first element.
tl [BatLazyList] | Return the given list without its first element.
to_array [BatVect.Make] | `to_array r` returns an array corresponding to the vect `r`.
to_array [BatVect] | `to_array r` returns an array corresponding to the vect `r`.
to_array [BatLazyList] | Eager conversion to array.
to_array [BatDynArray] | `to_array darr` returns the elements of `darr` in order as an array.
to_array [BatBigarray.Array3] | Build a three-dimensional array initialized from the given big array.
to_array [BatBigarray.Array2] | Build a two-dimensional array initialized from the given big array.
to_array [BatBigarray.Array1] | Build a one-dimensional array initialized from the given big array.
to_array [BatArray.Cap] | Return a capability array as an array.
to_buffer [BatMarshal] | `Marshal.to_buffer buff ofs len v flags` marshals the value `v`, storing its byte representation in the string `buff`, starting at character number `ofs`, and writing at most `len` characters.
to_byte [BatInt32] |
to_channel [BatMarshal] |
to_container [BatVect.Make] | `to_container r` returns a container corresponding to the vect `r`.
to_enum_filter [BatGenlex] | Apply the lexer to an enum.
to_f_printer [BatIO] |
to_float [BatString.Cap.Exceptionless] |
to_float [BatString.Cap] |
to_float [BatString.Exceptionless] | Returns the float represented by the given string or `None` if the string does not represent a float.
to_float [BatString] | Returns the float represented by the given string or
to_float [BatNumber.Numeric] |
to_float [BatNum] |
to_float [BatNativeint] | Convert the given native integer to a floating-point number.
to_float [BatInt64] | Convert the given 64-bit integer to a floating-point number.
to_float [BatInt32] | Convert the given 32-bit integer to a floating-point number.
to_float [BatInt.Safe_int] | Convert the given integer to a floating-point number.
to_float [BatInt] | Convert the given integer to a floating-point number.
to_float [BatFloat.Safe_float] |
to_float [BatFloat] |
to_float [BatComplex] | `Complex.to_float (a+bi)` returns the float `a`
to_float [BatBool] |
to_float [BatBig_int] |
to_hex [BatDigest] | Return the printable hexadecimal representation of the given digest.
to_input_channel [BatIO] | Create a channel that will read from an input.
to_int [BatString.Cap.Exceptionless] |
to_int [BatString.Cap] |
to_int [BatString.Exceptionless] | Returns the integer represented by the given string or `None` if the string does not represent an integer.
to_int [BatString] | Returns the integer represented by the given string or
to_int [BatNumber.Discrete] |
to_int [BatNumber.Numeric] |
to_int [BatNum] |
to_int [BatNativeint] | Convert the given native integer (type `nativeint`) to an integer (type `int`).
to_int [BatInt64] | Convert the given 64-bit integer (type `int64`) to an integer (type `int`).
to_int [BatInt32] | Convert the given 32-bit integer (type `int32`) to an integer (type `int`).
to_int [BatInt.Safe_int] |
to_int [BatInt] |
to_int [BatFloat.Safe_float] |
to_int [BatFloat] |
to_int [BatComplex] | `to_int c` is the integer part of the real part of `c`
to_int [BatBool] |
to_int [BatBig_int] |
to_int32 [BatNativeint] | Convert the given native integer to a 32-bit integer (type `int32`).
to_int32 [BatInt64] | Convert the given 64-bit integer (type `int64`) to a 32-bit integer (type `int32`).
to_int64 [BatNativeint] | Convert the given native integer to a 64-bit integer (type `int64`).
to_int64 [BatInt32] | Convert the given 32-bit integer (type `int32`) to a 64-bit integer (type `int64`).
to_lazy_list_filter [BatGenlex] | Apply the lexer to a lazy list.
to_list [BatVect.Make] | Returns a list with the elements contained in the vect.
to_list [BatVect] | Returns a list with the elements contained in the vect.
to_list [BatString.Cap] |
to_list [BatString] | Converts a string to the list of its characters.
to_list [BatStream] | Convert a stream to a list
to_list [BatSplay.Map] |
to_list [BatRefList] | Returns the current elements as a list - O(1)
to_list [BatLazyList] | Eager conversion to string.
to_list [BatHeap.H] | See `BatHeap.to_list`.
to_list [BatHeap] | Enumerate the elements of the heap.
to_list [BatFingerTree.S] | `to_list t` is equivalent to `BatList.of_enum (enum t)`.
to_list [BatDynArray] | `to_list darr` returns the elements of `darr` in order as a list.
to_list [BatDllist] | Converts a dllist to a normal list.
to_list [BatDeque] | `to_list dq` is a list representation of the elements of `dq`.
to_list [BatArray.Cap] |
to_list [BatArray] | `Array.to_list a` returns the list of all the elements of `a`.
to_list_backwards [BatFingerTree.S] | `to_list_backwards t` is equivalent to `BatList.of_enum (backwards t)`.
to_nativeint [BatInt64] | Convert the given 64-bit integer (type `int64`) to a native integer.
to_nativeint [BatInt32] | Convert the given 32-bit integer (type `int32`) to a native integer.
to_object [BatEnum] | `to_object e` returns a representation of `e` as an object.
to_option [BatResult] | Convert a `result` to an `option`
to_stream [BatLazyList] | Lazy conversion to stream.
to_stream_filter [BatGenlex] | Apply the lexer to a stream.
to_string [BatText] | `to_string t` returns a UTF-8 encoded string representing `t`
to_string [BatSubstring] | `string sus` is the string s`i..i+n-1` represented by sus = (s, i, n).
to_string [BatString.Cap] | Return a capability string as a regular string.
to_string [BatStream] | convert stream of chars to string, using buffer
to_string [BatPrintexc] | `Printexc.to_string e` returns a string representation of the exception `e`.
to_string [BatPathGen.StringType] | Convert to primitive string with UTF-8 content.
to_string [BatPathGen.PathType] | Convert to type primitive string with UTF-8 content.
to_string [BatNumber.Numeric] |
to_string [BatNum] | Convert a number to a string, using fractional notation.
to_string [BatNativeint] | Return the string representation of its argument, in decimal.
to_string [BatMarshal] | `Marshal.to_string v flags` returns a string containing the representation of `v` as a sequence of bytes.
to_string [BatLog.Level_sig] | The default level for loggers created with this; log messages with level less than this won't be printed by default.
to_string [BatInt64] | Return the string representation of its argument, in decimal.
to_string [BatInt32] | Return the string representation of its argument, in signed decimal.
to_string [BatInt.Safe_int] | Return the string representation of its argument, in signed decimal.
to_string [BatInt] | Return the string representation of its argument, in signed decimal.
to_string [BatIO] |
to_string [BatFloat.Safe_float] |
to_string [BatFloat] |
to_string [BatComplex] |
to_string [BatBool] |
to_string [BatBig_int] |
to_string_fmt [BatStream.StreamLabels] |
to_string_fmt [BatStream] | convert stream to string, using Printf with given format
to_string_fun [BatStream.StreamLabels] |
to_string_fun [BatStream] | convert stream to string, using given conversion function
to_string_in_base [BatBig_int] | `to_string_in_base b n` returns the string representation in base `b` of the given big integer `n`.
to_string_in_binary [BatBig_int] | as `string_of_big_int`, but in base 2
to_string_in_custom_base [BatBig_int] | First argument, called `symbols`, is the vector of the symbols used to represent the digits in base `b`.
to_string_in_hexa [BatBig_int] | as `string_of_big_int`, but in base 16
to_string_in_octal [BatBig_int] | as `string_of_big_int`, but in base 8
to_table [BatHashtbl.Cap] | Return a capability hashtable as a regular hashtable.
to_ustring [BatPathGen.PathType] | Convert to the chosen `ustring` type.
toggle [BatRef] | Invert the boolean stored in the reference
toggle [BatBitSet] | `toggle s n` changes the nth-bit value in the bitset `s`.
tokens [BatSubstring] | `tokens p sus` returns the list of tokens in `sus`, from left to right, where a token is a non-empty maximal substring of `sus` not containing any delimiter, and a delimiter is a character satisfying `p`.
top [BatStack.Exceptionless] |
top [BatStack] | `top s` returns the topmost element in stack `s`, or
top [BatQueue] | `top` is a synonym for `peek`.
total_size [BatMarshal] | See `Marshal.header_size`.
transfer [BatQueue] | `transfer q1 q2` adds all of `q1`'s elements at the end of the queue `q2`, then clears `q1`.
transform [BatRefList] | transform all elements in the ref list using a function.
translate [BatSubstring] | `translate f sus` applies `f` to every character of `sus`, from left to right, and returns the concatenation of the results.
transpose [BatList] | Transposes a list of lists, turning rows of the input into columns of the output and vice versa.
trim [BatSubstring] | removes whitespace from left and right ends of input
trim [BatString.Cap] |
trim [BatString] | Return a copy of the argument, without leading and trailing whitespace.
triml [BatSubstring] | `triml k sus` returns sus less its leftmost k characters; or the empty string at the end of sus if it has less than k characters.
trimr [BatSubstring] | `trimr k sus` returns sus less its rightmost k characters; or the empty string at the beginning of sus if it has less than k characters.
truncate [BatUnix.LargeFile] |
truncate [BatUnix] | Truncates the named file to the given size.
try_lock [BatRMutex] | Same as `RMutex.lock`, but does not suspend the calling thread if the mutex is already locked: just return `false` immediately in that case.
try_lock [BatConcurrent.BaseLock] |
try_lock [BatConcurrent.Lock] |
U
uget [BatUref] | `uget ur` returns the value stored in the uref `ur`.
ui16s_of [BatIO.BigEndian] | Read an enumeration of unsigned 16-bit words.
ui16s_of [BatIO] | Read an enumeration of unsigned 16-bit words.
umask [BatUnix] | Set the process's file mode creation mask, and return the previous mask.
uncapitalize [BatString.Cap] |
uncapitalize [BatString] | Return a copy of the argument, with the first character set to lowercase.
uncombine [BatLazyList] | Divide a list of pairs into a pair of lists.
uncombine [BatEnum] | `uncombine` is the opposite of `combine`
uncurry [BatTuple.Tuple5] |
uncurry [BatTuple.Tuple4] |
uncurry [BatTuple.Tuple3] |
uncurry [BatTuple.Tuple2] |
uncurry [BatPervasives] | Convert a function which accepts a two arguments into a function which accepts a pair of arguments.
uncurry [BatInnerPervasives] |
undef [BatGlobal] | Reset the global value contents to undefined.
undefined [BatPervasives] | The undefined function.
unfold [BatList] | `unfold init f` creates a list by repeatedly applying `f` to the second element of its own result, starting from the initial value `init`.
unfold [BatLazyList] | `unfold data next` creates a (possibly infinite) lazy list from the successive results of applying `next` to `data`, then to the result, etc.
unfold [BatEnum.Labels] |
unfold [BatEnum] | As `from_loop`, except uses option type to signal the end of the enumeration.
union [BatSet.PSet] | `union s t` returns the union of `s` and `t` - the set containing all elements in either `s` and `t`.
union [BatSet.S] | Set union.
union [BatSet] | `union s t` returns the union of `s` and `t` - the set containing all elements in either `s` and `t`.
union [BatMap.PMap] | `union m1 m2` merges two maps, using the comparison function of `m1`.
union [BatMap] | `union m1 m2` merges two maps, using the comparison function of `m1`.
union [BatISet] | Compute the union of two sets.
union [BatIMap] | Merge two maps, giving a value
union [BatBitSet] | `union s t` return the union of sets `s` and `t`.
uniq [BatEnum] | `uniq e` returns a duplicate of `e` with repeated values omitted.
unique [BatPervasives] | Returns an unique identifier every time it is called.
unique [BatList] | `unique cmp l` returns the list `l` without any duplicate element.
unique [BatLazyList] | `unique cmp l` returns the list `l` without any duplicate element.
unique [BatInnerPervasives] |
unique_cmp [BatList] | As `unique`, except comparator parameter returns an int.
unique_eq [BatLazyList] | as `unique` except only uses an equality function.
unique_hash [BatList] | As `unique`, except uses a hash table to cut down the expected runtime to linear, assuming a good hash function.
unique_value [BatInnerPervasives] |
unit_big_int [BatBig_int] | The big integer `1`.
unite [BatUref] | `unite ~sel ur1 ur2` unites the urefs `ur1` and `ur2`, selecting the result of `sel (uget ur1) (uget ur2)` for the contents of the resulting united uref.
unite [BatBitSet] | `unite s t` sets `s` to the union of the sets `s` and `t`.
unix_perm [BatFile] | Create a permission from a Unix-style octal integer.
unlink [BatUnix] | Removes the named file
unlock [BatRMutex] | Unlock the given mutex.
unlock [BatConcurrent.BaseLock] |
unlock [BatConcurrent.Lock] |
unpack [BatInt32] | `unpack str off` reads 4 bytes from string `str` starting at offset `off` as a little-endian int32
unpack_big [BatInt32] | `unpack str off` reads 4 bytes from string `str` starting at offset `off` as a big-endian int32
unregister_formatter [BatLogger] | `unregister_formatter name` unregisters a named log formatter.
unsafe_get [BatVect.RANDOMACCESS] |
unsafe_get [BatDynArray] |
unsafe_get [BatBigarray.Array3] | Like `Bigarray.Array3.get`, but bounds checking is not always performed.
unsafe_get [BatBigarray.Array2] | Like `Bigarray.Array2.get`, but bounds checking is not always performed.
unsafe_get [BatBigarray.Array1] | Like `Bigarray.Array1.get`, but bounds checking is not always performed.
unsafe_set [BatVect.RANDOMACCESS] |
unsafe_set [BatDynArray] |
unsafe_set [BatBigarray.Array3] | Like `Bigarray.Array3.set`, but bounds checking is not always performed.
unsafe_set [BatBigarray.Array2] | Like `Bigarray.Array2.set`, but bounds checking is not always performed.
unsafe_set [BatBigarray.Array1] | Like `Bigarray.Array1.set`, but bounds checking is not always performed.
unsafe_substring [BatSubstring] | `unsafe_substring` behaves like `substring`, but does not perform any sanity check on the position and length.
unset [BatBitSet] | `unset s n` sets the `n`th-bit in the bitset `s` to false.
until [BatISet] | `until x t` returns the portion of `t` in the range `min_int, x`
until [BatIMap] | Return the sub-map of bindings in the range `min_int, x`
update [BatFingerTree] | `update t i f` returns `t` where the `i`-th element is now `f (get i t)`.
uppercase [BatString.Cap] |
uppercase [BatString] | Return a copy of the argument, with all lowercase letters translated to uppercase, including accented letters of the ISO Latin-1 (8859-1) character set.
uppercase [BatCharParser] | Recognizes one upper-case ASCII character, including accentuated characters.
uppercase [BatChar] | Convert the given character to its equivalent uppercase character.
uppercase_latin1 [BatCharParser] | Recognizes one upper-case Latin-1 character, including accentuated characters.
uref [BatUref] | `uref x` allocates a new uref and places the value `x` in it.
usage [BatOptParse.OptParser] | Display the usage message to the channel `chn` (default is `Pervasives.stdout`) and return.
user_exec [BatFile] | Give the current user permission to execute the file.
user_read [BatFile] | Give the current user permission to read the file.
user_write [BatFile] | Give the current user permission to write the file
uset [BatUref] | `uset ur x` updates the contents of `ur` with `x`.
utimes [BatUnix] | Set the last access time (second arg) and last modification time (third arg) for a file.
V
validate [BatUTF8] | `validate s` successes if s is valid UTF-8, otherwise raises Malformed_code.
value_option [BatOptParse.Opt] | Make an option which takes a single argument.
values [BatMap.PMap] | Return an enumeration of al the values of a map.
values [BatMap.S] | Return an enumeration of al the values of a map.
values [BatMap] | Return an enumeration of al the values of a map.
values [BatHashtbl.Cap] |
values [BatHashtbl.S] |
values [BatHashtbl] | Return an enumeration of all the values of a hashtable.
verify_arg [BatPervasives] | `verify_arg condition message` will raise `Invalid_argument message` if `condition` is false, otherwise it does nothing.
version [BatteriesConfig] |
version_option [BatOptParse.StdOpt] | `version_option f` returns the standard version option which displays the string returned by `f ()` (and nothing else) on standard output and exits.
W
wait [BatUnix] | Wait until one of the children processes die, and return its pid and termination status.
waitpid [BatUnix] | Same as `Unix.wait`, but waits for the child process whose pid is given.
while_do [BatEnum] | `while_do cont f e` is a loop on `e` using `f` as body and `cont` as condition for continuing.
whitespace [BatCharParser] | Recognizes white-space
whitespaces [BatGenlex.Languages.Make] |
widen [BatOo.Internal] |
with_dispose [BatPervasives] | `with_dispose dispose f x` invokes `f` on `x`, calling `dispose x` when `f` terminates (either with a return value or an exception).
with_dispose [BatInnerPervasives] |
with_file_in [BatFile] | `with_file_in file_name f` opens the file named `file_name` for reading, invokes `f` to process the contents of that file then, once `f` has returned or triggered an exception, closes the file before proceeding.
with_file_out [BatFile] | `with_file_out file_name f` opens the file named `file_name` for writing, invokes `f` to write onto that file then, once `f` has returned or triggered an exception, closes the file before proceeding.
with_label [BatReturn] | as `label`
with_log [BatLogger] | `with_log logger level event_fun ?result body` logs an event before and after calling `body ()`.
with_temporary_out [BatFile] | `with_temporary_out f` opens a new temporary file for writing, invokes `f` with to write onto that file then, once `f` has returned or triggered an exception, closes the file before proceeding.
word_size [BatteriesConfig] |
word_size [BatSys] | Size of one word on the machine currently executing the OCaml program, in bits: 32 or 64.
would_at_fail [BatLazyList] | `would_at_fail l n` returns `true` if `l` contains strictly less than `n` elements, `false` otherwise
wrap [BatPervasives] | `wrap f x` wraps a function that would normally throw an exception on failure such that it now returns a result with either the `Ok` return value or the `Bad` exception.
wrap [BatOptParse.Formatter] | `wrap text width` reflows the given text paragraph into lines of width at most `width` (lines may exceed this if the are single words that exceed this limit).
wrap [BatInnerPervasives] |
wrap_in [BatInnerIO] | Fully create an input reading from other inputs by giving all the needed functions.
wrap_in [BatIO] | Fully create an input reading from other inputs by giving all the needed functions.
wrap_out [BatInnerIO] | Fully create an output that writes to one or more underlying outputs.
wrap_out [BatIO] | Fully create an output that writes to one or more underlying outputs.
write [BatUnix] | `write fd buff ofs len` writes `len` characters to descriptor `fd`, taking them from string `buff`, starting at position `ofs` in string `buff`.
write [BatInnerIO] | Write a single char to an output.
write [BatIO] | Write a single char to an output.
write_bits [BatIO] | Write up to 31 bits represented as a value, raise Bits_error if nbits < 0 or nbits > 31 or the value representation excess nbits.
write_bitss [BatIO] | Write an enumeration of bits
write_byte [BatInnerIO] | Write an unsigned 8-bit byte.
write_byte [BatIO] | Write an unsigned 8-bit byte.
write_char [BatText] | Write one uchar to a UTF-8 encoded output.
write_double [BatInnerIO] | Write an IEEE double precision floating point value.
write_double [BatIO.BigEndian] | Write an IEEE double precision floating point value.
write_double [BatIO] | Write an IEEE double precision floating point value.
write_float [BatInnerIO] | Write an IEEE single precision floating point value.
write_float [BatIO.BigEndian] | Write an IEEE single precision floating point value.
write_float [BatIO] | Write an IEEE single precision floating point value.
write_i16 [BatInnerIO] | Write a signed 16-bit word.
write_i16 [BatIO.BigEndian] | Write a signed 16-bit word.
write_i16 [BatIO] | Write a signed 16-bit word.
write_i32 [BatInnerIO] | Write a signed 32-bit integer.
write_i32 [BatIO.BigEndian] | Write a signed 32-bit integer.
write_i32 [BatIO] | Write a signed 32-bit integer.
write_i64 [BatInnerIO] | Write an OCaml int64.
write_i64 [BatIO.BigEndian] | Write an OCaml int64.
write_i64 [BatIO] | Write an OCaml int64.
write_line [BatText] | Write one line onto a UTF-8 encoded output, followed by a \n.
write_line [BatInnerIO] | Write a line and append a LF (it might be converted to CRLF on some systems depending on the underlying BatIO).
write_line [BatIO] | Write a line and append a line end.
write_lines [BatFile] | `write_lines name lines` writes strings given by `lines` to file `name` with newline character appended to each line.
write_only [BatString.Cap] | Drop capabilities to write only.
write_only [BatHashtbl.Cap] | Drop to write-only permissions.
write_only [BatArray.Cap] | Drop to write-only permissions.
write_real_i32 [BatInnerIO] | Write an OCaml int32.
write_real_i32 [BatIO.BigEndian] | Write an OCaml int32.
write_real_i32 [BatIO] | Write an OCaml int32.
write_string [BatInnerIO] | Write a string and append an null character.
write_string [BatIO] | Write a string and append an null character.
write_text [BatText] | Write a character text onto a UTF-8 encoded output.
write_ui16 [BatInnerIO] | Write an unsigned 16-bit word.
write_ui16 [BatIO.BigEndian] | Write an unsigned 16-bit word.
write_ui16 [BatIO] | Write an unsigned 16-bit word.
X
xor_big_int [BatBig_int] | Bitwise logical ``exclusive or''.
Z
zero [BatNumber.Numeric] |
zero [BatNum] | Usual operations
zero [BatNativeint] | The native integer 0.
zero [BatInt64] | The 64-bit integer 0.
zero [BatInt32] | The 32-bit integer 0.
zero [BatInt.Safe_int] | The integer `0`.
zero [BatInt] | The integer `0`.
zero [BatFloat.Safe_float] | Floating number zero.
zero [BatFloat] | Floating number zero.
zero [BatComplex] | The complex number `0`.
zero [BatBool] |
zero [BatBig_int] |
zero_big_int [BatBig_int] | The big integer `0`.
zero_plus [BatParserCo] | Accept a (possibly empty) list of expressions.