( * ) [BatNum] | |||
( * ) [BatNativeint] | |||
( * ) [BatInt64] | |||
( * ) [BatInt.Safe_int] |
Multiplication.
| ||
( * ) [BatInt] |
Multiplication.
| ||
( * ) [BatFloat.Safe_float] | |||
( * ) [BatFloat] | |||
( * ) [BatComplex] | |||
( * ) [BatBounded.NumericSig] | |||
( * ) [BatBool] | |||
( * ) [BatNumber.Infix] | |||
( * ) [BatBig_int] | |||
( ** ) [BatNum] | |||
( ** ) [BatNativeint] | |||
( ** ) [BatInt64] | |||
( ** ) [BatInt.Safe_int] | a ** b computes ab
| ||
( ** ) [BatInt] | a ** b computes ab
| ||
( ** ) [BatFloat.Safe_float] | |||
( ** ) [BatFloat] | |||
( ** ) [BatComplex] | |||
( ** ) [BatBool] | |||
( ** ) [BatNumber.Infix] | |||
( ** ) [BatBig_int] | |||
( **/ ) [BatNum.Infix] | |||
( **/ ) [BatNum.TaggedInfix] | |||
( **/ ) [BatNum] | |||
( */ ) [BatNum.Infix] | |||
( */ ) [BatNum.TaggedInfix] | |||
( */ ) [BatNum] | |||
( *: ) [BatBounded.NumericSig] | |||
( *= ) [BatNumber.RefOps] | |||
( ~* ) [BatParserCo.Infix] | |||
( ~* ) [BatParserCo] |
As
zero_plus without arguments.
| ||
(!!) [BatPathGen.PathType.OperatorLift] |
Prefix operator that converts primitive string to
ustring .
| ||
(!) [BatRef] | !r returns the current contents of reference r .
| ||
(%) [BatPervasives] |
Function composition: the mathematical
o operator.
| ||
(%) [BatInnerPervasives] | |||
(%>) [BatPervasives] |
Piping function composition.
| ||
(%>) [BatInnerPervasives] | |||
(&&) [BatBool] |
The boolean ``and''.
| ||
(+) [BatNum] | |||
(+) [BatNativeint] | |||
(+) [BatInt64] | |||
(+) [BatInt.Safe_int] |
Addition.
| ||
(+) [BatInt] |
Addition.
| ||
(+) [BatFloat.Safe_float] | |||
(+) [BatFloat] | |||
(+) [BatComplex] | |||
(+) [BatBounded.NumericSig] | |||
(+) [BatBool] | |||
(+) [BatNumber.Infix] | |||
(+) [BatBig_int] | |||
(+/) [BatNum.Infix] | |||
(+/) [BatNum.TaggedInfix] | |||
(+/) [BatNum] | |||
(+:) [BatBounded.NumericSig] | |||
(+=) [BatNumber.RefOps] | |||
(-) [BatNum] | |||
(-) [BatNativeint] | |||
(-) [BatInt64] | |||
(-) [BatInt.Safe_int] |
Substraction.
| ||
(-) [BatInt] |
Subtraction.
| ||
(-) [BatFloat.Safe_float] | |||
(-) [BatFloat] | |||
(-) [BatComplex] | |||
(-) [BatBounded.NumericSig] | |||
(-) [BatBool] | |||
(-) [BatNumber.Infix] | |||
(-) [BatBig_int] | |||
(--) [BatSeq.Infix] | |||
(--) [BatPervasives] |
Enumerate numbers.
| ||
(--) [BatNumber.Discrete] | |||
(--) [BatNativeint] |
Enumerate an interval.
| ||
(--) [BatInt64] |
Enumerate an interval.
| ||
(--) [BatInt32] |
Enumerate an interval.
| ||
(--) [BatInt] |
Enumerate an interval.
| ||
(--) [BatFloat] | |||
(--) [BatEnum.Infix] |
As
range , without the label.
| ||
(--) [BatEnum] | |||
(--) [BatComplex] | |||
(--) [BatChar.Infix] | |||
(--) [BatChar] |
Produce the enumeration of a segment of characters.
| ||
(--) [BatBool] | |||
(--) [BatNumber.Infix] | |||
(--) [BatBig_int] | |||
(---) [BatSeq.Infix] | |||
(---) [BatPervasives] |
As
-- , but accepts enumerations in reverse order.
| ||
(---) [BatNumber.Discrete] | |||
(---) [BatNativeint] |
Enumerate an interval.
| ||
(---) [BatInt64] |
Enumerate an interval.
| ||
(---) [BatInt32] |
Enumerate an interval.
| ||
(---) [BatInt] |
Enumerate an interval.
| ||
(---) [BatFloat] | |||
(---) [BatEnum.Infix] |
As
-- , but accepts enumerations in reverse order.
| ||
(---) [BatEnum] | |||
(---) [BatComplex] | |||
(---) [BatBool] | |||
(---) [BatNumber.Infix] | |||
(---) [BatBig_int] | |||
(--.) [BatSeq.Infix] | |||
(--.) [BatPervasives] | (a, step) --. b) creates a float enumeration from a to b with an
increment of step between elements.
| ||
(--.) [BatEnum.Infix] | (a, step) --. b) creates a float enumeration from a to b with an
increment of step between elements.
| ||
(--.) [BatEnum] | |||
(-->) [BatMultiPMap.Infix] | map-->key returns the current binding of key in map .
| ||
(-->) [BatMultiMap.Infix] | map-->key returns the current binding of key in map .
| ||
(-->) [BatMap.PMap.Infix] | map-->key returns the current binding of key in map ,
or raises Not_found .
| ||
(-->) [BatMap.PMap] |
Map find and insert from Infix
| ||
(-->) [BatMap.Infix] | map-->key returns the current binding of key in map ,
or raises Not_found .
| ||
(-->) [BatMap.S.Infix] | map-->key returns the current binding of key in map ,
or raises Not_found .
| ||
(-->) [BatMap] |
Map find and insert from Infix
| ||
(-->) [BatIMap.Infix] | map-->key returns the current binding of key in map ,
or
| ||
(-->) [BatHashtbl.S.Infix] | tbl-->x returns the current binding of x in tbl ,
or raises Not_found if no such binding exists.
| ||
(-->) [BatHashtbl.Infix] | tbl-->x returns the current binding of x in tbl ,
or raises Not_found if no such binding exists.
| ||
(--^) [BatSeq.Infix] | |||
(--^) [BatPervasives] |
Enumerate numbers, without the right endpoint
| ||
(--^) [BatEnum.Infix] |
As
(--) but without the right endpoint
| ||
(--^) [BatEnum] | |||
(--~) [BatSeq.Infix] | |||
(--~) [BatPervasives] |
As ( -- ), but for characters.
| ||
(--~) [BatEnum.Infix] |
As ( -- ), but for characters.
| ||
(--~) [BatEnum] | |||
(-/) [BatNum.Infix] | |||
(-/) [BatNum.TaggedInfix] | |||
(-/) [BatNum] | |||
(-:) [BatBounded.NumericSig] | |||
(-=) [BatNumber.RefOps] | |||
(/) [BatNum] | |||
(/) [BatNativeint] | |||
(/) [BatInt64] | |||
(/) [BatInt.Safe_int] |
Integer division.
| ||
(/) [BatInt] |
Integer division.
| ||
(/) [BatFloat.Safe_float] | |||
(/) [BatFloat] | |||
(/) [BatComplex] | |||
(/) [BatBounded.NumericSig] | |||
(/) [BatBool] | |||
(/) [BatNumber.Infix] | |||
(/) [BatBig_int] | |||
(//) [BatSeq.Infix] | |||
(//) [BatPervasives] |
Filtering (pronounce this operator name "such that").
| ||
(//) [BatNum.Infix] | |||
(//) [BatNum.TaggedInfix] | |||
(//) [BatNum] | |||
(//) [BatEnum.Infix] |
Filtering (pronounce this operator name "such that").
| ||
(//) [BatEnum] | |||
(//@) [BatSeq.Infix] | |||
(//@) [BatPervasives] | |||
(//@) [BatPathGen.PathType.Infix] | |||
(//@) [BatPathGen.PathType.Operators] | basepath//@relpath catenates two paths.
| ||
(//@) [BatEnum.Infix] | |||
(//@) [BatEnum] | |||
(/:) [BatPathGen.PathType.Infix] | |||
(/:) [BatPathGen.PathType.Operators] | path/:name is a path of name located in a directory path .
| ||
(/:) [BatBounded.NumericSig] | |||
(/=) [BatNumber.RefOps] | |||
(/@) [BatSeq.Infix] | |||
(/@) [BatPervasives] | |||
(/@) [BatEnum.Infix] | |||
(/@) [BatEnum] | |||
(:=) [BatRef] | r := a stores the value of a in reference r .
| ||
(<) [BatInt.Safe_int] |
Comparaison:
a < b is true if and only if a is strictly smaller than b .
| ||
(<) [BatInt] | |||
(<) [BatNumber.Compare] | |||
(<--) [BatMultiPMap.Infix] | map<--(key, value) returns a map containing the same bindings as
map , plus a binding of key to value .
| ||
(<--) [BatMultiMap.Infix] | map<--(key, value) returns a map containing the same bindings as
map , plus a binding of key to value .
| ||
(<--) [BatMap.PMap.Infix] | map<--(key, value) returns a map containing the same bindings as
map , plus a binding of key to value .
| ||
(<--) [BatMap.PMap] | |||
(<--) [BatMap.Infix] | map<--(key, value) returns a map containing the same bindings as
map , plus a binding of key to value .
| ||
(<--) [BatMap.S.Infix] | map<--(key, value) returns a map containing the same bindings as
map , plus a binding of key to value .
| ||
(<--) [BatMap] | |||
(<--) [BatIMap.Infix] | map<--(key, value) returns a map containing the same bindings as
map , plus a binding of key to value .
| ||
(<--) [BatHashtbl.S.Infix] | tbl<--(x, y) adds a binding of x to y in table tbl .
| ||
(<--) [BatHashtbl.Infix] | tbl<--(x, y) adds a binding of x to y in table tbl .
| ||
(</) [BatNum.Infix] | |||
(</) [BatNum.TaggedInfix] | |||
(</) [BatNum] | |||
(<=) [BatInt.Safe_int] |
Comparaison:
a <= b is true if and only if a is smaller or equalto b .
| ||
(<=) [BatInt] | |||
(<=) [BatNumber.Compare] | |||
(<=/) [BatNum.Infix] | |||
(<=/) [BatNum.TaggedInfix] | |||
(<=/) [BatNum] | |||
(<>) [BatInt.Safe_int] |
Comparaison:
a <> b is true if and only if a and b have
different values.
| ||
(<>) [BatInt] | |||
(<>) [BatNumber.Compare] | |||
(<>/) [BatNum.Infix] | |||
(<>/) [BatNum.TaggedInfix] | |||
(<>/) [BatNum] | |||
(<|>) [BatParserCo.Infix] | |||
(<|>) [BatParserCo] |
Accept one of two parsers
| ||
(=) [BatInt.Safe_int] |
Comparaison:
a = b if and only if a and b have the same value.
| ||
(=) [BatInt] | |||
(=) [BatNumber.Compare] | |||
(=/) [BatNum.Infix] | |||
(=/) [BatNum.TaggedInfix] | |||
(=/) [BatNum] | |||
(=~) [BatFloat.Infix] |
Approximate comparison of two floats, as
approx_equal .
| ||
(>) [BatInt.Safe_int] |
Comparaison:
a > b is true if and only if a is strictly greater than b .
| ||
(>) [BatInt] | |||
(>) [BatNumber.Compare] | |||
(>/) [BatNum.Infix] | |||
(>/) [BatNum.TaggedInfix] | |||
(>/) [BatNum] | |||
(>::) [BatParserCo.Infix] | |||
(>::) [BatParserCo] |
As
cons
| ||
(>=) [BatInt.Safe_int] |
Comparaison:
a >= b is true if and only if a is greater or equal to b .
| ||
(>=) [BatInt] | |||
(>=) [BatNumber.Compare] | |||
(>=/) [BatNum.Infix] | |||
(>=/) [BatNum.TaggedInfix] | |||
(>=/) [BatNum] | |||
(>>=) [BatResult.Infix] | |||
(>>=) [BatResult.Monad] |
as
bind
| ||
(>>=) [BatParserCo.Infix] | |||
(>>=) [BatParserCo] |
As
bind
| ||
(>>>) [BatParserCo.Infix] | |||
(>>>) [BatParserCo] |
As
bind , but ignoring the result
| ||
(@) [BatPervasives] |
List concatenation.
| ||
(@) [BatList.Infix] | |||
(@) [BatList] |
Tail recursive
List.append .
| ||
(@/) [BatSeq.Infix] | |||
(@/) [BatPervasives] |
Mapping operators.
| ||
(@/) [BatEnum.Infix] |
Mapping operators.
| ||
(@/) [BatEnum] | |||
(@//) [BatSeq.Infix] | |||
(@//) [BatPervasives] |
Map combined with filter.
| ||
(@//) [BatEnum.Infix] |
Map combined with filter.
| ||
(@//) [BatEnum] | |||
(@@) [BatPervasives] | |||
(@@) [BatInnerPervasives] | |||
(^:^) [BatLazyList.Infix] | |||
(^:^) [BatLazyList] |
As
cons : x^:^l is the lazy list with head x and tail l
| ||
(^@^) [BatLazyList.Infix] | |||
(^@^) [BatLazyList] |
As lazy append
| ||
(^^) [BatParserCo.Infix] | |||
(^^) [BatParserCo] | p ^^ n is the same thing as times n p
| ||
(^^^) [BatText] | |||
(|>) [BatteriesPrint] | |||
(|>) [BatPervasives] |
The "pipe": function application.
| ||
(|>) [BatInnerPervasives] | |||
(|?) [BatPervasives] |
Like
BatOption.default , with the arguments reversed.
| ||
(|?) [BatOption.Infix] |
Like
BatOption.default , with the arguments reversed.
| ||
(|?) [BatOption] |
Like
BatOption.default , with the arguments reversed.
| ||
(|?) [BatInnerPervasives] | |||
(||) [BatBool] |
The boolean ``or''.
| ||
(~+) [BatParserCo.Infix] | |||
(~+) [BatParserCo] |
As
one_plus
| ||
(~?) [BatParserCo.Infix] | |||
(~?) [BatParserCo] |
As
maybe
| ||
A | |||
abs [BatNumber.Numeric] | |||
abs [BatNum] | |||
abs [BatNativeint] |
Return the absolute value of its argument.
| ||
abs [BatInt64] |
Return the absolute value of its argument.
| ||
abs [BatInt32] |
Return the absolute value of its argument.
| ||
abs [BatInt.Safe_int] |
Return the absolute value of its argument.
| ||
abs [BatInt] |
Return the absolute value of its argument, except when the argument is
min_num .
| ||
abs [BatFloat.Safe_float] |
The absolute value of a floating point number.
| ||
abs [BatFloat] |
The absolute value of a floating point number.
| ||
abs [BatComplex] | abs c returns the module of this complex number,
i.e.
| ||
abs [BatBool] | |||
abs [BatBig_int] | |||
abs_big_int [BatBig_int] |
Absolute value.
| ||
abs_num [BatNum] | |||
accept [BatUnix] |
Accept connections on the given socket.
| ||
access [BatUnix] |
Check that the process has the given permissions over the named
file.
| ||
acos [BatFloat.Safe_float] | |||
acos [BatFloat] |
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] | |||
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] | |||
atan [BatFloat] |
See
BatFloat.atan2 .
| ||
atan2 [BatFloat.Safe_float] |
The usual trigonometric functions.
| ||
atan2 [BatFloat] |
The usual trigonometric functions.
| ||
B | |||
backtrace_status [BatPrintexc] | Printexc.backtrace_status() returns true if exception
backtraces are currently recorded, false if not.
| ||
backwards [BatVect.RANDOMACCESS] | |||
backwards [BatVect.Make] |
Returns an enumeration of the elements of a vector, from last to first.
| ||
backwards [BatVect] |
Returns an enumeration of the elements of a vector, from last to first.
| ||
backwards [BatString.Cap] | |||
backwards [BatString] |
Returns an enumeration of the characters of a string, from last to first.
| ||
backwards [BatSet.S] |
Return an enumeration of all elements of the given set.
| ||
backwards [BatSet] |
Return an enumeration of all elements of the given set.
| ||
backwards [BatRefList] |
Returns an enumeration of current elements in the ref list, going from last to first
| ||
backwards [BatMap.PMap] |
creates an enumeration for this map, enumerating key,value pairs with the keys in decreasing order.
| ||
backwards [BatMap.S] |
Return an enumeration of (key, value) pairs of a map.
| ||
backwards [BatMap] |
creates an enumeration for this map, enumerating key,value pairs with the keys in decreasing order.
| ||
backwards [BatList] |
Returns an enumeration of the elements of a list.
| ||
backwards [BatFingerTree.S] | backwards t builds an enumeration of the elements of t going from
right to left.
| ||
backwards [BatDllist] | backwards t is similar to rev_enum t except that the enumeration
starts at the node before the current one:
| ||
backwards [BatArray.Cap] | |||
backwards [BatArray] |
Returns an enumeration of the elements of an array, from last to first.
| ||
balance [BatVect.Make] | balance r returns a balanced copy of the r vect.
| ||
balance [BatVect] | balance r returns a balanced copy of the r vect.
| ||
balance [BatText] | balance r returns a balanced copy of the r rope.
| ||
base [BatSubstring] | base sus is the concrete triple (s, i, n) , where psus = (s, i,
n) .
| ||
base_of_t [BatBounded.BoundedType] | base_of_t x converts a value of type BatBounded.BoundedType.t back to a BatBounded.BoundedType.base_t if
possible.
| ||
base_of_t_exn [BatBounded.BoundedType] | base_of_t_exn x converts a value of type BatBounded.BoundedType.t back to a BatBounded.BoundedType.base_t .
| ||
before [BatISet] | before x t returns the portion of t in the range min_int, x-1
| ||
before [BatIMap] |
Return the sub-map of bindings in the range
min_int, x-1
| ||
beginning_of_input [BatScanf.Scanning] | Scanning.beginning_of_input ib tests the beginning of input condition of
the given scanning buffer.
| ||
belongs [BatPathGen.PathType] | belongs base sub is true when sub descends from base , i.e.
| ||
big_endian [BatSys] |
Whether the machine currently executing the OCaml program is big-endian.
| ||
big_int_base_default_symbols [BatBig_int] |
Default vector of symbols used by
to_string_in_base and its fixed-base
derivatives to_string_in_binary , to_string_in_octal and to_string_in_hexa
to represent digits.
| ||
big_int_of_int [BatBig_int] |
Convert a small integer to a big integer.
| ||
big_int_of_int32 [BatBig_int] |
Convert a 32-bit integer to a big integer.
| ||
big_int_of_int64 [BatBig_int] |
Convert a 64-bit integer to a big integer.
| ||
big_int_of_nativeint [BatBig_int] |
Convert a native integer to a big integer.
| ||
big_int_of_num [BatNum] | |||
big_int_of_string [BatBig_int] |
Convert a string to a big integer, in decimal.
| ||
bin_comp [BatOrd] | |||
bin_eq [BatOrd] | |||
bin_ord [BatOrd] |
binary lifting of the comparison function, using lexicographic order:
bin_ord ord1 v1 v1' ord2 v2 v2' is ord2 v2 v2' if ord1 v1 v1' = Eq ,
and ord1 v1 v1' otherwhise.
| ||
bind [BatUnix] |
Bind a socket to an address.
| ||
bind [BatResult.Monad] |
Monadic composition.
| ||
bind [BatParserCo] |
Monadic-style combination:
| ||
bind [BatOption.Monad] | bind m f combines the calculation result m with the function f .
| ||
bind [BatOption] | bind (Some x) f returns f x and bind None f returns None .
| ||
bind [BatInterfaces.Monad] |
Monadic binding.
| ||
bind [BatEnum.Monad] | bind m f takes the result of the monadic computation m, puts the f function in the monadic context passing it the result of m and then
returning a monadic result.
| ||
bindings [BatMap.PMap] |
Return the list of all bindings of the given map.
| ||
bindings [BatMap.S] |
Return the list of all bindings of the given map.
| ||
bindings [BatMap] |
Return the list of all bindings of the given map.
| ||
bits [BatRandom.Incubator.Private_state_enums.State] | |||
bits [BatRandom.State] | |||
bits [BatRandom] |
Return 30 random bits in a nonnegative integer.
| ||
bits_of [BatIO] |
Read an enumeration of bits
| ||
bits_of_float [BatInt64] |
Return the internal representation of the given float according
to the IEEE 754 floating-point ``double format'' bit layout.
| ||
bits_of_float [BatInt32] |
Return the internal representation of the given float according
to the IEEE 754 floating-point ``single format'' bit layout.
| ||
blit [BatText] | blit src srcoff dst dstoff len returns a copy
of dst in which len characters have been copied
from rope src , starting at character number srcoff , to
rope dst , starting at character number dstoff .
| ||
blit [BatString.Cap] | |||
blit [BatString] | String.blit src srcoff dst dstoff len copies len characters
from string src , starting at character number srcoff , to
string dst , starting at character number dstoff .
| ||
blit [BatDynArray] | blit src srcidx dst dstidx len copies len elements from src
starting with index srcidx to dst starting at dstidx .
| ||
blit [BatBuffer] | Buffer.blit src srcoff dst dstoff len copies len characters from
the current contents of the buffer src , starting at offset srcoff
to string dst , starting at character dstoff .
| ||
blit [BatBigarray.Array3] |
Copy the first big array to the second big array.
| ||
blit [BatBigarray.Array2] |
Copy the first big array to the second big array.
| ||
blit [BatBigarray.Array1] |
Copy the first big array to the second big array.
| ||
blit [BatBigarray.Genarray] |
Copy all elements of a big array in another big array.
| ||
blit [BatArray.Cap.Labels] | |||
blit [BatArray.Cap] | |||
blit [BatArray.Labels] | |||
blit [BatArray] | Array.blit v1 o1 v2 o2 len copies len elements
from array v1 , starting at element number o1 , to array v2 ,
starting at element number o2 .
| ||
bool [BatRandom.Incubator.Private_state_enums.State] | |||
bool [BatRandom.State] | |||
bool [BatRandom] | Random.bool () returns true or false with probability 0.5 each.
| ||
bounded [BatBounded.BoundedType] | |||
bounding_of_ord [BatBounded] | bounding_of_ord ~default_low ~default_high conv ord will returning a
bounding function using ord for value comparison and default_low and
default_high for values which fall outside of the requested range.
| ||
bounding_of_ord_chain [BatBounded] | bounding_oF_ord_chain ?low ?high ord is like BatBounded.bounding_of_ord except
that functions are used to handle out of range values rather than single
default values.
| ||
bounds [BatBounded.BoundedType] | bounds defines the (min, max) bounds for the bounded range
| ||
bounds [BatBounded.S] | bounds defines the (min, max) bounds for the bounded range
| ||
bprintf [BatPrintf] |
As
BatPrintf.fprintf , but with buffers instead of outputs.
| ||
bprintf [BatFormat] |
A deprecated and error prone function.
| ||
bprintf2 [BatPrintf] |
As
BatPrintf.printf but writes to a buffer instead
of printing to the output.
| ||
break [BatEnum] |
Negated span.
| ||
browse [BatteriesConfig] | |||
bscanf [BatScanf] | bscanf ib fmt r1 ... rN f reads arguments for the function f , from the
scanning buffer ib , according to the format string fmt , and applies f
to these values.
| ||
bscanf_format [BatScanf] | bscanf_format ib fmt f reads a format string token from the scannning
buffer ib , according to the given format string fmt , and applies f to
the resulting format string value.
| ||
bytes_of [BatIO] |
Read an enumeration of unsigned 8-bit integers.
| ||
C | |||
c_layout [BatBigarray] | |||
callback_option [BatOptParse.Opt] |
Make a callback option which takes a single argument.
| ||
capacity [BatBitSet] |
Internals
| ||
capitalize [BatString.Cap] | |||
capitalize [BatString] |
Return a copy of the argument, with the first character set to uppercase.
| ||
cardinal [BatSet.PSet] |
Return the number of elements of a set.
| ||
cardinal [BatSet.S] |
Return the number of elements of a set.
| ||
cardinal [BatSet] |
Return the number of elements of a set.
| ||
cardinal [BatMap.PMap] |
Return the number of bindings of a map.
| ||
cardinal [BatMap.S] |
Return the number of bindings of a map.
| ||
cardinal [BatMap] |
Return the number of bindings of a map.
| ||
cardinal [BatISet] |
Returns the number of elements in the set
| ||
cartesian_product [BatList] |
Different from
List.combine , this returns every pair
of elements formed out of the two lists.
| ||
case_char [BatCharParser] |
As
char , but case-insensitive
| ||
case_sensitive [BatGenlex.Languages.Definition] | true if the language is case-sensitive, false otherwise.
| ||
case_string [BatCharParser] |
As
case_string , but case-insensitive
| ||
cast_output [BatInnerIO] |
You can safely transform any output to an unit output in a safe way
by using this function.
| ||
cast_output [BatIO] |
You can safely transform any output to an unit output in a safe way
by using this function.
| ||
catch [BatResult] |
Execute a function and catch any exception as a result.
| ||
catch [BatPrintexc] | Printexc.catch fn x is similar to Printexc.print , but aborts
the program with exit code 2 after printing the uncaught exception.
| ||
catch2 [BatResult] |
As
catch but two paramaters.
| ||
catch3 [BatResult] |
As
catch but three paramaters.
| ||
catch_break [BatSys] | catch_break governs whether interactive interrupt (ctrl-C)
terminates the program or raises Break .
| ||
ceil [BatNum] | |||
ceil [BatFloat.Safe_float] | |||
ceil [BatFloat] |
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] | |||
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 [BatString.Cap] | |||
contains [BatString] | String.contains s c tests if character c
appears in the string s .
| ||
contains_from [BatText] | contains_from s start c tests if character c appears in
the subrope of s starting from start to the end of s .
| ||
contains_from [BatString.Cap] | |||
contains_from [BatString] | String.contains_from s start c tests if character c
appears in s after position start .
| ||
contents [BatUTF8.Buf] | contents buf returns the contents of the buffer.
| ||
contents [BatBuffer] |
Return a copy of the current contents of the buffer.
| ||
copy [BatVect.RANDOMACCESS] | |||
copy [BatString.Cap] | |||
copy [BatString] |
Return a copy of the given string.
| ||
copy [BatStack] |
Return a copy of the given stack.
| ||
copy [BatRefList] |
Makes a copy of a ref list - O(1)
| ||
copy [BatRef] | copy r returns a new reference with the same initial
content as r .
| ||
copy [BatRandom.Incubator.Private_state_enums.State] |
Return a copy of the given state.
| ||
copy [BatRandom.State] |
Return a copy of the given state.
| ||
copy [BatQueue] |
Return a copy of the given queue.
| ||
copy [BatOo.Internal] | |||
copy [BatOo] | Oo.copy o returns a copy of object o , that is a fresh
object with the same methods and instance variables as o
| ||
copy [BatInnerWeaktbl] |
Return a copy of the given hashtable.
| ||
copy [BatIO] |
Read everything from an input and copy it to an output.
| ||
copy [BatHashtbl.Cap] | |||
copy [BatHashtbl.S] | |||
copy [BatHashtbl] |
Return a copy of the given hashtable.
| ||
copy [BatDynArray] | copy src returns a fresh copy of src , such that no modification of
src affects the copy, or vice versa (all new memory is allocated for
the copy).
| ||
copy [BatDllist] |
Copy the list attached to the given node and return the copy of the given
node.
| ||
copy [BatBitSet] |
Copy a bitset : further modifications of first one will not affect the
copy.
| ||
copy [BatArray.Cap] | |||
copy [BatArray] | Array.copy a returns a copy of a , that is, a fresh array
containing the same elements as a .
| ||
copy_enum [BatRefList] |
Makes a copy of a enum.
| ||
copy_list [BatRefList] |
Makes a copy of a list - O(1)
| ||
copysign [BatFloat] | copysign x y returns a copy of x with the same sign as y .
| ||
cos [BatFloat.Safe_float] | |||
cos [BatFloat] |
See
BatFloat.atan2 .
| ||
cosh [BatFloat.Safe_float] | |||
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 [BatArray.Cap.Labels] | |||
create [BatArray.Cap] | |||
create [BatArray.Labels] | |||
create [BatArray] | |||
create_alarm [BatGc] | create_alarm f will arrange for f to be called at the end of each
major GC cycle, starting with the current cycle or the next one.
| ||
create_full [BatBitSet] |
Create a full bitset with at least initial capacity (in number of bits).
| ||
create_in [BatInnerIO] |
Fully create an input by giving all the needed functions.
| ||
create_in [BatIO] |
Fully create an input by giving all the needed functions.
| ||
create_matrix [BatArray.Cap.Labels] | |||
create_matrix [BatArray.Cap] | |||
create_matrix [BatArray.Labels] | |||
create_matrix [BatArray] | |||
create_object [BatOo.Internal] | |||
create_object_and_run_initializers [BatOo.Internal] | |||
create_object_opt [BatOo.Internal] | |||
create_out [BatInnerIO] |
Fully create an output by giving all the needed functions.
| ||
create_out [BatIO] |
Fully create an output by giving all the needed functions.
| ||
create_process [BatUnix] | create_process prog args new_stdin new_stdout new_stderr
forks a new process that executes the program
in file prog , with arguments args .
| ||
create_process_env [BatUnix] | create_process_env prog args env new_stdin new_stdout new_stderr
works as Unix.create_process , except that the extra argument
env specifies the environment passed to the program.
| ||
create_table [BatOo.Internal] | |||
current_browse [BatteriesConfig] | |||
curry [BatTuple.Tuple5] | |||
curry [BatTuple.Tuple4] | |||
curry [BatTuple.Tuple3] | |||
curry [BatTuple.Tuple2] | |||
curry [BatPervasives] |
Convert a function which accepts a pair of arguments into a
function which accepts two arguments.
| ||
curry [BatInnerPervasives] | |||
cycle [BatEnum] | cycle is similar to repeat , except that the content to fill is a
subenum rather than a single element.
| ||
D | |||
data_size [BatMarshal] |
See
Marshal.header_size .
| ||
dbg_formatter [BatLogger] | dbg_formatter is a debug formatter that outputs log events to
stderr using the same format as make_dbg_formatter .
| ||
debug_mode [BatParserCo] |
If set to
true , debugging information will be printed to the standard error.
| ||
decode [BatBase64] |
Generic base64 decoding over an input.
| ||
decorate_fast_sort [BatArray] |
As
Array.decorate_stable_sort , but uses fast_sort internally.
| ||
decorate_stable_sort [BatArray] | decorate_stable_sort f a returns a sorted copy of a such that if f
x < f y then x is earlier in the result than y .
| ||
decr_num [BatNum] | |||
decr_option [BatOptParse.StdOpt] |
Exactly identical to
count_option ~dest:dest ~increment:(-1) () .
| ||
default [BatResult] | default d r evaluates to d if r is Bad else x when r is
Ok x
| ||
default [BatOption] | default x (Some v) returns v and default x None returns x .
| ||
default_browse [BatteriesConfig] |
The default function to open a www browser.
| ||
default_buffer_size [BatInnerIO] |
The default size of buffers.
| ||
default_buffer_size [BatIO] |
The default size for internal buffers.
| ||
default_level [BatLog.Level_sig] |
a comparison function between levels, to know whether logging at a
particular level should be printed
| ||
default_permission [BatFile] |
Default permissions.
| ||
default_resizer [BatDynArray] |
The default resizer function the library is using - in this version
of DynArray, this is the
exponential_resizer but should change in
next versions.
| ||
default_validator [BatPathGen.PathType] |
Forward slash and code zero are considered invalid.
| ||
del_min [BatHeap.H] |
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
takeWhile p xs .
| ||
drop_while [BatLazyList.Labels] | |||
drop_while [BatLazyList] | drop_while f xs returns the list xs with the first
elements satisfying the predicate f dropped.
| ||
drop_while [BatEnum.Labels] | |||
drop_while [BatEnum] | drop_while p e produces a new enumeration in which only
all the first elements such that f e have been junked.
| ||
dropl [BatSubstring] | dropl p sus drops the longest prefix (left substring) of sus
all of whose characters satisfy predicate p .
| ||
dropr [BatSubstring] | dropr p sus drops the longest suffix (right substring) of sus all
of whose characters satisfy predicate p .
| ||
dropwhile [BatList] |
obsolete, as
BatList.drop_while
| ||
dummy_class [BatOo.Internal] | |||
dummy_pos [BatLexing] |
A value of type
position , guaranteed to be different from any
valid position.
| ||
dummy_table [BatOo.Internal] | |||
dump [BatPervasives] |
Attempt to convert a value to a string.
| ||
dup [BatUnix] |
Return a new file descriptor referencing the same file as
the given descriptor.
| ||
dup [BatStream] | dup stream returns a pair of streams which are identical to stream .
| ||
dup [BatEnum] | dup stream returns a pair of streams which are identical to stream .
| ||
dup2 [BatUnix] | dup2 fd1 fd2 duplicates fd1 to fd2 , closing fd2 if already
opened.
| ||
E | |||
e [BatFloat] |
Euler? ...
| ||
eager_append [BatLazyList] |
Evaluate a list and append another list after this one.
| ||
eager_of_list [BatLazyList] |
Eager conversion from lists.
| ||
either [BatParserCo] |
Accept one of several parsers.
| ||
elements [BatSet.PSet] |
Return the list of all elements of the given set.
| ||
elements [BatSet.S] |
Return the list of all elements of the given set.
| ||
elements [BatSet] |
Return the list of all elements of the given set.
| ||
elements [BatISet] |
Returns a list of all elements in the set
| ||
elems [BatHeap.H] | |||
elems [BatHeap] | |||
empty [BatVect.RANDOMACCESS] | |||
empty [BatVect.Make] |
The empty vect.
| ||
empty [BatVect] |
The empty vect.
| ||
empty [BatText] |
The empty rope.
| ||
empty [BatSubstring] | |||
empty [BatStream] |
Return
() if the stream is empty, else raise Stream.Failure .
| ||
empty [BatSet.PSet] |
The empty set, using
compare as comparison function
| ||
empty [BatSet.S] |
The empty set.
| ||
empty [BatSet] |
The empty set, using
compare as comparison function
| ||
empty [BatRefList] |
Returns a new empty ref list
| ||
empty [BatMultiPMap] |
The empty map, using
compare as key comparison function.
| ||
empty [BatMultiMap] |
The empty map, using
compare as key comparison function.
| ||
empty [BatMap.PMap] |
The empty map, using
compare as key comparison function.
| ||
empty [BatMap.S] |
The empty map.
| ||
empty [BatMap] |
The empty map, using
compare as key comparison function.
| ||
empty [BatISet] |
The empty set
| ||
empty [BatIMap] |
The empty map.
| ||
empty [BatHeap.H] |
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 [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] | 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 [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_big_int [BatBig_int] | extract_big_int bi ofs n returns a nonnegative number
corresponding to bits ofs to ofs + n - 1 of the
binary representation of bi .
| ||
F | |||
fail [BatParserCo] |
Always fail, without consuming anything.
| ||
fast_count [BatEnum] |
For users worried about the speed of
count you can call the fast_count
function that will give an hint about count implementation.
| ||
fast_sort [BatList.Labels] | |||
fast_sort [BatList] |
Same as
List.sort or List.stable_sort , whichever is faster
on typical input.
| ||
fast_sort [BatArray.Cap.Labels] | |||
fast_sort [BatArray.Cap] | |||
fast_sort [BatArray.Labels] | |||
fast_sort [BatArray] |
Same as
Array.sort or Array.stable_sort , whichever is faster
on typical input.
| ||
fatal [BatParserCo] | |||
fatal [BatLog.Make] | fatal s logs the message s and then calls exit 1 .
| ||
fatal [BatLog] | fatal s logs the message s and then calls exit 1 .
| ||
fatalf [BatLog.Make] | fatalf allows a format string (as Printf.printf )and the
arguments to that format string to build the logging message.
| ||
fatalf [BatLog] | fatalf allows a format string (as Printf.printf )and the
arguments to that format string to build the logging message.
| ||
fchmod [BatUnix] |
Change the permissions of an opened file.
| ||
fchown [BatUnix] |
Change the owner uid and owner gid of an opened file.
| ||
feed [BatGenlex.Languages.Make] |
Drop comments, present reserved operators and reserved
names as
Kwd , operators and identifiers as Ident ,
integer numbers as Int , floating-point numbers as
Float and characters as Char .
| ||
fields [BatSubstring] | fields p sus returns the list of fields in sus , from left to right,
where a field is a (possibly empty) maximal substring of sus not
containing any delimiter, and a delimiter is a character satisfying p .
| ||
fifth [BatTuple.Tuple5] | |||
file [BatDigest] |
Return the digest of the file whose name is given.
| ||
file_exists [BatSys] |
Test if a file with the given name exists.
| ||
files_of [BatSys] |
As
BatSys.readdir but the results are presented as an enumeration
of names.
| ||
fill [BatText] | fill s start len c returns the rope in which
characters number start to start + len - 1 of s has
been replaced by c .
| ||
fill [BatString.Cap] | |||
fill [BatString] | String.fill s start len c modifies string s in place,
replacing len characters by c , starting at start .
| ||
fill [BatOptParse.Formatter] |
See
OptParse.Formatter.wrap .
| ||
fill [BatBigarray.Array3] |
Fill the given big array with the given value.
| ||
fill [BatBigarray.Array2] |
Fill the given big array with the given value.
| ||
fill [BatBigarray.Array1] |
Fill the given big array with the given value.
| ||
fill [BatBigarray.Genarray] |
Set all elements of a big array to a given value.
| ||
fill [BatArray.Cap.Labels] | |||
fill [BatArray.Cap] | |||
fill [BatArray.Labels] | |||
fill [BatArray] | Array.fill a ofs len x modifies the array a in place,
storing x in elements number ofs to ofs + len - 1 .
| ||
filter [BatVect.Make] | filter f v returns a vect with the elements x from v such that
f x returns true .
| ||
filter [BatVect] | filter f v returns a vect with the elements x from v such that
f x returns true .
| ||
filter [BatText] | filter f s returns a copy of rope s in which only
characters c such that f c = true remain.
| ||
filter [BatString.Cap] | |||
filter [BatString] | filter f s returns a copy of string s in which only
characters c such that f c = true remain.
| ||
filter [BatStream.StreamLabels] | |||
filter [BatStream] | filter test stream picks all the elements satisfying test from stream
and return the results in the same order as a stream.
| ||
filter [BatSet.PSet] | filter p s returns the set of all elements in s
that satisfy predicate p .
| ||
filter [BatSet.S.Labels] | |||
filter [BatSet.S] | filter p s returns the set of all elements in s
that satisfy predicate p .
| ||
filter [BatSet] | filter p s returns the set of all elements in s
that satisfy predicate p .
| ||
filter [BatSeq] | filter p s returns the sequence of elements of s satisfying
p .
| ||
filter [BatRefList] |
Remove all elements that do not match the
specified predicate
| ||
filter [BatPervasives] | filter f e returns an enumeration over all elements x of e such
as f x returns true .
| ||
filter [BatParserCo] | filter f p is only accepts values x such that p
accepts x and f (p x) is true
| ||
filter [BatOption] | filter f None returns None , filter f (Some x) returns Some x
if f x is true, and None otherwise.
| ||
filter [BatMap.PMap] | filter f m returns a map where only the (key, value) pairs
key , a of m such that f key a = true remain.
| ||
filter [BatMap.S.Labels] | |||
filter [BatMap.S] | filter f m returns a map where only the key, values pairs
key , a of m such that f key a = true remain.
| ||
filter [BatMap] | filter f m returns a map where only the (key, value) pairs
key , a of m such that f key a = true remain.
| ||
filter [BatList.Labels] | |||
filter [BatList] | filter p l returns all the elements of the list l
that satisfy the predicate p .
| ||
filter [BatLazyList.Labels] | |||
filter [BatLazyList] |
Lazy filtering.
| ||
filter [BatISet] |
Builds the subset of those elements that satisfy the predicate
| ||
filter [BatHashtbl.Cap.Labels] | |||
filter [BatHashtbl.Cap] | |||
filter [BatHashtbl.S.Labels] | |||
filter [BatHashtbl.S] | |||
filter [BatHashtbl.Labels] | |||
filter [BatHashtbl] | filter f m returns a new hashtable where only the values a of m
such that f a = true remain.
| ||
filter [BatEnum.Labels] | |||
filter [BatEnum] | filter f e returns an enumeration over all elements x of e such
as f x returns true .
| ||
filter [BatDynArray] | filter p a returns all the elements of the array a
that satisfy the predicate p .
| ||
filter [BatDllist] | filter p l returns a new list, with entirely new nodes, whose
values are all the elements of the list l that satisfy the
predicate p .
| ||
filter [BatArray.Cap.Labels] | |||
filter [BatArray.Cap] | |||
filter [BatArray.Labels] | |||
filter [BatArray] | filter p a returns all the elements of the array a
that satisfy the predicate p .
| ||
filter_map [BatVect.Make] | filter_map f e returns a vect consisting in all elements
x such that f y returns Some x , where y is an element
of e .
| ||
filter_map [BatVect] | filter_map f e returns a vect consisting in all elements
x such that f y returns Some x , where y is an element
of e .
| ||
filter_map [BatText] | filter_map f l calls (f a0) (f a1).... (f an) where a0..an are
the characters of l .
| ||
filter_map [BatString.Cap] | |||
filter_map [BatString] | filter_map f s calls (f a0) (f a1).... (f an) where a0..an are
the characters of s .
| ||
filter_map [BatSet.PSet] | filter_map f m combines the features of filter and
map .
| ||
filter_map [BatSet.S.Labels] | |||
filter_map [BatSet.S] | filter_map f m combines the features of filter and
map .
| ||
filter_map [BatSet] | filter_map f m combines the features of filter and
map .
| ||
filter_map [BatSeq] | filter_map f s returns the sequence of elements filtered and
mapped by f .
| ||
filter_map [BatPervasives] |
Similar to a map, except that you can skip over some items of the
incoming enumeration by returning None instead of Some value.
| ||
filter_map [BatMap.PMap] | filter_map f m combines the features of filter and
map .
| ||
filter_map [BatMap.S] | filter_map f m combines the features of filter and
map .
| ||
filter_map [BatMap] | filter_map f m combines the features of filter and
map .
| ||
filter_map [BatList.Labels] | |||
filter_map [BatList] | filter_map f l calls (f a0) (f a1).... (f an) where a0,a1..an are
the elements of l .
| ||
filter_map [BatLazyList.Labels] | |||
filter_map [BatLazyList] |
Lazily eliminate some elements and transform others.
| ||
filter_map [BatHashtbl.Cap.Labels] | |||
filter_map [BatHashtbl.Cap] | |||
filter_map [BatHashtbl.S.Labels] | |||
filter_map [BatHashtbl.S] | |||
filter_map [BatHashtbl.Labels] | |||
filter_map [BatHashtbl] | filter_map f m combines the features of filteri and map .
| ||
filter_map [BatEnum.Labels] | |||
filter_map [BatEnum] | filter_map f e returns an enumeration over all elements x such as
f y returns Some x , where y is an element of e .
| ||
filter_map [BatDynArray] | filter_map f e returns an array consisting in all elements
x such that f y returns Some x , where y is an element
of e .
| ||
filter_map [BatDllist] | filter_map f l calls (f a0) (f a1) ... (f an) where a0,a1...an
are the elements of l .
| ||
filter_map [BatArray.Cap.Labels] | |||
filter_map [BatArray.Cap] | |||
filter_map [BatArray.Labels] | |||
filter_map [BatArray] | filter_map f e returns an array consisting in all elements
x such that f y returns Some x , where y is an element
of e .
| ||
filteri [BatHashtbl.Cap.Labels] | |||
filteri [BatHashtbl.Cap] | |||
filteri [BatHashtbl.S.Labels] | |||
filteri [BatHashtbl.S] | |||
filteri [BatHashtbl.Labels] | |||
filteri [BatHashtbl] | filter f m returns a hashtbl where only the key, values pairs
key , a of m such that f key a = true remain.
| ||
filteri [BatArray] |
As
filter but with the index passed to the predicate.
| ||
filterv [BatMap.PMap] | filterv f m returns a map where only the values a of m
such that f a = true remain.
| ||
filterv [BatMap.S.Labels] | |||
filterv [BatMap.S] | filterv f m returns a map where only the values a of m
such that f a = true remain.
| ||
filterv [BatMap] | filterv f m returns a map where only the values a of m
such that f a = true remain.
| ||
finalise [BatGc] | finalise f v registers f as a finalisation function for v .
| ||
finalise_release [BatGc] |
A finalisation function may call
finalise_release to tell the
GC that it can launch the next finalisation function without waiting
for the current one to return.
| ||
finally [BatPervasives] | finally fend f x calls f x and then fend() even if f x raised
an exception.
| ||
finally [BatInnerPervasives] | |||
find [BatVect.Make] | find p a returns the first element of vect a
that satisfies the predicate p .
| ||
find [BatVect] | find p a returns the first element of vect a
that satisfies the predicate p .
| ||
find [BatText] | find s x returns the starting index of the first occurrence of
rope x within rope s .
| ||
find [BatString.Cap.Exceptionless] | |||
find [BatString.Cap] | |||
find [BatString.Exceptionless] | find s x returns Some i , the starting index of the first
occurrence of string x within string s , or None if x
is not a substring of s .
| ||
find [BatString] | find s x returns the starting index of the first occurrence of
string x within string s .
| ||
find [BatSeq] | find p s returns the first element of s such as p e
returns true , if any.
| ||
find [BatRefList] |
Find the first element matching
the specified predicate
raise
Not_found if no element is found
| ||
find [BatPervasives] | find f e returns the first element x of e such that f x returns
true , consuming the enumeration up to and including the
found element, or, raises Not_found if no such element exists
in the enumeration, consuming the whole enumeration in the search.
| ||
find [BatMultiPMap] | find x m returns the current binding of x in m
| ||
find [BatMultiMap] | find x m returns the current binding of x in m
| ||
find [BatMap.PMap.Exceptionless] | |||
find [BatMap.PMap] | find x m returns the current binding of x in m ,
or raises Not_found if no such binding exists.
| ||
find [BatMap.Exceptionless] | |||
find [BatMap.S.Exceptionless] | |||
find [BatMap.S] | find x m returns the current binding of x in m ,
or raises Not_found if no such binding exists.
| ||
find [BatMap] | find x m returns the current binding of x in m ,
or raises Not_found if no such binding exists.
| ||
find [BatList.Labels.LExceptionless] | |||
find [BatList.Labels] | |||
find [BatList.Exceptionless] | find p l returns Some x where x is the first element
of l such as p x returns true or None if such an
element has not been found.
| ||
find [BatList] | find p l returns the first element of the list l
that satisfies the predicate p .
| ||
find [BatLazyList.Labels.Exceptionless] | |||
find [BatLazyList.Labels] | |||
find [BatLazyList.Exceptionless] | rfind p l returns Some x where x is the first element of l such
that p x returns true or None if such element as not been found.
| ||
find [BatLazyList] | find p l returns the first element of l such as p x
returns true .
| ||
find [BatInnerWeaktbl] | Weaktbl.find tbl x returns the current binding of x in tbl ,
or raises Not_found if no such binding exists.
| ||
find [BatIMap] | find x t returns the y that is bound to x in t .
| ||
find [BatHashtbl.Cap.Exceptionless] | |||
find [BatHashtbl.Cap] | |||
find [BatHashtbl.S.Exceptionless] | |||
find [BatHashtbl.S] | |||
find [BatHashtbl.Exceptionless] | |||
find [BatHashtbl] | Hashtbl.find tbl x returns the current binding of x in tbl ,
or raises Not_found if no such binding exists.
| ||
find [BatEnum.Labels.LExceptionless] | |||
find [BatEnum.Labels] | |||
find [BatEnum.Exceptionless] | find f e returns Some x where x is the first element x of e
such that f x returns true , consuming the enumeration up to and
including the found element, or None if no such element exists
in the enumeration, consuming the whole enumeration in the search.
| ||
find [BatEnum] | find f e returns the first element x of e such that f x returns
true , consuming the enumeration up to and including the
found element.
| ||
find [BatDllist] | find p l returns the first element, l or after, for which p
returns true.
| ||
find [BatDeque] | find ~backwards f dq returns Some (n, x) if x at position
n is such that f x is true, or None if there is no such
element.
| ||
find [BatArray.Cap.Labels] | |||
find [BatArray.Cap.Exceptionless] | |||
find [BatArray.Cap] | |||
find [BatArray.Labels.LExceptionless] | |||
find [BatArray.Labels] | |||
find [BatArray.Exceptionless] | find p a returns Some x , where x is the first element of
array a that satisfies the predicate p , or None if there
is no such element.
| ||
find [BatArray] | find p a returns the first element of array a that
satisfies the predicate p .
| ||
find_all [BatVect.Make] | find_all is another name for Vect.filter .
| ||
find_all [BatVect] | find_all is another name for Vect.filter .
| ||
find_all [BatList.Labels] | |||
find_all [BatList] | find_all is another name for List.filter .
| ||
find_all [BatInnerWeaktbl] | Weaktbl.find_all tbl x returns the list of all data
associated with x in tbl .
| ||
find_all [BatHashtbl.Cap] | |||
find_all [BatHashtbl.S] | |||
find_all [BatHashtbl] | Hashtbl.find_all tbl x returns the list of all data
associated with x in tbl .
| ||
find_all [BatArray.Cap] | |||
find_all [BatArray] | find_all is another name for Array.filter .
| ||
find_default [BatHashtbl.Cap] | |||
find_default [BatHashtbl.S] | |||
find_default [BatHashtbl] |
Find a binding for the key, and return a default
value if not found
| ||
find_exc [BatRefList] |
Same as find but takes an exception to be raised when
no element is found as additional parameter
| ||
find_exn [BatList.Labels] | |||
find_exn [BatList] | find_exn p e l returns the first element of l such as p x
returns true or raises e if such an element has not been found.
| ||
find_exn [BatLazyList.Labels] | |||
find_exn [BatLazyList] | find_exn p e l returns the first element of l such as p x
returns true or raises e if such an element has not been found.
| ||
find_from [BatText] | find_from s ofs x behaves as find s x but starts searching
at offset ofs .
| ||
find_from [BatString.Cap.Exceptionless] | |||
find_from [BatString.Cap] | |||
find_from [BatString.Exceptionless] | find_from s ofs x behaves as find s x but starts searching
at offset ofs .
| ||
find_from [BatString] | find_from s pos x behaves as find s x but starts searching
at position pos .
| ||
find_map [BatSeq] | find_map p s finds the first element of s for which p e
returns Some r , if any.
| ||
find_map [BatList.Exceptionless] | find_map f xs returns Some y such that x is the first
element of the list where f x returns Some y .
| ||
find_map [BatList] | find_map pred list finds the first element of list for which
pred element returns Some r .
| ||
find_map [BatEnum] | find_map f e finds the first element x of e such that f x returns
Some r , then returns r.
| ||
find_min [BatHeap.H] |
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_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] | |||
head [BatFingerTree.S] | head t returns None if t is empty,
or Some hd otherwise, where hd is the first element
of the sequence.
| ||
head [BatArray] | |||
head_exn [BatFingerTree.S] | head_exn t returns the first element of the sequence.
| ||
header_size [BatMarshal] |
The bytes representing a marshaled value are composed of
a fixed-size header and a variable-sized data part,
whose size can be determined from the header.
| ||
height [BatVect.Make] |
Returns the height (depth) of the vect.
| ||
height [BatVect] |
Returns the height (depth) of the vect.
| ||
height [BatText] |
Returns the height (depth) of the rope.
| ||
height [BatAvlTree] | |||
help_option [BatOptParse.StdOpt] | help_option () returns the standard help option which
displays a usage message and exits the program when encountered
on the command line.
| ||
hex [BatCharParser] |
Recognizes one hexadecimal digit (case-insensitive)
| ||
I | |||
i [BatComplex] |
The complex number
i .
| ||
i16s_of [BatIO.BigEndian] |
Read an enumartion of signed 16-bit words.
| ||
i16s_of [BatIO] |
Read an enumartion of signed 16-bit words.
| ||
i32s_of [BatIO.BigEndian] |
Read an enumeration of signed 32-bit integers.
| ||
i32s_of [BatIO] |
Read an enumeration of signed 32-bit integers.
| ||
i64s_of [BatIO.BigEndian] |
Read an enumeration of signed 64-bit integers as OCaml
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] | in_place_mirror s mutates the string s , so that its new value is
the mirror of its old one: for instance if s contained "Example!" , after
the mutation it will contain "!elpmaxE" .
| ||
incr_num [BatNum] | |||
incr_option [BatOptParse.StdOpt] |
Exactly identical to
count_option ~dest:dest ~increment:1 () .
| ||
indented_formatter [BatOptParse.Formatter] |
Create an "indented" formatter with the given options.
| ||
index [BatText] | Rope.index s c returns the position of the leftmost
occurrence of character c in rope s .
| ||
index [BatSubstring] | index sus c returns the index of the first occurence of c in sus or
| ||
index [BatString.Cap.Exceptionless] | |||
index [BatString.Cap] | |||
index [BatString.Exceptionless] | index s c returns Some p , the position of the leftmost
occurrence of character c in string s or
None if c does not occur in s .
| ||
index [BatString] | String.index s c returns the character number of the first
occurrence of character c in string s .
| ||
index [BatRefList.Index] |
Return the index (position : 0 starting) of an element in
a ref list, using the specified comparator
raise
Not_found if no element was found
| ||
index_from [BatText] |
Same as
Rope.index , but start searching at the character
position given as second argument.
| ||
index_from [BatSubstring] | index_from sus i c returns the index of the first occurence of c in
sus after the index i or
| ||
index_from [BatString.Cap.Exceptionless] | |||
index_from [BatString.Cap] | |||
index_from [BatString.Exceptionless] |
Same as
String.Exceptionless.index , but start
searching at the character position given as second argument.
| ||
index_from [BatString] | String.index_from s i c returns the character number of the
first occurrence of character c in string s after position i .
| ||
index_of [BatRefList.Index] |
Return the index (position : 0 starting) of an element in
a ref list, using ( = ) for testing element equality
raise
Not_found if no element was found
| ||
index_of [BatList] | index_of e l returns the index of the first occurrence of e
in l , or None if there is no occurrence of e in l
| ||
index_of [BatLazyList] | index_of e l returns the index of the first occurrence of e
in l , or None if there is no occurrence of e in l
| ||
index_of [BatDynArray] | index_of f darr returns the index of the first element x in darr such
as f x returns true or raise Not_found if not found.
| ||
index_ofq [BatList] | index_ofq e l behaves as index_of e l except it uses
physical equality
| ||
index_ofq [BatLazyList] | index_ofq e l behaves as index_of e l except it uses
physical equality
| ||
inet6_addr_any [BatUnix] |
A special IPv6 address, for use only with
bind , representing
all the Internet addresses that the host machine possesses.
| ||
inet6_addr_loopback [BatUnix] |
A special IPv6 address representing the host machine (
::1 ).
| ||
inet_addr_any [BatUnix] |
A special IPv4 address, for use only with
bind , representing
all the Internet addresses that the host machine possesses.
| ||
inet_addr_loopback [BatUnix] |
A special IPv4 address representing the host machine (
127.0.0.1 ).
| ||
inet_addr_of_string [BatUnix] |
Conversion from the printable representation of an Internet
address to its internal representation.
| ||
infinity [BatFloat.Safe_float] |
Positive infinity.
| ||
infinity [BatFloat] |
Positive infinity.
| ||
inherit_in [BatInnerIO] |
Simplified and optimized version of
BatInnerIO.wrap_in whenever only
one input appears as dependency.
| ||
inherit_in [BatIO] |
Simplified and optimized version of
BatIO.wrap_in which may be used
whenever only one input appears as dependency.
| ||
inherit_out [BatInnerIO] |
Simplified and optimized version of
BatInnerIO.wrap_out whenever only
one output appears as dependency.
| ||
inherit_out [BatIO] |
Simplified and optimized version of
BatIO.wrap_out whenever only
one output appears as dependency.
| ||
inherits [BatOo.Internal] | |||
init [BatVect.Make] | init n f returns a fresh vect of length n ,
with element number i initialized to the result of f i .
| ||
init [BatVect] | init n f returns a fresh vect of length n ,
with element number i initialized to the result of f i .
| ||
init [BatUTF8] | init len f
returns a new string which contains len Unicode characters.
| ||
init [BatText] | init l f returns the rope of length l with the chars f 0 , f
1 , f 2 ...
| ||
init [BatString.Cap] | |||
init [BatString] | init l f returns the string of length l with the chars
f 0 , f 1 , f 2 ...
| ||
init [BatSeq] | init n f returns the sequence returning the results of f 0 ,
f 1 ....
| ||
init [BatRandom] |
Initialize the generator, using the argument as a seed.
| ||
init [BatLogger] | init name_level_list formatter initializes the logging
system enabling the specified levels for each named
logger.
| ||
init [BatList.Labels] | |||
init [BatList] |
Similar to
Array.init , init n f returns the list containing
the results of (f 0),(f 1)....
| ||
init [BatLazyList] |
Similar to
Array.init , init n f returns the lazy list
containing the results of (f 0),(f 1)....
| ||
init [BatFingerTree.S] | init t returns None if t is empty,
or Some init where init is the sequence t where the last element
has been removed.
| ||
init [BatEnum.Labels] | |||
init [BatEnum] | init n f creates a new enumeration over elements
f 0, f 1, ..., f (n-1)
| ||
init [BatDynArray] | init n f returns an array of n elements filled with values
returned by f 0 , f 1, ... f (n-1) .
| ||
init [BatArray.Cap.Labels] | |||
init [BatArray.Cap] | |||
init [BatArray.Labels] | |||
init [BatArray] | Array.init n f returns a fresh array of length n ,
with element number i initialized to the result of f i .
| ||
init_class [BatOo.Internal] | |||
init_exn [BatFingerTree.S] | init_exn t returns the sequence t where the last element
has been removed.
| ||
init_from_string [BatLogger] | init_from_string name_level_string formatter initializes the
logging system enabling the specified levels for each named
logger.
| ||
initgroups [BatUnix] | initgroups user group initializes the group access list by
reading the group database /etc/group and using all groups of
which user is a member.
| ||
input [BatPervasives] | input ic buf pos len reads up to len characters from
the given channel ic , storing them in string buf , starting at
character number pos .
| ||
input [BatMarshal] | input inp reads from inp the
byte representation of a structured value, as produced by
one of the Marshal.to_* functions, and reconstructs and
returns the corresponding value.
| ||
input [BatInnerIO] | input i s p l reads up to l characters from the given input, storing
them in string s , starting at character number p .
| ||
input [BatIO] | input i s p l reads up to l characters from the given input,
storing them in string s , starting at character number p .
| ||
input [BatDigest] |
Read a digest from the given input.
| ||
input_all [BatPervasives] |
Return the whole contents of an input channel as a single
string.
| ||
input_binary_float [BatPervasives] |
Read a float encoded in binary format (8 bytes, IEEE 754 double format)
from the given input channel.
| ||
input_binary_int [BatPervasives] |
Read an integer encoded in binary format (4 bytes, big-endian)
from the given input channel.
| ||
input_bits [BatIO] |
Read bits from an input
| ||
input_byte [BatPervasives] |
Same as
Pervasives.input_char , but return the 8-bit integer representing
the character.
| ||
input_channel [BatInnerIO] |
Create an input that will read from a channel.
| ||
input_channel [BatIO] |
Create an input that will read from a channel.
| ||
input_char [BatPervasives] |
Read one character from the given input channel.
| ||
input_chars [BatPervasives] |
Returns an enumeration over characters of an input channel.
| ||
input_enum [BatIO] |
Create an input that will read from an
enum .
| ||
input_file [BatPervasives] |
returns the data of a given filename.
| ||
input_line [BatPervasives] |
Read characters from the given input channel, until a
newline character is encountered.
| ||
input_lines [BatPervasives] |
Returns an enumeration over lines of an input channel, as read by the
input_line function.
| ||
input_list [BatPervasives] |
Returns the list of lines read from an input channel.
| ||
input_of_descr [BatUnix] |
Create an
input reading from the given descriptor.
| ||
input_string [BatInnerIO] |
Create an input that will read from a string.
| ||
input_string [BatIO] |
Create an input that will read from a string.
| ||
input_value [BatPervasives] |
Read the representation of a structured value, as produced
by
BatPervasives.output_value , and return the corresponding value.
| ||
insert [BatVect.Make] | insert n r u returns a copy of the u vect where r has been
inserted between the elements with index n and n + 1 in the
original vect.
| ||
insert [BatVect] | insert n r u returns a copy of the u vect where r has been
inserted between the elements with index n and n + 1 in the
original vect.
| ||
insert [BatText] | insert n r u returns a copy of the u rope where r has been
inserted between the characters with index n and n + 1 in the
original rope.
| ||
insert [BatHeap.H] |
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] |
Traversing
| ||
iter [BatHashtbl.S.Labels] | |||
iter [BatHashtbl.S] | |||
iter [BatHashtbl.Labels] | |||
iter [BatHashtbl] | Hashtbl.iter f tbl applies f to all bindings in table tbl .
| ||
iter [BatHashcons.Table] | iter f tab applies f to every live hashed object in the
table tab .
| ||
iter [BatFingerTree.S] | iter is equivalent to List.iter .
| ||
iter [BatEnum.Labels] | |||
iter [BatEnum] | iter f e calls the function f with each elements of e in turn.
| ||
iter [BatDynArray] | iter f darr calls the function f on every element of darr .
| ||
iter [BatDllist] | iter f n Apply f to every element in the list, starting at n .
| ||
iter [BatDeque] | iter f dq calls f x on each element x of dq .
| ||
iter [BatBigarray.Genarray] | iter f a applies function f in turn to all
the elements of a .
| ||
iter [BatAvlTree] | |||
iter [BatArray.Cap.Labels] | |||
iter [BatArray.Cap] | |||
iter [BatArray.Labels] | |||
iter [BatArray] | Array.iter f a applies function f in turn to all
the elements of a .
| ||
iter2 [BatList.Labels] | |||
iter2 [BatList] | List.iter2 f [a0; a1; ...; an] [b0; b1; ...; bn] calls in turn
f a0 b0; f a1 b1; ...; f an bn .
| ||
iter2 [BatLazyList.Labels] | |||
iter2 [BatLazyList] | iter2 f [^ a0; ...; an ^] [^ b0; ...; bn ^] calls in turn
f a0 b0; ...; f an bn .
| ||
iter2 [BatEnum.Labels] | |||
iter2 [BatEnum] | iter2 f e1 e2 calls the function f with the next elements of e1 and
e2 repeatedly until one of the two enumerations ends.
| ||
iter2 [BatArray.Cap.Labels] | |||
iter2 [BatArray.Cap] | |||
iter2 [BatArray.Labels] | |||
iter2 [BatArray] | Array.iter2 f [|a0; a1; ...; an|] [|b0; b1; ...; bn|]
performs calls f a0 b0; f a1 b1; ...; f an bn in that order.
| ||
iter2i [BatEnum.Labels] | |||
iter2i [BatEnum] | |||
iter2i [BatArray.Cap.Labels] | |||
iter2i [BatArray.Cap] | |||
iter2i [BatArray.Labels] | |||
iter2i [BatArray] | Array.iter2i f [|a0; a1; ...; an|] [|b0; b1; ...; bn|]
performs calls f 0 a0 b0; f 1 a1 b1; ...; f n an bn in that
order.
| ||
iter_range [BatISet] | iter_range f t calls f once for each contiguous range of t .
| ||
iter_range [BatIMap] | iter_range f t calls f on every contiguous range.
| ||
iter_right [BatFingerTree.S] | iter_right is equivalent to List.iter o List.rev .
| ||
iteri [BatVect.Make] |
Operates like iter, but also passes the index of the character
to the given function.
| ||
iteri [BatVect] |
Operates like iter, but also passes the index of the character
to the given function.
| ||
iteri [BatText] |
Operates like
iter , but also passes the index of the character
to the given function.
| ||
iteri [BatString] |
Same as
String.iter , but the
function is applied to the index of the element as first argument
(counting from 0), and the character itself as second argument.
| ||
iteri [BatPathGen.StringType] | |||
iteri [BatList.Labels] | |||
iteri [BatList] | iteri f l will call (f 0 a0);(f 1 a1) ... (f n an) where
a0..an are the elements of the list l .
| ||
iteri [BatLazyList.Labels] | |||
iteri [BatLazyList] |
Eager iteration, with indices
| ||
iteri [BatEnum.Labels] | |||
iteri [BatEnum] | |||
iteri [BatDynArray] | iter f darr calls the function f on every element of darr .
| ||
iteri [BatDeque] | iteri f dq calls f n x on each element x of dq .
| ||
iteri [BatBigarray.Genarray] |
Same as
BatBigarray.Genarray.iter , but the function is applied to the index of
the element as the first argument, and the element itself as
the second argument.
| ||
iteri [BatArray.Cap.Labels] | |||
iteri [BatArray.Cap] | |||
iteri [BatArray.Labels] | |||
iteri [BatArray] |
Same as
Array.iter , but the
function is applied to the index of the element as first argument,
and the element itself as second argument.
| ||
J | |||
join [BatText] |
Same as
BatText.concat
| ||
join [BatString.Cap] | |||
join [BatString] |
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.
| ||
lchop [BatText] |
Returns the same rope but without the first character.
| ||
lchop [BatString.Cap] | |||
lchop [BatString] |
Returns the same string but without the first
n characters.
| ||
ldexp [BatFloat.Safe_float] | ldexp x n returns x *. 2 ** n .
| ||
ldexp [BatFloat] | ldexp x n returns x *. 2 ** n .
| ||
le_big_int [BatBig_int] | |||
le_num [BatNum] | |||
left [BatText] | left r len returns the rope containing the len first characters of r
| ||
left [BatString.Cap] | |||
left [BatString] | left r len returns the string containing the len first
characters of r .
| ||
left [BatArray] | left r len returns the array containing the len first
characters of r .
| ||
left_branch [BatAvlTree] | |||
length [BatVect.RANDOMACCESS] | |||
length [BatVect.Make] |
Returns the length of the vect (
O(1) ).
| ||
length [BatVect] |
Returns the length of the vect (
O(1) ).
| ||
length [BatUTF8] | length s returns the number of Unicode characters contained in s
| ||
length [BatText] |
Returns the length of the rope (
O(1) ).
| ||
length [BatSubstring] |
Equivalent to
BatSubstring.size .
| ||
length [BatString.Cap] | |||
length [BatString] |
Return the length (number of characters) of the given string.
| ||
length [BatStack] |
Return the number of elements in a stack.
| ||
length [BatSeq] |
Return the number of elements of the given sequence.
| ||
length [BatRefList] |
Returns the number of elements - O(n)
| ||
length [BatQueue] |
Return the number of elements in a queue.
| ||
length [BatPathGen.StringType] |
Length - number of indexing units
| ||
length [BatList] |
Return the length (number of elements) of the given list.
| ||
length [BatLazyList] |
Return the length (number of elements) of the given list.
| ||
length [BatInnerWeaktbl] | Weaktbl.length tbl returns the number of bindings in tbl .
| ||
length [BatHashtbl.Cap] |
Base operations
| ||
length [BatHashtbl.S] | |||
length [BatHashtbl] | Hashtbl.length tbl returns the number of bindings in tbl .
| ||
length [BatDynArray] |
Return the number of elements in the array.
| ||
length [BatDllist] |
Returns the length of the list.
| ||
length [BatBuffer] |
Return the number of characters currently contained in the buffer.
| ||
length [BatArray.Cap] | |||
length [BatArray] |
Return the length (number of elements) of the given array.
| ||
letter [BatPathGen.StringType.Parse] | |||
letter [BatCharParser] |
Recognizes one lower- or upper-case ASCII character, including
accentuated characters.
| ||
level [BatLog.Make_lev] | |||
level [BatLog.Easy] |
Set this ref to the lowest level of log you want logged.
| ||
level_of_name [BatLogger] | level_of_name str returns the level associated with str .
| ||
lexeme [BatLexing] | Lexing.lexeme lexbuf returns the string matched by
the regular expression.
| ||
lexeme_char [BatLexing] | Lexing.lexeme_char lexbuf i returns character number i in
the matched string.
| ||
lexeme_end [BatLexing] | Lexing.lexeme_end lexbuf returns the offset in the input stream
of the character following the last character of the matched
string.
| ||
lexeme_end_p [BatLexing] |
Like
lexeme_end , but return a complete position instead
of an offset.
| ||
lexeme_start [BatLexing] | Lexing.lexeme_start lexbuf returns the offset in the
input stream of the first character of the matched string.
| ||
lexeme_start_p [BatLexing] |
Like
lexeme_start , but return a complete position instead
of an offset.
| ||
lift [BatPathGen.StringType] |
Convert from UTF-8 string of primitive
string type.
| ||
lift_char [BatPathGen.StringType] |
Convert Latin-1 character to
tchar .
| ||
line_comment [BatGenlex.Languages.Make] | |||
line_comment_start [BatGenlex.Languages.Definition] | |||
lines_of [BatText] |
offer the lines of a UTF-8 encoded input as an enumeration
| ||
lines_of [BatIO] |
Read an enumeration of LF or CRLF terminated strings.
| ||
lines_of [BatFile] | line_of name reads the contents of file name as an enumeration of lines.
| ||
lines_of2 [BatIO] | |||
link [BatUnix] | link source dest creates a hard link named dest to the file
named source .
| ||
listen [BatUnix] |
Set up a socket for receiving connection requests.
| ||
ln10 [BatFloat] | log 10
| ||
ln2 [BatFloat] | log 2
| ||
localtime [BatUnix] |
Convert a time in seconds, as returned by
Unix.time , into a date and
a time.
| ||
lock [BatUnix] |
A lock used to synchronize internal operations.
| ||
lock [BatRMutex] |
Lock the given mutex.
| ||
lock [BatPervasives] |
A lock used to synchronize internal operations.
| ||
lock [BatInnerPervasives] | |||
lock [BatIO] |
A lock used to synchronize internal operations.
| ||
lock [BatConcurrent.BaseLock] | |||
lock [BatConcurrent.Lock] | |||
lock_factory [BatIO] |
A factory used to create locks.
| ||
lockf [BatUnix] | lockf fd cmd size puts a lock on a region of the file opened
as fd .
| ||
log [BatLogger] | log logger level event_fun raises a log event if if the
specified level is currently enabled for the logger.
| ||
log [BatLog.Make_lev] | |||
log [BatLog.Easy] | log lev msg logs the message msg if the current logging
level is lev or lower.
| ||
log [BatLog.Make] | print s logs the message s, returning unit.
| ||
log [BatLog] | log s logs the message s, returning unit.
| ||
log [BatFloat.Safe_float] |
Natural logarithm.
| ||
log [BatFloat] |
Natural logarithm.
| ||
log [BatComplex] |
Natural logarithm (in base
e ).
| ||
log10 [BatFloat.Safe_float] |
Base 10 logarithm.
| ||
log10 [BatFloat] |
Base 10 logarithm.
| ||
log10e [BatFloat] | log10 e
| ||
log2e [BatFloat] | Math.log2 e
| ||
log_enable [BatLogger] | log_enable logger level enables a log level for a logger.
| ||
log_enabled [BatLogger] | log_enabled logger level returns true if the specified level is
currently enabled for the logger.
| ||
log_level [BatLogger] | log_level logger returns the currently enabled level for a logger.
| ||
log_name [BatLogger] | log_name logger returns the name of the logger.
| ||
logand [BatNativeint] |
Bitwise logical and.
| ||
logand [BatInt64] |
Bitwise logical and.
| ||
logand [BatInt32] |
Bitwise logical and.
| ||
logf [BatLog.Make_lev] | |||
logf [BatLog.Easy] |
As
log , but instead of a string message, a printf format is
allowed with whatever arguments are appropriate.
| ||
logf [BatLog.Make] |
As
Printf.printf , only the message is printed to the logging
output and prefixed with status information per the current flags and
the currently set prefix.
| ||
logf [BatLog] |
As
Printf.printf , only the message is printed to the logging
output and prefixed with status information per the current flags and
the currently set prefix.
| ||
lognot [BatNativeint] |
Bitwise logical negation
| ||
lognot [BatInt64] |
Bitwise logical negation
| ||
lognot [BatInt32] |
Bitwise logical negation
| ||
logor [BatNativeint] |
Bitwise logical or.
| ||
logor [BatInt64] |
Bitwise logical or.
| ||
logor [BatInt32] |
Bitwise logical or.
| ||
logxor [BatNativeint] |
Bitwise logical exclusive or.
| ||
logxor [BatInt64] |
Bitwise logical exclusive or.
| ||
logxor [BatInt32] |
Bitwise logical exclusive or.
| ||
look [BatUTF8] | look s i
returns the Unicode character of the location i in the string s .
| ||
lookahead [BatParserCo] | lookahead p behaves as maybe p but without consuming anything
| ||
lookup [BatFingerTree.Generic] | lookup p t , when p is monotonic, returns the first element
of the sequence for which the measure of its predecessors in the
sequence (itself included) satisfies p .
| ||
lookup_tables [BatOo.Internal] | |||
lowercase [BatString.Cap] | |||
lowercase [BatString] |
Return a copy of the argument, with all uppercase letters
translated to lowercase, including accented letters of the ISO
Latin-1 (8859-1) character set.
| ||
lowercase [BatCharParser] |
Recognizes one lower-case ASCII character, including
accentuated characters.
| ||
lowercase [BatChar] |
Convert the given character to its equivalent lowercase character.
| ||
lowercase_latin1 [BatCharParser] |
Recognizes one lower-case Latin-1 character, including
accentuated characters.
| ||
lru_cache [BatCache] | |||
lseek [BatUnix.LargeFile] | |||
lseek [BatUnix] |
Set the current position for a file descriptor
| ||
lstat [BatUnix.LargeFile] | |||
lstat [BatUnix] |
Same as
Unix.stat , but in case the file is a symbolic link,
return the information for the link itself.
| ||
lt_big_int [BatBig_int] | |||
lt_num [BatNum] | |||
M | |||
major [BatGc] |
Do a minor collection and finish the current major collection cycle.
| ||
major_slice [BatGc] |
Do a minor collection and a slice of major collection.
| ||
make [BatVect.RANDOMACCESS] | |||
make [BatVect.Make] | make i c returns a vect of length i whose elements are all equal to
c ; it is similar to Array.make
| ||
make [BatVect] | make i c returns a vect of length i whose elements are all equal to
c ; it is similar to Array.make
| ||
make [BatText] | make i c returns a rope of length i consisting of c chars;
it is similar to String.make
| ||
make [BatSubstring] | |||
make [BatString.Cap] | |||
make [BatString] | String.make n c returns a fresh string of length n ,
filled with the character c .
| ||
make [BatSeq] | make n e returns the sequence of length n where all elements
are e
| ||
make [BatRandom.Incubator.Private_state_enums.State] |
Create a new state and initialize it with the given seed.
| ||
make [BatRandom.State] |
Create a new state and initialize it with the given seed.
| ||
make [BatRMutex] |
Create a new abstract lock based on Reentrant Mutexes.
| ||
make [BatOptParse.OptParser] |
Creates a new option parser with the given options.
| ||
make [BatMutex] |
Create a new abstract lock based on Mutexes.
| ||
make [BatList] |
Similar to
String.make , make n x returns a
list containing n elements x .
| ||
make [BatLazyList] |
Similar to
String.make , make n x returns a
list containing n elements x .
| ||
make [BatEnum] |
This function creates a fully defined enumeration.
| ||
make [BatDynArray] | make count returns an array with some memory already allocated so
up to count elements can be stored into it without resizing.
| ||
make [BatConcurrent.Lock] | |||
make [BatBounded.S] | |||
make [BatArray.Cap.Labels] | |||
make [BatArray.Cap] | |||
make [BatArray] | Array.make n x returns a fresh array of length n ,
initialized with x .
| ||
make_class [BatOo.Internal] | |||
make_class_store [BatOo.Internal] | |||
make_dbg_formatter [BatLogger] | make_dbg_formatter oc constructs a debug formatter from an
output channel.
| ||
make_decoding_table [BatBase64] |
Create a valid decoding table from an encoding one.
| ||
make_formatter [BatFormat] | make_formatter out flush returns a new formatter that writes according
to the output function out , and the flushing function flush .
| ||
make_ht [BatCache] |
Make a manual cache backed by a hashtable.
| ||
make_lexer [BatGenlex] |
Construct the lexer function.
| ||
make_log [BatLogger] | make_log name returns a new logger.
| ||
make_logger [BatLog] | |||
make_map [BatCache] |
Make a manual cache for function
~gen backed by a Set.t.
| ||
make_matrix [BatArray.Cap.Labels] | |||
make_matrix [BatArray.Cap] | |||
make_matrix [BatArray.Labels] | |||
make_matrix [BatArray] | Array.make_matrix dimx dimy e returns a two-dimensional array
(an array of arrays) with first dimension dimx and
second dimension dimy .
| ||
make_self_init [BatRandom.Incubator.Private_state_enums.State] |
Create a new state and initialize it with a system-dependent
low-entropy seed.
| ||
make_self_init [BatRandom.State] |
Create a new state and initialize it with a system-dependent
low-entropy seed.
| ||
make_std_formatter [BatLogger] | make_std_formatter oc constructs a formatter from an output
channel.
| ||
make_tree [BatAvlTree] | |||
map [BatVect.RANDOMACCESS] | |||
map [BatVect.Make] | map f v returns a vect isomorphic to v where each element of index
i equals f (get v i) .
| ||
map [BatVect] | map f v returns a vect isomorphic to v where each element of index
i equals f (get v i) .
| ||
map [BatTuple.Tuple5] | |||
map [BatTuple.Tuple4] | |||
map [BatTuple.Tuple3] | |||
map [BatTuple.Tuple2] |
Equivalent to
BatPervasives.
.
| ||
map [BatText] | map f s returns a rope where all characters c in s have been
replaced by f c .
| ||
map [BatString.Cap] | |||
map [BatString] | String.map f s applies function f in turn to all
the characters of s and stores the results in a new string that
is returned.
| ||
map [BatStream.StreamLabels] | |||
map [BatStream] | map f stream applies f in turn to elements from stream and return the
results as a stream in the same order.
| ||
map [BatSet.PSet] | map f x creates a new set with elements f a0 ,
f a1 ...
| ||
map [BatSet.S.Labels] | |||
map [BatSet.S] | map f x creates a new set with elements f a0 ,
f a1 ...
| ||
map [BatSet] | map f x creates a new set with elements f a0 ,
f a1 ...
| ||
map [BatSeq] | map f s returns the sequence where elements are elements of
s mapped with f .
| ||
map [BatRefList] |
Apply a function to all elements
and return the ref list constructed with
the function returned values
| ||
map [BatPervasives] |
Transformation loop on an enumeration, used to build an enumeration
from another enumeration.
| ||
map [BatPathGen.PathType] |
Map a path through a function that operates on separate components.
| ||
map [BatOption.Labels] | |||
map [BatOption] | map f (Some x) returns Some (f x) and map f None returns None .
| ||
map [BatMultiPMap] | map f m returns a map with same domain as m , where the
associated value a of all bindings of m has been
replaced by the result of the application of f to a .
| ||
map [BatMultiMap] | map f m returns a map with same domain as m , where the
associated value a of all bindings of m has been
replaced by the result of the application of f to a .
| ||
map [BatMap.PMap] | map f m returns a map with same domain as m , where the
associated value a of all bindings of m has been
replaced by the result of the application of f to a .
| ||
map [BatMap.S.Labels] | |||
map [BatMap.S] | map f m returns a map with same domain as m , where the
associated value a of all bindings of m has been
replaced by the result of the application of f to a .
| ||
map [BatMap] | map f m returns a map with same domain as m , where the
associated value a of all bindings of m has been
replaced by the result of the application of f to a .
| ||
map [BatList.Labels] | |||
map [BatList] | map f [a0; a1; ...; an] applies function f to a0, a1, ..., an ,
and builds the list [f a0; f a1; ...; f an]
with the results returned by f .
| ||
map [BatLazyList.Labels] | |||
map [BatLazyList] |
Lazy map
| ||
map [BatInterfaces.Mappable] | map f e applies f to every element of e and returns the corresponding data structure
| ||
map [BatIMap] |
Create a new map by modifying each
y by the given function.
| ||
map [BatHashtbl.Cap.Labels] | |||
map [BatHashtbl.Cap] | |||
map [BatHashtbl.S.Labels] | |||
map [BatHashtbl.S] | |||
map [BatHashtbl.Labels] | |||
map [BatHashtbl] | map f x creates a new hashtable with the same
keys as x , but with the function f applied to
all the values
| ||
map [BatFingerTree.S] | map is equivalent to List.map .
| ||
map [BatEnum.Labels] | |||
map [BatEnum] | map f e returns an enumeration over (f a0, f a1, ...) where
a0,a1... are the elements of e .
| ||
map [BatDynArray] | map f darr applies the function f to every element of darr
and creates a dynamic array from the results - similar to List.map or
Array.map .
| ||
map [BatDllist] |
Allocate a new list, with entirely new nodes, whose values are
the transforms of the values of the original list.
| ||
map [BatDeque] | map f dq returns a deque where every element x of dq has
been replaces with f x .
| ||
map [BatBounded.S] | map f x applies f to x .
| ||
map [BatBigarray.Array3] | Array3.map f a applies function f to all the elements of a ,
and builds a Bigarray.Array3.t with the results returned by f .
| ||
map [BatBigarray.Array2] | Array2.map f a applies function f to all the elements of a ,
and builds a Bigarray.Array2.t with the results returned by f .
| ||
map [BatBigarray.Array1] | Array1.map f a applies function f to all the elements of a ,
and builds a Bigarray.Array1.t with the results returned by f .
| ||
map [BatBigarray.Genarray] | map f kind a applies function f to all the elements of a ,
and builds a Bigarray.t of kind kind with the results
returned by f .
| ||
map [BatArray.Cap.Labels] | |||
map [BatArray.Cap] | |||
map [BatArray.Labels] | |||
map [BatArray] | Array.map f a applies function f to all the elements of a ,
and builds an array with the results returned by f :
[| f a.(0); f a.(1); ...; f a.(Array.length a - 1) |] .
| ||
map1 [BatTuple.Tuple5] | |||
map1 [BatTuple.Tuple4] | |||
map1 [BatTuple.Tuple3] | |||
map1 [BatTuple.Tuple2] | map1 f (x,y) returns (f x,y)
| ||
map2 [BatTuple.Tuple5] | |||
map2 [BatTuple.Tuple4] | |||
map2 [BatTuple.Tuple3] | |||
map2 [BatTuple.Tuple2] | map2 f (x,y) returns (x,f y)
| ||
map2 [BatStream.StreamLabels] | |||
map2 [BatStream] | map2 f streama streamb applies f in turn to elements of corresponding
positions from streama and streamb .
| ||
map2 [BatList.Labels] | |||
map2 [BatList] | List.map2 f [a0; a1; ...; an] [b0; b1; ...; bn] is
[f a0 b0; f a1 b1; ...; f an bn] .
| ||
map2 [BatLazyList.Labels] | |||
map2 [BatLazyList] |
Operations on two lists
| ||
map2 [BatBounded.S] | map f x y applies f to x and y .
| ||
map2 [BatArray] |
As
Array.map but on two arrays.
| ||
map2_exn [BatBounded.S] | map f x y applies f to x and y .
| ||
map3 [BatTuple.Tuple5] | |||
map3 [BatTuple.Tuple4] | |||
map3 [BatTuple.Tuple3] | |||
map4 [BatTuple.Tuple5] | |||
map4 [BatTuple.Tuple4] | |||
map5 [BatTuple.Tuple5] | |||
map_comp [BatOrd] | |||
map_default [BatResult] | map_default d f r evaluates to d if r is Bad else f x
when r is Ok x
| ||
map_default [BatOption.Labels] | |||
map_default [BatOption] | map_default f x (Some v) returns f v and map_default f x None
returns x .
| ||
map_eq [BatOrd] | |||
map_exn [BatBounded.S] | map_exn f x applies f to x .
| ||
map_ext [BatPathGen.PathType] | map_ext fu path returns path but with the name with extension given by fu ( BatPathGen.PathType.ext path) .
| ||
map_file [BatBigarray.Array3] |
Memory mapping of a file as a three-dimensional big array.
| ||
map_file [BatBigarray.Array2] |
Memory mapping of a file as a two-dimensional big array.
| ||
map_file [BatBigarray.Array1] |
Memory mapping of a file as a one-dimensional big array.
| ||
map_file [BatBigarray.Genarray] |
Memory mapping of a file as a big array.
| ||
map_list [BatRefList] |
Apply a function to all elements
and return the list constructed with
the function returned values
| ||
map_name [BatPathGen.PathType] | |||
map_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] | |||
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_num [BatNumber.Bounded] | |||
min_num [BatNum] | |||
min_num [BatNativeint] | |||
min_num [BatInt32] | |||
min_num [BatInt.Safe_int] |
The smallest representable integer, -230 or 262.
| ||
min_num [BatInt] |
The smallest representable integer, -230 or -262.
| ||
min_num [BatFloat.Safe_float] | |||
min_num [BatFloat] | |||
min_num [BatBool] | |||
min_ord [BatOrd] | |||
minor [BatGc] |
Trigger a minor collection.
| ||
minus_big_int [BatBig_int] |
Unary negation.
| ||
minus_num [BatNum] | |||
minus_one [BatNativeint] |
The native integer -1.
| ||
minus_one [BatInt64] |
The 64-bit integer -1.
| ||
minus_one [BatInt32] |
The 32-bit integer -1.
| ||
minus_one [BatInt.Safe_int] |
The integer
-1 .
| ||
minus_one [BatInt] |
The integer
-1 .
| ||
mkdir [BatUnix] |
Create a directory with the given permissions.
| ||
mkfifo [BatUnix] |
Create a named pipe with the given permissions.
| ||
mktime [BatUnix] |
Convert a date and time, specified by the
tm argument, into
a time in seconds, as returned by Unix.time .
| ||
mod_big_int [BatBig_int] |
Euclidean modulus of two big integers.
| ||
mod_num [BatNum] | |||
modf [BatFloat.Safe_float] | modf f returns the pair of the fractional and integral
part of f .
| ||
modf [BatFloat] | modf f returns the pair of the fractional and integral
part of f .
| ||
modify [BatVect.Make] | modify v n f is equivalent to set v n (f (get v n)) , but
more efficient.
| ||
modify [BatVect] | modify v n f is equivalent to set v n (f (get v n)) , but
more efficient.
| ||
modify [BatMap.PMap] | modify k f m replaces the previous binding for k with f
applied to that value.
| ||
modify [BatMap.S] | modify k f m replaces the previous binding for k with f applied to
that value.
| ||
modify [BatMap] | modify k f m replaces the previous binding for k with f
applied to that value.
| ||
modify [BatBigarray.Array3] | modify f a changes each element x in a to f x
in-place.
| ||
modify [BatBigarray.Array2] | modify f a changes each element x in a to f x
in-place.
| ||
modify [BatBigarray.Array1] | modify f a changes each element x in a to f x
in-place.
| ||
modify [BatBigarray.Genarray] | modify f a changes each element x in a to f x
in-place.
| ||
modify [BatArray.Cap.Labels] | |||
modify [BatArray.Cap] | |||
modify [BatArray.Labels] | |||
modify [BatArray] | modify f a replaces every element x of a with f x .
| ||
modify_def [BatMap.PMap] | modify_def v0 k f m replaces the previous binding for k
with f applied to that value.
| ||
modify_def [BatMap.S] | modify_def v0 k f m replaces the previous binding for k
with f applied to that value.
| ||
modify_def [BatMap] | modify_def v0 k f m replaces the previous binding for k
with f applied to that value.
| ||
modifyi [BatBigarray.Array1] |
Same as
Bigarray.Array1.modify , but the function is applied
to the index of the element as the first argument, and the
element itself as the second argument.
| ||
modifyi [BatBigarray.Genarray] |
Same as
BatBigarray.Genarray.modify , but the function is applied to the index of
the coordinates as the first argument, and the element itself
as the second argument.
| ||
modifyi [BatArray.Cap.Labels] | |||
modifyi [BatArray.Cap] | |||
modifyi [BatArray.Labels] | |||
modifyi [BatArray] |
Same as
BatArray.modify , but the function is applied to the index of
the element as the first argument, and the element itself as
the second argument.
| ||
modifyij [BatBigarray.Array2] |
Same as
Bigarray.Array2.modify , but the function is applied
to the index of the element as the first two arguments, and the
element itself as the third argument.
| ||
modifyijk [BatBigarray.Array3] |
Same as
Bigarray.Array3.modify , but the function is applied
to the index of the coordinates as the first three arguments, and the
element itself as the fourth argument.
| ||
modulo [BatNumber.Numeric] | |||
modulo [BatNum] | |||
modulo [BatNativeint] | |||
modulo [BatInt64] | |||
modulo [BatInt32] | |||
modulo [BatInt.Safe_int] | modulo a b computes the remainder of the integer
division of a by b .
| ||
modulo [BatInt] | modulo a b computes the remainder of the integer
division of a by b .
| ||
modulo [BatFloat.Safe_float] | |||
modulo [BatFloat] | |||
modulo [BatComplex] | |||
modulo [BatBool] | |||
modulo [BatBig_int] | |||
move [BatUTF8] | move s i n
returns n -th Unicode character after i if n >= 0,
n -th Unicode character before i if n < 0.
| ||
mul [BatNumber.Numeric] | |||
mul [BatNum] | |||
mul [BatNativeint] |
Multiplication.
| ||
mul [BatInt64] |
Multiplication.
| ||
mul [BatInt32] |
Multiplication.
| ||
mul [BatInt.Safe_int] |
Multiplication.
| ||
mul [BatInt] |
Multiplication.
| ||
mul [BatFloat.Safe_float] | |||
mul [BatFloat] | |||
mul [BatComplex] |
Multiplication
| ||
mul [BatBool] | |||
mul [BatBig_int] | |||
mult_big_int [BatBig_int] |
Multiplication of two big integers.
| ||
mult_int_big_int [BatBig_int] |
Multiplication of a big integer by a small integer
| ||
mult_num [BatNum] | |||
multi_choice [BatRandom] | multi_choice n e returns an enumeration of n
randomly-chosen elements of e .
| ||
multiline_comment [BatGenlex.Languages.Make] | |||
must [BatParserCo] |
Prevent backtracking.
| ||
N | |||
n_cartesian_product [BatList] |
Given n lists, return the n-way cartesian product of
these lists.
| ||
name [BatPathGen.PathType] |
Returns name of the object the pathname points to, i.e.
| ||
name [BatGlobal] |
Retrieve the name of a global.
| ||
name_core [BatPathGen.PathType] |
Returns part of the name to the left of rightmost dot.
| ||
name_of_input [BatScanf.Scanning] | Scanning.file_name_of_input ib returns the name of the character source
for the scanning buffer ib .
| ||
name_of_level [BatLogger] | name_of_level level returns the name of the specified level .
| ||
nan [BatFloat.Safe_float] |
A special floating-point value denoting the result of an
undefined operation such as
0.0 /. 0.0 .
| ||
nan [BatFloat] |
A special floating-point value denoting the result of an
undefined operation such as
0.0 /. 0.0 .
| ||
narrow [BatOo.Internal] | |||
nat_of_num [BatNum] |
Coercions between numerical types
| ||
nativeint [BatRandom.Incubator.Private_state_enums.State] | |||
nativeint [BatRandom.State] | |||
nativeint [BatRandom] | Random.nativeint bound returns a random integer between 0 (inclusive)
and bound (exclusive).
| ||
nativeint [BatBigarray] |
See
Bigarray.char .
| ||
nativeint_of_big_int [BatBig_int] |
Convert a big integer to a native integer.
| ||
neg [BatPervasives] | neg p returns a new predicate that is the negation of the given
predicate.
| ||
neg [BatNumber.Numeric] | |||
neg [BatNum] | |||
neg [BatNativeint] |
Unary negation.
| ||
neg [BatInt64] |
Unary negation.
| ||
neg [BatInt32] |
Unary negation.
| ||
neg [BatInt.Safe_int] |
Unary negation.
| ||
neg [BatInt] |
Unary negation.
| ||
neg [BatInnerPervasives] | |||
neg [BatFloat.Safe_float] | |||
neg [BatFloat] |
Returns the negation of the input, i.e.
| ||
neg [BatComplex] |
Unary negation.
| ||
neg [BatBool] | |||
neg [BatBig_int] | |||
neg2 [BatPervasives] |
as
neg but for predicates with two arguments
| ||
neg2 [BatInnerPervasives] | |||
neg_infinity [BatFloat.Safe_float] |
Negative infinity.
| ||
neg_infinity [BatFloat] |
Negative infinity.
| ||
nested_comments [BatGenlex.Languages.Definition] | |||
new_line [BatLexing] |
Update the
lex_curr_p field of the lexbuf to reflect the start
of a new line.
| ||
new_method [BatOo.Internal] | |||
new_methods_variables [BatOo.Internal] | |||
new_variable [BatOo.Internal] | |||
newline [BatCharParser] |
Recognizes a newline
| ||
next [BatUTF8] | next s i
returns the position of the head of the Unicode character
located immediately after i .
| ||
next [BatStream] |
Return the first element of the stream and remove it from the
stream.
| ||
next [BatLazyList] |
Common functions
| ||
next [BatDllist] |
Given a node, get the next element in the list after the node.
| ||
next_set_bit [BatBitSet] | next_set_bit s n returns Some m when m is the next set
element with index greater than or equal n , or None if no such
element exists (i.e.
| ||
nice [BatUnix] |
Change the process priority.
| ||
nil [BatSeq] | nil = fun () -> Nil
| ||
nil [BatLazyList] |
The empty list.
| ||
nolock [BatConcurrent] |
A lock which does nothing.
| ||
none_of [BatParserCo] |
Accept any value not in a list
Faster and more convenient than combining
satisfy and either .
| ||
none_of [BatCharParser] |
Accept any value not in a list
As
ParserCo.none_of , just with improved error message.
| ||
norm [BatComplex] |
Norm: given
x + i.y , returns sqrt(x^2 + y^2) .
| ||
norm2 [BatComplex] |
Norm squared: given
x + i.y , returns x^2 + y^2 .
| ||
normalize [BatPathGen.PathType] |
Deprecated name for
normalize_in_tree
| ||
normalize_filepath [BatPathGen.PathType] |
Consumes single dots where possible, e.g.:
| ||
normalize_in_graph [BatPathGen.PathType] |
Another name for
normalize_filepath .
| ||
normalize_in_tree [BatPathGen.PathType] |
Consumes single dots and applies double dots where possible, e.g.:
| ||
not [BatBool] |
The boolean negation.
| ||
not_char [BatCharParser] |
Accept any value not a given char
As
none_of .
| ||
npeek [BatStream] | npeek n returns the list of the n first elements of
the stream, or all its remaining elements if less than n
elements are available.
| ||
npop [BatRefList] |
Removes and returns the n first elements or
raises
Empty_list if the ref list does not
contain enough elements
| ||
nread [BatInnerIO] | nread i n reads a string of size up to n from an input.
| ||
nread [BatIO] | nread i n reads a string of size up to n from an input.
| ||
nreplace [BatString.Cap] | |||
nreplace [BatString] | nreplace ~str ~sub ~by returns a string obtained by iteratively
replacing each occurrence of sub by by in str , from right to left.
| ||
nsplit [BatText] | nsplit s sep splits the rope s into a list of ropes
which are separated by sep .
| ||
nsplit [BatString.Cap] | |||
nsplit [BatString] | nsplit s sep splits the string s into a list of strings
which are separated by sep (excluded).
| ||
nth [BatUTF8] | nth s n returns the position of the n -th Unicode character.
| ||
nth [BatList] |
Obsolete.
| ||
nth [BatLazyList] |
Obsolete.
| ||
nth [BatBuffer] |
get the n-th character of the buffer.
| ||
nth_dim [BatBigarray.Genarray] | Genarray.nth_dim a n returns the n -th dimension of the
big array a .
| ||
null_formatter [BatLogger] | null_formatter is a formatter that does not output any
events, but simply discards them.
| ||
num_digits_big_int [BatBig_int] |
Return the number of machine words used to store the
given big integer.
| ||
num_dims [BatBigarray.Genarray] |
Return the number of dimensions of the given big array.
| ||
num_of_big_int [BatNum] | |||
num_of_int [BatNum] | |||
num_of_nat [BatNum] | |||
num_of_ratio [BatNum] | |||
num_of_string [BatNum] | |||
number [BatGenlex.Languages.Make] |
Parse either an integer or a floating-point number.
| ||
numeric_compare [BatString] |
Compare two strings, sorting "abc32def" before "abc210abc".
| ||
nwrite [BatInnerIO] |
Write a string to an output.
| ||
nwrite [BatIO] |
Write a string to an output.
| ||
O | |||
ocaml_version [BatSys] | ocaml_version is the version of OCaml.
| ||
of_array [BatVect.Make] | of_array s returns a vect corresponding to the array s .
| ||
of_array [BatVect] | of_array s returns a vect corresponding to the array s .
| ||
of_array [BatLazyList] |
Eager conversion from array
| ||
of_array [BatDynArray] | of_array arr returns an array with the elements of arr in it
in order.
| ||
of_array [BatBigarray.Array3] |
Build a three-dimensional big array initialized from the
given array of arrays of arrays.
| ||
of_array [BatBigarray.Array2] |
Build a two-dimensional big array initialized from the
given array of arrays.
| ||
of_array [BatBigarray.Array1] |
Build a one-dimensional big array initialized from the
given array.
| ||
of_array [BatArray.Cap] |
Adopt a regular array as a capability array, allowing
to decrease capabilities if necessary.
| ||
of_backwards [BatVect.RANDOMACCESS] | |||
of_backwards [BatVect.Make] |
Build a vector from an enumeration, from last to first.
| ||
of_backwards [BatVect] |
Build a vector from an enumeration, from last to first.
| ||
of_backwards [BatString.Cap] | |||
of_backwards [BatString] |
Build a string from an enumeration, starting with last character, ending with first.
| ||
of_backwards [BatRefList] |
Creates a ref list from an enumeration, going from last to first
| ||
of_backwards [BatList] |
Build a list from an enumeration.
| ||
of_backwards [BatFingerTree.S] | of_backward e is equivalent to reverse (of_enum e) .
| ||
of_backwards [BatArray.Cap] | |||
of_backwards [BatArray] |
Build an array from an enumeration, with the first element of
the enumeration as the last element of the array and vice
versa.
| ||
of_byte [BatInt32] | |||
of_channel [BatStream] |
Return the stream of the characters read from the input channel.
| ||
of_char [BatUChar] | of_char c returns the Unicode character of the Latin-1 character c
| ||
of_char [BatText] | of_char c returns a rope containing exactly Latin-1 character c .
| ||
of_char [BatString.Cap] | |||
of_char [BatString] |
Returns a string containing one given character.
| ||
of_container [BatVect.Make] | of_container s returns a vect corresponding to the container s .
| ||
of_digit [BatChar] |
Return the character representing a given digit.
| ||
of_enum [BatVect.RANDOMACCESS] | |||
of_enum [BatVect.Make] |
Build a vector from an enumeration.
| ||
of_enum [BatVect] |
Build a vector from an enumeration.
| ||
of_enum [BatTuple.Tuple5] | |||
of_enum [BatTuple.Tuple4] | |||
of_enum [BatTuple.Tuple3] | |||
of_enum [BatTuple.Tuple2] | |||
of_enum [BatString.Cap] | |||
of_enum [BatString] |
Creates a string from a character enumeration.
| ||
of_enum [BatStream] |
Convert an enumeration to a stream.
| ||
of_enum [BatStack] | of_enum e returns a new stack containing all the elements of
e .
| ||
of_enum [BatSet.PSet] | |||
of_enum [BatSet.S] | |||
of_enum [BatSet] | |||
of_enum [BatRefList] |
Creates a ref list from an enumeration
| ||
of_enum [BatQueue] | of_enum e returns a new queue containing all the elements of e .
| ||
of_enum [BatParserCo.Source] | |||
of_enum [BatOption] | of_enum e consumes the first element of e , if it exists, and
returns Some e .
| ||
of_enum [BatMultiPMap] |
creates a map from an enumeration, using the specified function
for key comparison or
compare by default.
| ||
of_enum [BatMultiMap] |
creates a map from an enumeration, using the specified function
for key comparison or
compare by default.
| ||
of_enum [BatMap.PMap] |
creates a map from an enumeration, using the specified function
for key comparison or
compare by default.
| ||
of_enum [BatMap.S] |
Create a map from a (key, value) enumeration.
| ||
of_enum [BatMap] |
Creates a map from an enumeration
| ||
of_enum [BatList] |
Build a list from an enumeration.
| ||
of_enum [BatLazyList] |
Lazy conversion from enum.
| ||
of_enum [BatISet] | |||
of_enum [BatHeap.H] |
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 [BatArray.Cap] | |||
of_enum [BatArray] |
Build an array from an enumeration.
| ||
of_enum_cmp [BatSet.PSet] | |||
of_float [BatString.Cap] | |||
of_float [BatString] |
Returns the string representation of an float.
| ||
of_float [BatNumber.Numeric] | |||
of_float [BatNum] | |||
of_float [BatNativeint] |
Convert the given floating-point number to a native integer,
discarding the fractional part (truncate towards 0).
| ||
of_float [BatInt64] |
Convert the given floating-point number to a 64-bit integer,
discarding the fractional part (truncate towards 0).
| ||
of_float [BatInt32] |
Convert the given floating-point number to a 32-bit integer,
discarding the fractional part (truncate towards 0).
| ||
of_float [BatInt.Safe_int] |
Convert the given floating-point number to integer,
discarding the fractional part (truncate towards 0).
| ||
of_float [BatInt] |
Convert the given floating-point number to integer integer,
discarding the fractional part (truncate towards 0).
| ||
of_float [BatFloat.Safe_float] | |||
of_float [BatFloat] | |||
of_float [BatComplex] | Complex.of_float x returns the complex number x+0i
| ||
of_float [BatBool] | 0. , nan +infinity and -infiity are false .
| ||
of_float [BatBig_int] |
rounds to the nearest integer
| ||
of_fun [BatStream] | Stream.of_fun f returns a stream built from the function f .
| ||
of_input [BatSubstring] | |||
of_input [BatStream] |
Convert an
input to a stream.
| ||
of_int [BatUChar] |
Alias of
chr
| ||
of_int [BatString.Cap] | |||
of_int [BatString] |
Returns the string representation of an int.
| ||
of_int [BatNumber.Numeric] | |||
of_int [BatNum] | |||
of_int [BatNativeint] |
Convert the given integer (type
int ) to a native integer
(type nativeint ).
| ||
of_int [BatInt64] |
Convert the given integer (type
int ) to a 64-bit integer
(type int64 ).
| ||
of_int [BatInt32] |
Convert the given integer (type
int ) to a 32-bit integer
(type int32 ).
| ||
of_int [BatInt.Safe_int] | |||
of_int [BatInt] | |||
of_int [BatFloat.Safe_float] | |||
of_int [BatFloat] | |||
of_int [BatComplex] | |||
of_int [BatBool] |
anything but
0 is true
| ||
of_int [BatBig_int] | |||
of_int32 [BatNativeint] |
Convert the given 32-bit integer (type
int32 )
to a native integer.
| ||
of_int32 [BatInt64] |
Convert the given 32-bit integer (type
int32 )
to a 64-bit integer (type int64 ).
| ||
of_int64 [BatNativeint] |
Convert the given 64-bit integer (type
int64 )
to a native integer.
| ||
of_int64 [BatInt32] |
Convert the given 64-bit integer (type
int64 ) to a
32-bit integer (type int32 ).
| ||
of_latin1 [BatText] |
Constructs a unicode rope from a latin-1 string.
| ||
of_list [BatVect.Make] | |||
of_list [BatVect] | |||
of_list [BatString.Cap] | |||
of_list [BatString] |
Converts a list of characters to a string.
| ||
of_list [BatStream] |
Return the stream holding the elements of the list in the same
order.
| ||
of_list [BatSplay.Map] | |||
of_list [BatSet.PSet] |
builds a set from the given list, using the default comparison
function
| ||
of_list [BatSet] |
builds a set from the given list, using the default comparison
function
| ||
of_list [BatRefList] |
Creates a ref list from a list - O(1)
| ||
of_list [BatLazyList] |
Lazy conversion from lists
| ||
of_list [BatISet] |
Build a ISet.t out of a list or enum of ranges
| ||
of_list [BatHeap.H] |
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_start [BatGenlex.Languages.Definition] | |||
open_box [BatFormat] | open_box d opens a new pretty-printing box
with offset d .
| ||
open_connection [BatUnix] |
Connect to a server at the given address.
| ||
open_hbox [BatFormat] | open_hbox () opens a new pretty-printing box.
| ||
open_hovbox [BatFormat] | open_hovbox d opens a new pretty-printing box
with offset d .
| ||
open_hvbox [BatFormat] | open_hvbox d opens a new pretty-printing box
with offset d .
| ||
open_in [BatPervasives] |
Open the named file for reading.
| ||
open_in [BatFile] | open_in file_name opens the file named file_name for reading.
| ||
open_in_bin [BatPervasives] |
Same as
Pervasives.open_in , but the file is opened in binary mode,
so that no translation takes place during reads.
| ||
open_in_gen [BatPervasives] | open_in mode perm filename opens the named file for reading,
as described above.
| ||
open_out [BatPervasives] |
Open the named file for writing, and return a new output channel
on that file.
| ||
open_out [BatFile] | open_out file_name opens the file named file_name for writing.
| ||
open_out_bin [BatPervasives] |
Same as
BatPervasives.open_out , but the file is opened in binary mode, so
that no translation takes place during writes.
| ||
open_out_gen [BatPervasives] | open_out_gen mode perm filename opens the named file for writing,
as described above.
| ||
open_process [BatUnix] |
Same as
Unix.open_process_out , but redirects both the
standard input and standard output of the command to pipes
connected to the two returned input /output .
| ||
open_process_full [BatUnix] |
Similar to
Unix.open_process , but the second argument
specifies the environment passed to the command.
| ||
open_process_in [BatUnix] |
High-level pipe and process management.
| ||
open_process_out [BatUnix] |
Same as
Unix.open_process_in , but redirect the standard input of
the command to a pipe.
| ||
open_tag [BatFormat] | open_tag t opens the tag named t ; the print_open_tag
function of the formatter is called with t as argument;
the tag marker mark_open_tag t will be flushed into the output
device of the formatter.
| ||
open_tbox [BatFormat] |
Opens a tabulation box.
| ||
open_temporary_out [BatFile] | open_temporary_out () opens a new temporary file for writing.
| ||
open_vbox [BatFormat] | open_vbox d opens a new pretty-printing box
with offset d .
| ||
opendir [BatUnix] |
Open a descriptor on a directory
| ||
openfile [BatUnix] |
Open the named file with the given flags.
| ||
operations [BatNumber.Numeric] | |||
operations [BatNum] | |||
operations [BatNativeint] | |||
operations [BatInt64] | |||
operations [BatInt.Safe_int] | |||
operations [BatInt] | |||
operations [BatFloat.Safe_float] | |||
operations [BatFloat] | |||
operations [BatComplex] | |||
operations [BatBool] | |||
operations [BatBig_int] | |||
opt [BatOptParse.Opt] |
Get the value of an option as an optional value.
| ||
opt_of_ord [BatBounded] | opt_of_ord ~bounds:(low, high) ord will returning a bounding function
using ord for value comparison and None for values which fall outside
of the requested range.
| ||
or_big_int [BatBig_int] |
Bitwise logical ``or''.
| ||
ord [BatVect] | |||
ord [BatUnit] |
Always returns
BatOrd.Eq
| ||
ord [BatTuple.Tuple5] | |||
ord [BatTuple.Tuple4] | |||
ord [BatTuple.Tuple3] | |||
ord [BatTuple.Tuple2] | |||
ord [BatString] |
Ordering function for strings, see
BatOrd
| ||
ord [BatRef] | |||
ord [BatOrd] |
Returns a variant ordering from a legacy comparison
| ||
ord [BatNumber.Numeric] | |||
ord [BatNum] | |||
ord [BatNativeint] | |||
ord [BatList] | |||
ord [BatInt64] | |||
ord [BatInt32] | |||
ord [BatInt.Safe_int] | |||
ord [BatInt] | |||
ord [BatISet] |
Same as
compare but returns BatOrd.Lt | BatOrd.Eq | BatOrd.Gt
instead of an int.
| ||
ord [BatFloat] | |||
ord [BatEnum] |
Same as
compare but returning a BatOrd.order instead of an interger.
| ||
ord [BatComplex] | |||
ord [BatOrd.Ord] | |||
ord [BatChar] | |||
ord [BatBool] | |||
ord [BatBitSet] | ord s1 s2 returns BatOrd.Lt , BatOrd.Eq or BatOrd.Gt if compare s1 s2
is, respectively, < 0 , 0 or > 0 .
| ||
ord [BatBig_int] | |||
ord [BatArray.Incubator.Ord] | |||
ord [BatArray.Cap] | |||
ord [BatArray] |
Hoist an element comparison function to compare arrays of those
elements, with shorter arrays less than longer ones, and
lexicographically for arrays of the same size.
| ||
ord0 [BatOrd] | |||
ord_by [BatOrd.Incubator] |
Build a
eq , cmp or ord function from a projection function.
| ||
os_type [BatSys] |
Operating system currently executing the OCaml program.
| ||
oset [BatRef] |
Set the given option ref to
Some x
| ||
other_exec [BatFile] |
Give the permission to execute the file to the rest
of the world.
| ||
other_read [BatFile] |
Give the permission to read the file to the rest
of the world.
| ||
other_write [BatFile] |
Give the permission to modify the file to the rest
of the world.
| ||
out [BatLog.Config] | |||
out_channel_of_descr [BatUnix] |
Create an output channel writing on the given descriptor.
| ||
out_of_range [BatUTF8] | out_of_range s i
tests whether i is a position inside of s .
| ||
output [BatPervasives] | output oc buf pos len writes len characters from string buf ,
starting at offset pos , to the given output channel oc .
| ||
output [BatMarshal] | output out v writes the representation of v on chan .
| ||
output [BatLog.Make_lev] | |||
output [BatLog.Easy] | |||
output [BatLog] |
This ref holds the output channel for simple logging.
| ||
output [BatInnerIO] | output o s p l writes up to l characters from string s , starting at
offset p .
| ||
output [BatIO] | output o s p l writes up to l characters from string s , starting at
offset p .
| ||
output [BatDigest] |
Write a digest on the given output.
| ||
output_binary_float [BatPervasives] |
Write one float in binary format (8 bytes, IEEE 754 double format)
on the given output channel.
| ||
output_binary_int [BatPervasives] |
Write one integer in binary format (4 bytes, big-endian)
on the given output channel.
| ||
output_bits [BatIO] |
Write bits to an output
| ||
output_buffer [BatBuffer] | output_buffer b creates an output channel that writes to that
buffer, and when closed, returns the contents of the buffer.
| ||
output_byte [BatPervasives] |
Write one 8-bit integer (as the single character with that code)
on the given output channel.
| ||
output_channel [BatInnerIO] |
Create an output that will write into a channel.
| ||
output_channel [BatIO] |
Create an output that will write into a channel.
| ||
output_char [BatPervasives] |
Write the character on the given output channel.
| ||
output_enum [BatIO] |
Create an output that will write into an
enum .
| ||
output_file [BatPervasives] |
creates a filename, write text into it and close it.
| ||
output_of_descr [BatUnix] |
Create an
output writing on the given descriptor.
| ||
output_string [BatPervasives] |
Write the string on the given output channel.
| ||
output_string [BatInnerIO] |
Create an output that will write into a string in an efficient way.
| ||
output_string [BatIO] |
Create an output that will write into a string in an efficient way.
| ||
output_text [BatText] |
Write the text on the given output channel.
| ||
output_value [BatPervasives] |
Write the representation of a structured value of any type
to a channel.
| ||
over_max_boxes [BatFormat] |
Tests if the maximum number of boxes allowed have already been opened.
| ||
P | |||
p [BatPathGen.PathType] | |||
pack [BatInt32] | pack str off i writes the little endian bit representation
of i into string str at offset off
| ||
pack_big [BatInt32] | pack_big str off i writes the big endian bit
representation of i into string str at offset off
| ||
params [BatOo.Internal] | |||
parent [BatPathGen.PathType] |
Returns parent path, i.e.
| ||
parse [BatOptParse.OptParser] |
Parse arguments as if the arguments
args.(first) ,
args.(first+1) , ..., args.(last) had been given on the
command line.
| ||
parse [BatCharParser] |
Apply a parser to a string.
| ||
parse_argv [BatOptParse.OptParser] |
Parse all the arguments in
Sys.argv .
| ||
partition [BatVect.Make] | partition p v returns a pair of vects (v1, v2) , where
v1 is the vect of all the elements of v that
satisfy the predicate p , and v2 is the vect of all the
elements of v that do not satisfy p .
| ||
partition [BatVect] | partition p v returns a pair of vects (v1, v2) , where
v1 is the vect of all the elements of v that
satisfy the predicate p , and v2 is the vect of all the
elements of v that do not satisfy p .
| ||
partition [BatSet.PSet] |
returns two disjoint subsets, those that satisfy the given
predicate and those that don't
| ||
partition [BatSet.S.Labels] | |||
partition [BatSet.S] | partition p s returns a pair of sets (s1, s2) , where
s1 is the set of all the elements of s that satisfy the
predicate p , and s2 is the set of all the elements of
s that do not satisfy p .
| ||
partition [BatSet] |
returns two disjoint subsets, those that satisfy the given
predicate and those that don't
| ||
partition [BatMap.PMap] | partition p m returns a pair of maps (m1, m2) , where m1
contains all the bindings of s that satisfy the predicate
p , and m2 is the map with all the bindings of s that do
not satisfy p .
| ||
partition [BatMap.S] | partition p m returns a pair of maps (m1, m2) , where
m1 contains all the bindings of s that satisfy the
predicate p , and m2 is the map with all the bindings of
s that do not satisfy p .
| ||
partition [BatMap] | partition p m returns a pair of maps (m1, m2) , where m1
contains all the bindings of s that satisfy the predicate
p , and m2 is the map with all the bindings of s that do
not satisfy p .
| ||
partition [BatList.Labels] | |||
partition [BatList] | partition p l returns a pair of lists (l1, l2) , where
l1 is the list of all the elements of l that
satisfy the predicate p , and l2 is the list of all the
elements of l that do not satisfy p .
| ||
partition [BatISet] |
partitions the input set into two sets with elements that satisfy
the predicate and those that don't
| ||
partition [BatEnum] |
as
switch
| ||
partition [BatArray.Cap] | |||
partition [BatArray] | partition p a returns a pair of arrays (a1, a2) , where
a1 is the array of all the elements of a that
satisfy the predicate p , and a2 is the array of all the
elements of a that do not satisfy p .
| ||
pass [BatPrintexc] | Printexc.pass fn x applies fn to x and returns the result.
| ||
pause [BatUnix] |
Wait until a non-ignored, non-blocked signal is delivered.
| ||
peek [BatStream] |
Return
Some of "the first element" of the stream, or None if
the stream is empty.
| ||
peek [BatQueue.Exceptionless] | |||
peek [BatQueue] | peek q returns the first element in queue q , without removing
it from the queue, or raises Empty if the queue is empty.
| ||
peek [BatPervasives] | peek e returns None if e is empty or Some x where x is
the next element of e .
| ||
peek [BatLazyList] | peek l returns the first element of l , if it exists.
| ||
peek [BatEnum] | peek e returns None if e is empty or Some x where x is
the next element of e .
| ||
perm [BatFile] |
Join permissions
| ||
perturb [BatRandom.Incubator.Private_state_enums.State] | perturb s returns a new state based on the given state
that is, in a sense, the hash of the input state.
| ||
pi [BatFloat.Safe_float] |
The constant pi (3.14159...)
| ||
pi [BatFloat] |
The constant pi (3.14159...)
| ||
pi2 [BatFloat] | pi /. 2.
| ||
pi4 [BatFloat] | pi /. 4.
| ||
pipe [BatUnix] |
Create a pipe.
| ||
pipe [BatInnerIO] |
Create a pipe between an input and an ouput.
| ||
pipe [BatIO] |
Create a pipe between an input and an ouput.
| ||
polar [BatComplex] | polar norm arg returns the complex having norm norm
and argument arg .
| ||
poly [BatOrd] |
Polymorphic comparison functions, based on the
Pervasives.compare function from inria's stdlib, have
polymorphic types: they claim to be able to compare values of any
type.
| ||
poly_comp [BatOrd] | |||
poly_ord [BatOrd] | |||
pop [BatVect.Make] |
Return the last element of a vector and its first
n-1 elements.
| ||
pop [BatVect] |
Return the last element of a vector and its first
n-1 elements.
| ||
pop [BatStack.Exceptionless] | |||
pop [BatStack] | pop s removes and returns the topmost element in stack s ,
or
| ||
pop [BatSet.PSet] |
returns one element of the set and the set without that element.
| ||
pop [BatSet.S] |
returns one element of the set and the set without that element.
| ||
pop [BatSet] |
returns one element of the set and the set without that element.
| ||
pop [BatRefList] |
Removes and returns the first element or
raises
Empty_list if the ref list is empty
| ||
pop [BatQueue] | pop is a synonym for take .
| ||
pop [BatMap.PMap] | pop m returns a binding from m and m without that
binding.
| ||
pop [BatMap.S] | pop m returns a binding from m and m without that
binding.
| ||
pop [BatMap] | pop m returns a binding from m and m without that
binding.
| ||
popcount [BatInt] |
Returns the number of 1 bits set in the binary representation of
the number.
| ||
pos_in [BatIO] |
Create an input that provide a count function of the number of bytes
read from it.
| ||
pos_out [BatIO] |
Create an output that provide a count function of the number of bytes
written through it.
| ||
post [BatRef] |
Perform an operation on a reference and return the
previous value of that reference.
| ||
post_decr [BatRef] |
Decrement an integer, return the old value.
| ||
post_incr [BatRef] |
Increment an integer, return the old value.
| ||
post_map [BatParserCo] |
Pass the (successful) result of some parser through a map.
| ||
pow [BatNumber.Numeric] | |||
pow [BatNum] | |||
pow [BatNativeint] | |||
pow [BatInt64] | |||
pow [BatInt32] | |||
pow [BatInt.Safe_int] | pow a b computes ab.
| ||
pow [BatInt] | pow a b computes ab.
| ||
pow [BatFloat.Safe_float] | |||
pow [BatFloat] | |||
pow [BatComplex] |
Power function.
| ||
pow [BatBool] | |||
pow [BatBig_int] | |||
power_big_int_positive_big_int [BatBig_int] |
Exponentiation functions.
| ||
power_big_int_positive_int [BatBig_int] | |||
power_int_positive_big_int [BatBig_int] | |||
power_int_positive_int [BatBig_int] | |||
power_num [BatNum] | |||
pp_close_box [BatFormat] | |||
pp_close_tag [BatFormat] | |||
pp_close_tbox [BatFormat] | |||
pp_force_newline [BatFormat] | |||
pp_get_all_formatter_output_functions [BatFormat] | |||
pp_get_ellipsis_text [BatFormat] | |||
pp_get_formatter_output_functions [BatFormat] | |||
pp_get_formatter_tag_functions [BatFormat] |
These functions are the basic ones: usual functions
operating on the standard formatter are defined via partial
evaluation of these primitives.
| ||
pp_get_margin [BatFormat] | |||
pp_get_mark_tags [BatFormat] | |||
pp_get_max_boxes [BatFormat] | |||
pp_get_max_indent [BatFormat] | |||
pp_get_print_tags [BatFormat] | |||
pp_open_box [BatFormat] | |||
pp_open_hbox [BatFormat] | |||
pp_open_hovbox [BatFormat] | |||
pp_open_hvbox [BatFormat] | |||
pp_open_tag [BatFormat] | |||
pp_open_tbox [BatFormat] | |||
pp_open_vbox [BatFormat] | |||
pp_over_max_boxes [BatFormat] | |||
pp_print_as [BatFormat] | |||
pp_print_bool [BatFormat] | |||
pp_print_break [BatFormat] | |||
pp_print_char [BatFormat] | |||
pp_print_cut [BatFormat] | |||
pp_print_float [BatFormat] | |||
pp_print_flush [BatFormat] | |||
pp_print_if_newline [BatFormat] | |||
pp_print_int [BatFormat] | |||
pp_print_newline [BatFormat] | |||
pp_print_space [BatFormat] | |||
pp_print_string [BatFormat] | |||
pp_print_tab [BatFormat] | |||
pp_print_tbreak [BatFormat] | |||
pp_set_all_formatter_output_functions [BatFormat] | |||
pp_set_ellipsis_text [BatFormat] | |||
pp_set_formatter_out_channel [BatFormat] | |||
pp_set_formatter_output [BatFormat] | |||
pp_set_formatter_output_functions [BatFormat] | |||
pp_set_formatter_tag_functions [BatFormat] | |||
pp_set_margin [BatFormat] | |||
pp_set_mark_tags [BatFormat] | |||
pp_set_max_boxes [BatFormat] | |||
pp_set_max_indent [BatFormat] | |||
pp_set_print_tags [BatFormat] | |||
pp_set_tab [BatFormat] | |||
pp_set_tags [BatFormat] | |||
pre [BatRef] |
Perform an operation on a reference and return the
new value of that reference.
| ||
pre_decr [BatRef] |
Increment an integer, return the new value.
| ||
pre_incr [BatRef] |
Increment an integer, return the new value.
| ||
pred [BatNumber.Discrete] | |||
pred [BatNumber.Numeric] | |||
pred [BatNum] | |||
pred [BatNativeint] |
Predecessor.
| ||
pred [BatInt64] |
Predecessor.
| ||
pred [BatInt32] |
Predecessor.
| ||
pred [BatInt.Safe_int] |
Predecessor.
| ||
pred [BatInt] |
Predecessor.
| ||
pred [BatFloat.Safe_float] |
Substract
1. from a floating number.
| ||
pred [BatFloat] |
Substract
1. from a floating number.
| ||
pred [BatComplex] |
Remove
BatComplex.one from this number.
| ||
pred [BatBool] | |||
pred [BatBig_int] | |||
pred_big_int [BatBig_int] |
Predecessor (subtract 1).
| ||
pred_num [BatNum] | |||
prefix [BatLog.Config] | |||
prefix [BatLog] |
This ref holds the text printed before each log message.
| ||
prefix_action [BatEnum] | prefix_action f e will behave as e but guarantees that f ()
will be invoked exactly once before the current first element of e
is read.
| ||
prepend [BatVect.Make] | prepend c r returns a new vect with the c character at the
beginning in amortized O(1) time.
| ||
prepend [BatVect] | prepend c r returns a new vect with the c character at the
beginning in amortized O(1) time.
| ||
prepend [BatDllist] | prepend n a Creates a new node containing data a and inserts it into
the list before node n .
| ||
prepend_char [BatText] | prepend_char c r returns a new rope with the c character at the
beginning in amortized O(1) time.
| ||
prepend_list [BatDeque] | prepent_list l dq is equivalent to append (of_list l) dq ,
but more efficient.
| ||
prerr_all [BatPervasives] |
Print the contents of an input to the error output.
| ||
prerr_bool [BatPervasives] |
Print a boolean to stderr.
| ||
prerr_guess [BatPervasives] |
Attempt to print the representation of a runtime value on the
error output.
| ||
prev [BatUTF8] | prev s i
returns the position of the head of the Unicode character
located immediately before i .
| ||
prev [BatDllist] |
Given a node, get the previous element in the list before the node.
| ||
print [BatVect.Make] | |||
print [BatVect] | |||
print [BatUref] |
Print the uref.
| ||
print [BatUnit] |
Printing
| ||
print [BatTuple.Tuple5] | |||
print [BatTuple.Tuple4] | |||
print [BatTuple.Tuple3] | |||
print [BatTuple.Tuple2] | |||
print [BatText] |
Prints a rope to the given out_channel
| ||
print [BatSubstring] | print oc ss prints ss to the output channel oc
| ||
print [BatString.Cap] | |||
print [BatString] |
Print a string.
| ||
print [BatStack] | |||
print [BatSet.PSet] | |||
print [BatSet.S] | |||
print [BatSet] | |||
print [BatSeq] |
Print the contents of a sequence
| ||
print [BatResult] |
Print a result as Ok(x) or Bad(exn)
| ||
print [BatRef] | |||
print [BatQueue] | |||
print [BatPrintexc] |
Print an exception.
| ||
print [BatPervasives] |
Print and consume the contents of an enumeration.
| ||
print [BatOption] | |||
print [BatNum] |
Printing
| ||
print [BatNativeint] | |||
print [BatMultiPMap] | |||
print [BatMultiMap] | |||
print [BatMap.PMap] | |||
print [BatMap.S] | |||
print [BatMap] | |||
print [BatList] |
Print the contents of a list
| ||
print [BatLazyList] | |||
print [BatInt64] |
Printing
| ||
print [BatInt.Safe_int] | |||
print [BatInt] |
prints as decimal string
| ||
print [BatISet] | |||
print [BatHeap.H] |
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 [BatRefList] |
Reverses the ref list - O(n)
| ||
rev [BatOrd] |
Reverse a given ordering.
| ||
rev [BatList] |
List reversal.
| ||
rev [BatLazyList] |
Eager list reversal.
| ||
rev [BatDllist] |
List reversal.
| ||
rev [BatDeque] | rev dq reverses dq .
| ||
rev [BatArray.Cap] | |||
rev [BatArray] |
Array reversal.
| ||
rev_append [BatList] | List.rev_append l1 l2 reverses l1 and concatenates it to l2 .
| ||
rev_append [BatLazyList] |
Eager reverse-and-append
| ||
rev_comp [BatOrd] | |||
rev_comp0 [BatOrd] | |||
rev_drop [BatDllist] |
Remove node from the list no matter where it is.
| ||
rev_enum [BatDllist] |
Create a reverse enum of the list.
| ||
rev_in_place [BatArray.Cap] | |||
rev_in_place [BatArray] |
In-place array reversal.
| ||
rev_map [BatList.Labels] | |||
rev_map [BatList] | List.rev_map f l gives the same result as
List.rev ( List.map f l) .
| ||
rev_map2 [BatList.Labels] | |||
rev_map2 [BatList] | List.rev_map2 f l1 l2 gives the same result as
List.rev ( List.map2 f l1 l2) , but is tail-recursive and
more efficient.
| ||
rev_ord [BatOrd] | |||
rev_ord0 [BatOrd] | |||
reverse [BatFingerTree.S] | reverse t is equivalent to of_list (List.rev (to_list t)) .
| ||
rewinddir [BatUnix] |
Reposition the descriptor to the beginning of the directory
| ||
rfind [BatText] | rfind s x returns the starting index of the last occurrence
of rope x within rope s .
| ||
rfind [BatString.Cap.Exceptionless] | |||
rfind [BatString.Cap] | |||
rfind [BatString.Exceptionless] | rfind s x returns Some i , the starting index of the last occurrence
of string x within string s , or None if x is not a substring
of s .
| ||
rfind [BatString] | rfind s x returns the starting index of the last occurrence
of string x within string s .
| ||
rfind [BatRefList] |
Find the first element in the reversed ref list matching
the specified predicate
raise
Not_found if no element is found
| ||
rfind [BatList.Labels.LExceptionless] | |||
rfind [BatList.Labels] | |||
rfind [BatList.Exceptionless] | rfind p l returns Some x where x is the last element of l
such
that p x returns true or None if such element as not been found.
| ||
rfind [BatList] | rfind p l returns the last element x of l such as p x returns
true or
| ||
rfind [BatLazyList.Labels.Exceptionless] | |||
rfind [BatLazyList.Labels] | |||
rfind [BatLazyList.Exceptionless] | rfind p l returns Some x where x is the last element of l such
that p x returns true or None if such element as not been found.
| ||
rfind [BatLazyList] | rfind p l returns the last element x of l such as p x returns
true .
| ||
rfind_exn [BatLazyList.Labels] | |||
rfind_exn [BatLazyList] | find_exn p e l returns the last element of l such as p x
returns true or raises e if such an element has not been found.
| ||
rfind_from [BatText] | rfind_from s ofs x behaves as rfind s x but starts searching
at offset ofs .
| ||
rfind_from [BatString.Cap.Exceptionless] | |||
rfind_from [BatString.Cap] | |||
rfind_from [BatString.Exceptionless] | rfind_from s ofs x behaves as rfind s x but starts searching
at offset ofs .
| ||
rfind_from [BatString] | rfind_from s pos x behaves as rfind s x but starts searching
from the right at position pos + 1 .
| ||
rfindi [BatLazyList.Labels.Exceptionless] | |||
rfindi [BatLazyList.Labels] | |||
rfindi [BatLazyList.Exceptionless] | findi p e l returns Some (i, ai) where ai and i are respectively the
last element of l and its index, such that p i ai is true,
or None if no such element has been found.
| ||
rfindi [BatLazyList] | findi p e l returns the last element ai of l along with its
index i such that p i ai is true.
| ||
right [BatText] | left r len returns the rope containing the len last characters of r
| ||
right [BatString.Cap] | |||
right [BatString] | left r len returns the string containing the len last characters of r .
| ||
right [BatArray] | left r len returns the array containing the len last characters of r .
| ||
right_branch [BatAvlTree] | |||
rindex [BatText] | Rope.rindex s c returns the position of the rightmost
occurrence of character c in rope s .
| ||
rindex [BatSubstring] | rindex sus c returns the index of the last occurence of c in sus or
| ||
rindex [BatString.Cap.Exceptionless] | |||
rindex [BatString.Cap] | |||
rindex [BatString.Exceptionless] | rindex s c returns Some p , the position of the rightmost
occurrence of character c in string s or
None if c does not occur in s .
| ||
rindex [BatString] | String.rindex s c returns the character number of the last
occurrence of character c in string s .
| ||
rindex [BatPathGen.StringType] | |||
rindex_from [BatText] |
Same as
BatText.rindex , but start
searching at the character position given as second argument.
| ||
rindex_from [BatSubstring] | index_from sus i c returns the index of the last occurence of c in sus
before the index i or
| ||
rindex_from [BatString.Cap.Exceptionless] | |||
rindex_from [BatString.Cap] | |||
rindex_from [BatString.Exceptionless] |
Same as
String.Exceptionless.rindex , but start
searching at the character position given as second argument.
| ||
rindex_from [BatString] | String.rindex_from s i c returns the character number of the
last occurrence of character c in string s before position i+1 .
| ||
rindex_of [BatList] | rindex_of e l returns the index of the last occurrence of e
in l , or None if there is no occurrence of e in l
| ||
rindex_of [BatLazyList] | index_of e l returns the index of the last occurrence of e
in l , or None if there is no occurrence of e in l
| ||
rindex_ofq [BatList] | rindex_ofq e l behaves as rindex_of e l except it uses
physical equality
| ||
rindex_ofq [BatLazyList] | rindex_ofq e l behaves as rindex_of e l except it uses
physical equality
| ||
rmdir [BatUnix] |
Remove an empty directory.
| ||
root [BatPathGen.PathType] |
Root of the filesystem (
[""] ).
| ||
root [BatFloat] | root x n calculates the nth root of x.
| ||
root [BatAvlTree] | |||
rope_enum [BatteriesPrint] | |||
rope_pset [BatteriesPrint] | |||
round [BatNum] | |||
round [BatFloat] | round x rounds x to the nearest integral floating-point
(the nearest of floor x and ceil x ).
| ||
round_num [BatNum] | |||
round_to_int [BatFloat] | round_to_int x is int_of_float (round x) .
| ||
round_to_string [BatFloat] | round_to_string ~digits:d x will return a string
representation of x -- in base 10 -- rounded to d digits
after the decimal point.
| ||
rsplit [BatText] | rsplit s sep splits the rope s between the last
occurrence of sep .
| ||
rsplit [BatString.Cap.Exceptionless] | |||
rsplit [BatString.Cap] | |||
rsplit [BatString.Exceptionless] | rsplit s sep splits the string s between the last
occurrence of sep , or returns None if the separator
is not found.
| ||
rsplit [BatString] | rsplit s sep splits the string s between the last occurrence
of sep , and returns the two parts before and after the
occurence (excluded).
| ||
run [BatParserCo] | run p s executes parser p on source s .
| ||
run_initializers [BatOo.Internal] | |||
run_initializers_opt [BatOo.Internal] | |||
S | |||
s [BatPathGen.PathType] | |||
sat [BatParserCo] | satisfy p accepts one value p x such that p x = true
| ||
satisfy [BatParserCo] | satisfy p accepts one value p x such that p x = true
| ||
saturate_of_ord [BatBounded] | saturate_of_ord ~bounds:(low, high) ord will returning a bounding
function using ord for value comparison and low and high for values
which fall outside of the requested range.
| ||
scan [BatStream.StreamLabels] | |||
scan [BatStream] | scan is similar to scanl but without the init value:
scanl f init [< 'e0; 'e1; 'e2; ... >] is equivalent to
[< 'e0; '(f e0 e1); '(f (f e0 e1) e2); ... >]
| ||
scan [BatParserCo] |
Use a parser to extract list of tokens, but return
that list of tokens instead of whatever the original
parser returned.
| ||
scan [BatEnum] | scan is similar to scanl but without the init value: if e
contains x0 , x1 , x2 ..., scan f e is the enumeration containing
x0 , f x0 x1 , f (f x0 x1) x2 ...
| ||
scanf [BatScanf] |
Same as
Scanf.bscanf , but reads from the predefined scanning
buffer Scanf.Scanning.stdib that is connected to stdin .
| ||
scanl [BatStream.StreamLabels] | |||
scanl [BatStream] | scanl f init stream returns a stream of successive reduced
values from the left: scanl f init [< 'e0; 'e1; ... >] is
equivalent to
[< 'init; '(f init e0); '(f (f init e0) e1); ... >]
| ||
scanl [BatPervasives] |
Functional loop on an enumeration, used to build an enumeration
from both an enumeration and an initial value.
| ||
scanl [BatEnum] |
A variant of
fold producing an enumeration of its intermediate values.
| ||
second [BatTuple.Tuple5] | |||
second [BatTuple.Tuple4] | |||
second [BatTuple.Tuple3] | |||
second [BatTuple.Tuple2] |
Equivalent to
Pervasives.snd .
| ||
select [BatUnix] |
Wait until some input/output operations become possible on
some channels.
| ||
self_init [BatRandom] |
Initialize the generator with a more-or-less random seed chosen
in a system-dependent way.
| ||
send [BatUnix] |
Send data over a connected socket.
| ||
send [BatOo.Internal] | |||
sendcache [BatOo.Internal] | |||
sendself [BatOo.Internal] | |||
sendto [BatUnix] |
Send data over an unconnected socket.
| ||
seq [BatLazyList] | seq init step cond creates a sequence of data, which starts
from init , extends by step , until the condition cond
fails.
| ||
seq [BatEnum.Labels] | |||
seq [BatEnum] | seq init step cond creates a sequence of data, which starts
from init , extends by step , until the condition cond
fails.
| ||
sequence [BatEnum.WithMonad] | sequence e evaluates each monadic elements (of type 'a m ) contained in the enumeration e to get a monadic enumeration of 'a elements,
of type 'a BatEnum.t m .
| ||
set [BatVect.RANDOMACCESS] | |||
set [BatVect.Make] | set v n c returns a copy of the v vect where the (n+1)th element
(see also get ) has been set to c .
| ||
set [BatVect] | set v n c returns a copy of the v vect where the (n+1)th element
(see also get ) has been set to c .
| ||
set [BatText] | set r n c returns a copy of rope r where the (n+1)th character
has been set to c .
| ||
set [BatString.Cap] | |||
set [BatString] | String.set s n c modifies string s in place,
replacing the character number n by c .
| ||
set [BatRefList.Index] |
Change the element at the specified index
raise
Invalid_index if the index is outside 0 ; length-1
| ||
set [BatRef] |
As
:=
| ||
set [BatOptParse.Opt] |
Set the value of an option.
| ||
set [BatGlobal] |
Set the global value contents.
| ||
set [BatGc] | set r changes the GC parameters according to the control record r .
| ||
set [BatFingerTree] | set t i v returns t where the i -th element is now v .
| ||
set [BatDynArray] | set darr idx v sets the element of darr at index idx to value
v .
| ||
set [BatDllist] |
Given a node, set the data associated with that node.
| ||
set [BatBitSet] | set s n sets the 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] | |||
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 [BatISet] |
Return the singleton set containing only the given element
| ||
singleton [BatIMap] | |||
singleton [BatFingerTree.S] | singleton elt build the sequence containing elt as its sole
element.
| ||
singleton [BatEnum] |
Create an enumeration consisting in exactly one element.
| ||
singleton_tree [BatAvlTree] | |||
sinh [BatFloat.Safe_float] | |||
sinh [BatFloat] |
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 [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_out [BatIO] | |||
system [BatUnix] |
Execute the given command, wait until it terminates, and return
its termination status.
| ||
T | |||
tab_out [BatIO] |
Create an output shifted to the right by a number of spaces
(or other character as specified by
tab ).
| ||
tail [BatText] | tail r pos returns the rope containing all but the pos first characters of r
| ||
tail [BatString.Cap] | |||
tail [BatString] | tail r pos returns the string containing all but the pos first characters of r
| ||
tail [BatFingerTree.S] | tail t returns None when t is empty,
or Some tl where tl is the sequence t where the first element
has been removed.
| ||
tail [BatArray] | tail r pos returns the array containing all but the pos first characters of r
| ||
tail_exn [BatFingerTree.S] | tail_exn t returns the sequence t where the first element
has been removed.
| ||
take [BatStream] | take n stream returns the prefix of stream of length n , or stream
itself if n is greater than the length of stream
| ||
take [BatSeq] | take n s returns up to the n first elements from sequence
s , if available.
| ||
take [BatQueue.Exceptionless] | |||
take [BatQueue] | take q removes and returns the first element in queue q ,
or raises Empty if the queue is empty.
| ||
take [BatList] | take n l returns up to the n first elements from list l , if
available.
| ||
take [BatLazyList] | take n l returns up to the n first elements from list l , if
available.
| ||
take [BatEnum] | take n e returns the prefix of e of length n , or e
itself if n is greater than the length of e
| ||
take_while [BatStream.StreamLabels] | |||
take_while [BatStream] | take_while test stream returns the longest (possibly empty) prefix of
stream of elements that satisfy test .
| ||
take_while [BatSeq] | take_while f s returns the first elements of sequence s
which satisfy the predicate f .
| ||
take_while [BatList.Labels] | |||
take_while [BatList] | take_while p xs returns the (possibly empty) longest prefix of
elements of xs that satisfy the predicate p .
| ||
take_while [BatLazyList.Labels] | |||
take_while [BatLazyList] | take_while f xs returns the first elements of list xs
which satisfy the predicate f .
| ||
take_while [BatEnum.Labels] | |||
take_while [BatEnum] | take_while f e produces a new enumeration in which only remain
the first few elements x of e such that f x
| ||
takel [BatSubstring] | takel p sus returns the longest prefix (left substring) of sus
all of whose characters satisfy predicate p .
| ||
taker [BatSubstring] | taker p sus returns the longest suffix (right substring) of sus
all of whose characters satisfy predicate p .
| ||
takewhile [BatList] |
obsolete, as
BatList.take_while
| ||
tan [BatFloat.Safe_float] | |||
tan [BatFloat] |
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 si..i+n-1 represented by sus = (s, i, n).
| ||
to_string [BatString.Cap] |
Return a capability string as a regular string.
| ||
to_string [BatStream] |
convert stream of chars to string, using buffer
| ||
to_string [BatPrintexc] | Printexc.to_string e returns a string representation of the
exception e .
| ||
to_string [BatPathGen.StringType] |
Convert to primitive string with UTF-8 content.
| ||
to_string [BatPathGen.PathType] |
Convert to type primitive string with UTF-8 content.
| ||
to_string [BatNumber.Numeric] | |||
to_string [BatNum] |
Convert a number to a string, using fractional notation.
| ||
to_string [BatNativeint] |
Return the string representation of its argument, in decimal.
| ||
to_string [BatMarshal] | Marshal.to_string v flags returns a string containing
the representation of v as a sequence of bytes.
| ||
to_string [BatLog.Level_sig] |
The default level for loggers created with this; log messages
with level less than this won't be printed by default.
| ||
to_string [BatInt64] |
Return the string representation of its argument, in decimal.
| ||
to_string [BatInt32] |
Return the string representation of its argument, in signed decimal.
| ||
to_string [BatInt.Safe_int] |
Return the string representation of its argument, in signed decimal.
| ||
to_string [BatInt] |
Return the string representation of its argument, in signed decimal.
| ||
to_string [BatIO] | |||
to_string [BatFloat.Safe_float] | |||
to_string [BatFloat] | |||
to_string [BatComplex] | |||
to_string [BatBool] | |||
to_string [BatBig_int] | |||
to_string_fmt [BatStream.StreamLabels] | |||
to_string_fmt [BatStream] |
convert stream to string, using Printf with given format
| ||
to_string_fun [BatStream.StreamLabels] | |||
to_string_fun [BatStream] |
convert stream to string, using given conversion function
| ||
to_string_in_base [BatBig_int] | to_string_in_base b n returns the string representation in base b of
the given big integer n .
| ||
to_string_in_binary [BatBig_int] |
as
string_of_big_int , but in base 2
| ||
to_string_in_custom_base [BatBig_int] |
First argument, called
symbols , is the vector of the symbols used to
represent the digits in base b .
| ||
to_string_in_hexa [BatBig_int] |
as
string_of_big_int , but in base 16
| ||
to_string_in_octal [BatBig_int] |
as
string_of_big_int , but in base 8
| ||
to_table [BatHashtbl.Cap] |
Return a capability hashtable as a regular hashtable.
| ||
to_ustring [BatPathGen.PathType] |
Convert to the chosen
ustring type.
| ||
toggle [BatRef] |
Invert the boolean stored in the reference
| ||
toggle [BatBitSet] | toggle s n changes the nth-bit value in the bitset s .
| ||
tokens [BatSubstring] | tokens p sus returns the list of tokens in sus , from left to
right, where a token is a non-empty maximal substring of sus not
containing any delimiter, and a delimiter is a character satisfying
p .
| ||
top [BatStack.Exceptionless] | |||
top [BatStack] | top s returns the topmost element in stack s ,
or
| ||
top [BatQueue] | top is a synonym for peek .
| ||
total_size [BatMarshal] |
See
Marshal.header_size .
| ||
transfer [BatQueue] | transfer q1 q2 adds all of q1 's elements at the end of
the queue q2 , then clears q1 .
| ||
transform [BatRefList] |
transform all elements in the ref list
using a function.
| ||
translate [BatSubstring] | translate f sus applies f to every character of sus , from
left to right, and returns the concatenation of the results.
| ||
transpose [BatList] |
Transposes a list of lists, turning rows of the input into columns
of the output and vice versa.
| ||
trim [BatSubstring] |
removes whitespace from left and right ends of input
| ||
trim [BatString.Cap] | |||
trim [BatString] |
Return a copy of the argument, without leading and trailing
whitespace.
| ||
triml [BatSubstring] | triml k sus returns sus less its leftmost k characters; or the
empty string at the end of sus if it has less than k characters.
| ||
trimr [BatSubstring] | trimr k sus returns sus less its rightmost k characters; or the
empty string at the beginning of sus if it has less than k
characters.
| ||
truncate [BatUnix.LargeFile] | |||
truncate [BatUnix] |
Truncates the named file to the given size.
| ||
try_lock [BatRMutex] |
Same as
RMutex.lock , but does not suspend the calling thread if
the mutex is already locked: just return false immediately
in that case.
| ||
try_lock [BatConcurrent.BaseLock] | |||
try_lock [BatConcurrent.Lock] | |||
U | |||
uget [BatUref] | uget ur returns the value stored in the uref ur .
| ||
ui16s_of [BatIO.BigEndian] |
Read an enumeration of unsigned 16-bit words.
| ||
ui16s_of [BatIO] |
Read an enumeration of unsigned 16-bit words.
| ||
umask [BatUnix] |
Set the process's file mode creation mask, and return the previous
mask.
| ||
uncapitalize [BatString.Cap] | |||
uncapitalize [BatString] |
Return a copy of the argument, with the first character set to lowercase.
| ||
uncombine [BatLazyList] |
Divide a list of pairs into a pair of lists.
| ||
uncombine [BatEnum] | uncombine is the opposite of combine
| ||
uncurry [BatTuple.Tuple5] | |||
uncurry [BatTuple.Tuple4] | |||
uncurry [BatTuple.Tuple3] | |||
uncurry [BatTuple.Tuple2] | |||
uncurry [BatPervasives] |
Convert a function which accepts a two arguments into a function
which accepts a pair of arguments.
| ||
uncurry [BatInnerPervasives] | |||
undef [BatGlobal] |
Reset the global value contents to undefined.
| ||
undefined [BatPervasives] |
The undefined function.
| ||
unfold [BatLazyList] | unfold data next creates a (possibly infinite) lazy list from
the successive results of applying next to data , then to the
result, etc.
| ||
unfold [BatEnum.Labels] | |||
unfold [BatEnum] |
As
from_loop , except uses option type to signal the end of the enumeration.
| ||
union [BatSet.PSet] | union s t returns the union of s and t - the set containing
all elements in either s and t .
| ||
union [BatSet.S] |
Set union.
| ||
union [BatSet] | union s t returns the union of s and t - the set containing
all elements in either s and t .
| ||
union [BatMap.PMap] | union m1 m2 merges two maps, using the comparison function of
m1 .
| ||
union [BatMap] | union m1 m2 merges two maps, using the comparison function of
m1 .
| ||
union [BatISet] |
Compute the union of two sets.
| ||
union [BatIMap] |
Merge two maps, giving a value
| ||
union [BatBitSet] | union s t return the union of sets s and t .
| ||
uniq [BatEnum] | uniq e returns a duplicate of e with repeated values
omitted.
| ||
unique [BatPervasives] |
Returns an unique identifier every time it is called.
| ||
unique [BatList] | unique cmp l returns the list l without any duplicate element.
| ||
unique [BatLazyList] | unique cmp l returns the list l without any duplicate element.
| ||
unique [BatInnerPervasives] | |||
unique_cmp [BatList] |
As
unique , except comparator parameter returns an int.
| ||
unique_eq [BatLazyList] |
as
unique except only uses an equality function.
| ||
unique_hash [BatList] |
As
unique , except uses a hash table to cut down the expected
runtime to linear, assuming a good hash function.
| ||
unique_value [BatInnerPervasives] | |||
unit_big_int [BatBig_int] |
The big integer
1 .
| ||
unite [BatUref] | unite ~sel ur1 ur2 unites the urefs ur1 and ur2 , selecting
the result of sel (uget ur1) (uget ur2) for the contents of
the resulting united uref.
| ||
unite [BatBitSet] | unite s t sets s to the union of the sets s and t .
| ||
unix_perm [BatFile] |
Create a permission from a Unix-style octal integer.
| ||
unlink [BatUnix] |
Removes the named file
| ||
unlock [BatRMutex] |
Unlock the given mutex.
| ||
unlock [BatConcurrent.BaseLock] | |||
unlock [BatConcurrent.Lock] | |||
unpack [BatInt32] | unpack str off reads 4 bytes from string str starting at
offset off as a little-endian int32
| ||
unpack_big [BatInt32] | unpack str off reads 4 bytes from string str starting at
offset off as a big-endian int32
| ||
unregister_formatter [BatLogger] | unregister_formatter name unregisters a named log formatter.
| ||
unsafe_get [BatVect.RANDOMACCESS] | |||
unsafe_get [BatDynArray] | |||
unsafe_get [BatBigarray.Array3] |
Like
Bigarray.Array3.get , but bounds checking is not always
performed.
| ||
unsafe_get [BatBigarray.Array2] |
Like
Bigarray.Array2.get , but bounds checking is not always
performed.
| ||
unsafe_get [BatBigarray.Array1] |
Like
Bigarray.Array1.get , but bounds checking is not always performed.
| ||
unsafe_set [BatVect.RANDOMACCESS] | |||
unsafe_set [BatDynArray] | |||
unsafe_set [BatBigarray.Array3] |
Like
Bigarray.Array3.set , but bounds checking is not always
performed.
| ||
unsafe_set [BatBigarray.Array2] |
Like
Bigarray.Array2.set , but bounds checking is not always
performed.
| ||
unsafe_set [BatBigarray.Array1] |
Like
Bigarray.Array1.set , but bounds checking is not always performed.
| ||
unset [BatBitSet] | unset s n sets the 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.
|