| ( * ) [BatNum] | |||
| ( * ) [BatNativeint] | |||
| ( * ) [BatInt64] | |||
| ( * ) [BatInt32] | |||
| ( * ) [BatInt.Safe_int] |
Multiplication.
| ||
| ( * ) [BatInt] |
Multiplication.
| ||
| ( * ) [BatFloat.Safe_float] | |||
| ( * ) [BatFloat] | |||
| ( * ) [BatComplex] | |||
| ( * ) [BatBounded.NumericSig] | |||
| ( * ) [BatBool] | |||
| ( * ) [BatNumber.Infix] | |||
| ( * ) [BatBig_int] | |||
| ( ** ) [BatNum] | |||
| ( ** ) [BatNativeint] | |||
| ( ** ) [BatInt64] | |||
| ( ** ) [BatInt32] | |||
| ( ** ) [BatInt.Safe_int] | a ** b computes ab
| ||
| ( ** ) [BatInt] | a ** b computes ab
| ||
| ( ** ) [BatFloat.Safe_float] | |||
| ( ** ) [BatFloat] | |||
| ( ** ) [BatComplex] | |||
| ( ** ) [BatBool] | |||
| ( ** ) [BatNumber.Infix] | |||
| ( ** ) [BatBig_int] | |||
| ( **/ ) [BatNum.Infix] | |||
| ( **/ ) [BatNum.TaggedInfix] | |||
| ( **/ ) [BatNum] | |||
| ( */ ) [BatNum.Infix] | |||
| ( */ ) [BatNum.TaggedInfix] | |||
| ( */ ) [BatNum] | |||
| ( *: ) [BatBounded.NumericSig] | |||
| ( *= ) [BatNumber.RefOps] | |||
| ( ~* ) [BatParserCo.Infix] | |||
| ( ~* ) [BatParserCo] |
As
zero_plus without arguments.
| ||
| (!!) [BatPathGen.PathType.OperatorLift] |
Prefix operator that converts primitive string to
ustring.
| ||
| (!) [BatRef] | !r returns the current contents of reference r.
| ||
| (%) [BatPervasives] |
Function composition: the mathematical
o operator.
| ||
| (%) [BatInnerPervasives] | |||
| (%>) [BatPervasives] |
Piping function composition.
| ||
| (%>) [BatInnerPervasives] | |||
| (&&) [BatBool] |
The boolean ``and''.
| ||
| (&&.) [BatSet.PSet.Infix] |
intersection
| ||
| (&&.) [BatSet.Infix] |
intersection
| ||
| (&&.) [BatSet.S.Infix] |
intersection
| ||
| (+) [BatNum] | |||
| (+) [BatNativeint] | |||
| (+) [BatInt64] | |||
| (+) [BatInt32] | |||
| (+) [BatInt.Safe_int] |
Addition.
| ||
| (+) [BatInt] |
Addition.
| ||
| (+) [BatFloat.Safe_float] | |||
| (+) [BatFloat] | |||
| (+) [BatComplex] | |||
| (+) [BatBounded.NumericSig] | |||
| (+) [BatBool] | |||
| (+) [BatNumber.Infix] | |||
| (+) [BatBig_int] | |||
| (+/) [BatNum.Infix] | |||
| (+/) [BatNum.TaggedInfix] | |||
| (+/) [BatNum] | |||
| (+:) [BatBounded.NumericSig] | |||
| (+=) [BatNumber.RefOps] | |||
| (-) [BatNum] | |||
| (-) [BatNativeint] | |||
| (-) [BatInt64] | |||
| (-) [BatInt32] | |||
| (-) [BatInt.Safe_int] |
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] | |||
| (-.) [BatSet.PSet.Infix] |
difference
| ||
| (-.) [BatSet.Infix] |
difference
| ||
| (-.) [BatSet.S.Infix] |
difference
| ||
| (-/) [BatNum.Infix] | |||
| (-/) [BatNum.TaggedInfix] | |||
| (-/) [BatNum] | |||
| (-:) [BatBounded.NumericSig] | |||
| (-=) [BatNumber.RefOps] | |||
| (/) [BatNum] | |||
| (/) [BatNativeint] | |||
| (/) [BatInt64] | |||
| (/) [BatInt32] | |||
| (/) [BatInt.Safe_int] |
Integer division.
| ||
| (/) [BatInt] |
Integer division.
| ||
| (/) [BatFloat.Safe_float] | |||
| (/) [BatFloat] | |||
| (/) [BatComplex] | |||
| (/) [BatBounded.NumericSig] | |||
| (/) [BatBool] | |||
| (/) [BatNumber.Infix] | |||
| (/) [BatBig_int] | |||
| (//) [BatSeq.Infix] | |||
| (//) [BatPervasives] |
Filtering (pronounce this operator name "such that").
| ||
| (//) [BatNum.Infix] | |||
| (//) [BatNum.TaggedInfix] | |||
| (//) [BatNum] | |||
| (//) [BatEnum.Infix] |
Filtering (pronounce this operator name "such that").
| ||
| (//) [BatEnum] | |||
| (//@) [BatSeq.Infix] | |||
| (//@) [BatPervasives] | |||
| (//@) [BatPathGen.PathType.Infix] | |||
| (//@) [BatPathGen.PathType.Operators] | basepath//@relpath catenates two paths.
| ||
| (//@) [BatEnum.Infix] | |||
| (//@) [BatEnum] | |||
| (/:) [BatPathGen.PathType.Infix] | |||
| (/:) [BatPathGen.PathType.Operators] | path/:name is a path of name located in a directory path.
| ||
| (/:) [BatBounded.NumericSig] | |||
| (/=) [BatNumber.RefOps] | |||
| (/@) [BatSeq.Infix] | |||
| (/@) [BatPervasives] | |||
| (/@) [BatEnum.Infix] | |||
| (/@) [BatEnum] | |||
| (:=) [BatRef] | r := a stores the value of a in reference r.
| ||
| (<) [BatInt.Safe_int] |
Comparaison:
a < b is true if and only if a is strictly smaller than b.
| ||
| (<) [BatInt] | |||
| (<) [BatNumber.Compare] | |||
| (<--) [BatSet.PSet.Infix] |
insertion
| ||
| (<--) [BatSet.Infix] |
insertion
| ||
| (<--) [BatSet.S.Infix] |
insertion
| ||
| (<--) [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.
| ||
| (<.) [BatSet.PSet.Infix] |
strict subset
| ||
| (<.) [BatSet.Infix] |
strict subset
| ||
| (<.) [BatSet.S.Infix] |
strict subset
| ||
| (</) [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] | |||
| (<=.) [BatSet.PSet.Infix] |
subset
| ||
| (<=.) [BatSet.Infix] |
subset
| ||
| (<=.) [BatSet.S.Infix] |
subset
| ||
| (<=/) [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] | |||
| (>.) [BatSet.PSet.Infix] |
strict superset
| ||
| (>.) [BatSet.Infix] |
strict superset
| ||
| (>.) [BatSet.S.Infix] |
strict superset
| ||
| (>/) [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] | |||
| (>=.) [BatSet.PSet.Infix] |
superset
| ||
| (>=.) [BatSet.Infix] |
superset
| ||
| (>=.) [BatSet.S.Infix] |
superset
| ||
| (>=/) [BatNum.Infix] | |||
| (>=/) [BatNum.TaggedInfix] | |||
| (>=/) [BatNum] | |||
| (>>=) [BatResult.Infix] | |||
| (>>=) [BatResult.Monad] |
as
bind
| ||
| (>>=) [BatParserCo.Infix] | |||
| (>>=) [BatParserCo] |
As
bind
| ||
| (>>=) [BatOption.Infix] |
as
Monad.bind
| ||
| (>>>) [BatParserCo.Infix] | |||
| (>>>) [BatParserCo] |
As
bind, but ignoring the result
| ||
| (@) [BatPervasives] |
List concatenation.
| ||
| (@) [BatList.Infix] | |||
| (@) [BatList] |
Tail recursive
List.append.
| ||
| (@/) [BatSeq.Infix] | |||
| (@/) [BatPervasives] |
Mapping operators.
| ||
| (@/) [BatEnum.Infix] |
Mapping operators.
| ||
| (@/) [BatEnum] | |||
| (@//) [BatSeq.Infix] | |||
| (@//) [BatPervasives] |
Map combined with filter.
| ||
| (@//) [BatEnum.Infix] |
Map combined with filter.
| ||
| (@//) [BatEnum] | |||
| (@@) [BatPervasives] | |||
| (@@) [BatInnerPervasives] | |||
| (^:^) [BatLazyList.Infix] | |||
| (^:^) [BatLazyList] |
As
cons: x^:^l is the lazy list with head x and tail l
| ||
| (^@^) [BatLazyList.Infix] | |||
| (^@^) [BatLazyList] |
As lazy append
| ||
| (^^) [BatParserCo.Infix] | |||
| (^^) [BatParserCo] | p ^^ n is the same thing as times n p
| ||
| (^^^) [BatText] | |||
| (|>) [BatteriesPrint] | |||
| (|>) [BatPervasives] |
The "pipe": function application.
| ||
| (|>) [BatInnerPervasives] | |||
| (|?) [BatPervasives] |
Like
BatOption.default, with the arguments reversed.
| ||
| (|?) [BatOption.Infix] |
Like
BatOption.default, with the arguments reversed.
| ||
| (|?) [BatOption] |
Like
BatOption.default, with the arguments reversed.
| ||
| (|?) [BatInnerPervasives] | |||
| (||) [BatBool] |
The boolean ``or''.
| ||
| (||.) [BatSet.PSet.Infix] |
union
| ||
| (||.) [BatSet.Infix] |
union
| ||
| (||.) [BatSet.S.Infix] |
union
| ||
| (~+) [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_bytes [BatBuffer] | add_string b s appends the string s at the end of the buffer b.
| ||
| add_carry [BatMap.PMap] | add_carry k v m adds the binding (k,v) to m, returning the new map and optionally the previous value bound to k.
| ||
| add_carry [BatMap] | add_carry k v m adds the binding (k,v) to m, returning the new map and optionally the previous value bound to k.
| ||
| add_channel [BatBuffer] | |||
| add_char [BatUTF8.Buf] |
Add one Unicode character to the buffer.
| ||
| add_char [BatBuffer] | add_char b c appends the character c at the end of the buffer b.
| ||
| add_group [BatOptParse.OptParser] |
Add a group to the option parser.
| ||
| add_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_subbytes [BatBuffer] | add_substring b s ofs len takes len characters from offset
ofs in byte sequence s and appends them at the end of the buffer b.
| ||
| add_substitute [BatBuffer] | add_substitute b f s appends the string pattern s at the end
of the buffer b with substitution.
| ||
| add_substring [BatBuffer] | add_substring b s ofs len takes len characters from offset
ofs in string s and appends them at the end of the buffer b.
| ||
| 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.
| ||
| asprintf [BatFormat] |
Same as
printf above, but instead of printing on a formatter, returns a
string containing the result of formatting the arguments.
| ||
| assoc [BatSeq] | assoc a s returns the value associated with key a in the
sequence of pairs s.
| ||
| assoc [BatList.Labels.LExceptionless] | |||
| assoc [BatList.Exceptionless] | assoc a l returns Some b where b is the value associated with
key b
in the list of pairs l.
| ||
| assoc [BatList] | assoc a l returns the value associated with key a in the list of
pairs l.
| ||
| assoc [BatLazyList.Labels.Exceptionless] | |||
| assoc [BatLazyList.Exceptionless] | assoc a l returns Some b where b is the value associated with key a
in the list of pairs l.
| ||
| assoc [BatLazyList] | assoc a l returns the value associated with key a in the list of
pairs l.
| ||
| assoc_inv [BatList.Labels.LExceptionless] | |||
| assoc_inv [BatList.Exceptionless] | assoc_inv b l returns Some a where a is the key associated with
value b
in the list of pairs l.
| ||
| assoc_inv [BatList] | assoc_inv b l returns the key associated with value b in the list of
pairs l.
| ||
| assq [BatList.Labels.LExceptionless] | |||
| assq [BatList.Exceptionless] |
As
BatList.Exceptionless.assoc but with physical equality.
| ||
| assq [BatList] |
Same as
List.assoc, but uses physical equality instead of structural
equality to compare keys.
| ||
| assq [BatLazyList.Labels.Exceptionless] | |||
| assq [BatLazyList.Exceptionless] |
As
BatLazyList.Exceptionless.assoc but with physical equality
| ||
| assq [BatLazyList] |
As
BatLazyList.assoc but with physical equality
| ||
| assq_inv [BatList] |
Same as
List.assoc_inv, but uses physical equality instead of structural
equality to compare keys.
| ||
| at [BatVect.Make] |
as
get
| ||
| at [BatVect] |
as
get
| ||
| at [BatSeq.Exceptionless] | |||
| at [BatSeq] | at l n returns the element at index n (starting from 0) in
the sequence l or raise Invalid_argument is the index is
outside of l bounds.
| ||
| at [BatList.Labels.LExceptionless] | |||
| at [BatList.Exceptionless] |
If
n is inside the bounds of l, at l n returns Ok x, where
x is the n-th element of the list l.
| ||
| at [BatList] | at l n returns the n-th element of the list l or
| ||
| at [BatLazyList.Labels.Exceptionless] | |||
| at [BatLazyList.Exceptionless] |
If
n is inside the bounds of l, at l n returns `Ok x, where
x is the n-th element of the list l.
| ||
| at [BatLazyList] | at l n returns the element at index n (starting from 0) in
the list l.
| ||
| at [BatDeque] | at ~backwards dq k returns the kth element of dq, from
the front if backwards is false, and from the rear if
backwards is true.
| ||
| at_index [BatRefList.Index] |
Return the element of ref list at the specified index
raise
Invalid_index if the index is outside 0 ; length-1
| ||
| at_rank_exn [BatSet.PSet] | at_rank_exn i s returns element at rank i in s, that is
the i-th element in increasing order
(the 0-th element being the smallest element of s).
| ||
| at_rank_exn [BatSet.S] | at_rank_exn i s returns element at rank i in s, that is
the i-th element in increasing order
(the 0-th element being the smallest element of s).
| ||
| at_rank_exn [BatSet] | at_rank_exn i s returns element at rank i in s, that is
the i-th element in increasing order
(the 0-th element being the smallest element of s).
| ||
| at_rank_exn [BatMap.PMap] | at_rank_exn i m returns the (key,value) pair
whose key is at rank i in m,
that is the i-th element in increasing order of the keys
(the 0-th element being the smallest key in m with its
associated value).
| ||
| at_rank_exn [BatMap] | at_rank_exn i m returns the (key,value) pair
whose key is at rank i in m,
that is the i-th element in increasing order of the keys
(the 0-th element being the smallest key in m with its
associated value).
| ||
| atan [BatFloat.Safe_float] | |||
| atan [BatFloat] |
See
BatFloat.atan2.
| ||
| atan2 [BatFloat.Safe_float] |
The usual trigonometric functions.
| ||
| atan2 [BatFloat] |
The usual trigonometric functions.
| ||
| avg [BatArray] | avg l returns the average of l
| ||
B | |||
| backtrace_slots [BatPrintexc] |
Returns the slots of a raw backtrace, or
None if none of them
contain useful information.
| ||
| backtrace_status [BatPrintexc] | Printexc.backtrace_status() returns true if exception
backtraces are currently recorded, false if not.
| ||
| backwards [BatVect.RANDOMACCESS] | |||
| backwards [BatVect.Make] |
Returns an enumeration of the elements of a vector, from last to first.
| ||
| backwards [BatVect] |
Returns an enumeration of the elements of a vector, from last to first.
| ||
| backwards [BatText] |
enumerates the rope's characters, in reverse order
| ||
| backwards [BatString.Cap] | |||
| backwards [BatString] |
Returns an enumeration of the characters of a string, from last to first.
| ||
| backwards [BatSet.S] |
Return an enumeration of all elements of the given set.
| ||
| backwards [BatSet] |
Return an enumeration of all elements of the given set.
| ||
| backwards [BatRefList] |
Returns an enumeration of current elements in the ref list, going from last to first
| ||
| backwards [BatMap.PMap] |
creates an enumeration for this map, enumerating key,value pairs with the keys in decreasing order.
| ||
| backwards [BatMap.S] |
Return an enumeration of (key, value) pairs of a map.
| ||
| backwards [BatMap] |
creates an enumeration for this map, enumerating key,value pairs with the keys in decreasing order.
| ||
| backwards [BatList] |
Returns an enumeration of the elements of a list.
| ||
| backwards [BatFingerTree.S] | backwards t builds an enumeration of the elements of t going from
right to left.
| ||
| backwards [BatDllist] | backwards t is similar to rev_enum t except that the enumeration
starts at the node before the current one:
| ||
| backwards [BatArray.Cap] | |||
| backwards [BatArray] |
Returns an enumeration of the elements of an array, from last to first.
| ||
| balance [BatVect.Make] | balance r returns a balanced copy of the r vect.
| ||
| balance [BatVect] | balance r returns a balanced copy of the r vect.
| ||
| balance [BatText] | balance r returns a balanced copy of the r rope.
| ||
| base [BatSubstring] | base sus is the concrete triple (s, i, n), where psus = (s, i,
n).
| ||
| base_of_t [BatBounded.BoundedType] | base_of_t x converts a value of type BatBounded.BoundedType.t back to a BatBounded.BoundedType.base_t if
possible.
| ||
| base_of_t_exn [BatBounded.BoundedType] | base_of_t_exn x converts a value of type BatBounded.BoundedType.t back to a BatBounded.BoundedType.base_t.
| ||
| 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 [BatBytes] | blit src srcoff dst dstoff len copies len bytes from sequence
src, starting at index srcoff, to sequence dst, starting at
index dstoff.
| ||
| blit [BatBuffer] | Buffer.blit src srcoff dst dstoff len copies len characters from
the current contents of the buffer src, starting at offset srcoff
to string dst, starting at character dstoff.
| ||
| blit [BatBigarray.Array3] |
Copy the first big array to the second big array.
| ||
| blit [BatBigarray.Array2] |
Copy the first big array to the second big array.
| ||
| blit [BatBigarray.Array1] |
Copy the first big array to the second big array.
| ||
| blit [BatBigarray.Genarray] |
Copy all elements of a big array in another big array.
| ||
| blit [BatArray.Cap.Labels] | |||
| blit [BatArray.Cap] | |||
| blit [BatArray.Labels] | |||
| blit [BatArray] | Array.blit v1 o1 v2 o2 len copies len elements
from array v1, starting at element number o1, to array v2,
starting at element number o2.
| ||
| blit_string [BatBytes] | blit src srcoff dst dstoff len copies len bytes from string
src, starting at index srcoff, to byte sequence dst,
starting at index dstoff.
| ||
| bool [BatRandom.Incubator.Private_state_enums.State] | |||
| bool [BatRandom.State] | |||
| bool [BatRandom] | Random.bool () returns true or false with probability 0.5 each.
| ||
| bounded [BatBounded.BoundedType] | |||
| 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.
| ||
| bsearch [BatArray] | bsearch cmp arr x finds the index of the object x in the array arr,
provided arr is sorted using cmp.
| ||
| bytes [BatDigest] |
Return the digest of the given byte sequence.
| ||
| bytes_of [BatIO] |
Read an enumeration of unsigned 8-bit integers.
| ||
C | |||
| c_layout [BatBigarray] | |||
| callback_option [BatOptParse.Opt] |
Make a callback option which takes a single argument.
| ||
| capacity [BatBitSet] |
Internals
| ||
| capitalize [BatString.Cap] | |||
| capitalize [BatString] |
Return a copy of the argument, with the first character set to uppercase.
| ||
| capitalize [BatBytes] |
Return a copy of the argument, with the first byte set to
uppercase.
| ||
| capitalize_ascii [BatString] |
Return a copy of the argument, with the first character set to uppercase,
using the US-ASCII character set.
| ||
| capitalize_ascii [BatBytes] |
Return a copy of the argument, with the first character set to uppercase,
using the US-ASCII character set.
| ||
| cardinal [BatSet.PSet] |
Return the number of elements of a set.
| ||
| cardinal [BatSet.S] |
Return the number of elements of a set.
| ||
| cardinal [BatSet] |
Return the number of elements of a set.
| ||
| cardinal [BatMap.PMap] |
Return the number of bindings of a map.
| ||
| cardinal [BatMap.S] |
Return the number of bindings of a map.
| ||
| cardinal [BatMap] |
Return the number of bindings of a map.
| ||
| cardinal [BatISet] |
Returns the number of elements in the set
| ||
| cartesian_product [BatSet.Make2] |
cartesian product of the two sets
| ||
| cartesian_product [BatSet] |
cartesian product of the two sets
| ||
| cartesian_product [BatList] |
Different from
List.combine, this returns every pair
of elements formed out of the two lists.
| ||
| cartesian_product [BatEnum] | cartesian_product e1 e2 computes the cartesian product of e1 and e2.
| ||
| cartesian_product [BatArray] |
Cartesian product of the two arrays.
| ||
| case_char [BatCharParser] |
As
char, but case-insensitive
| ||
| case_sensitive [BatGenlex.Languages.Definition] | true if the language is case-sensitive, false otherwise.
| ||
| case_string [BatCharParser] |
As
case_string, but case-insensitive
| ||
| cast_output [BatInnerIO] |
You can safely transform any output to an unit output in a safe way
by using this function.
| ||
| cast_output [BatIO] |
You can safely transform any output to an unit output in a safe way
by using this function.
| ||
| cat [BatBytes] | cat s1 s2 concatenates s1 and s2 and returns the result
as new byte sequence.
| ||
| catch [BatResult] |
Execute a function and catch any exception as a result.
| ||
| catch [BatPrintexc] | Printexc.catch fn x is similar to Printexc.print, but aborts
the program with exit code 2 after printing the uncaught exception.
| ||
| catch2 [BatResult] |
As
catch but two 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.
| ||
| check [BatAvlTree] |
Check that the tree is balanced according to the AVL tree rules.
| ||
| 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 [BatBytes] |
The comparison function for byte sequences, with the same
specification as
Pervasives.compare.
| ||
| compare [BatBool] | |||
| compare [BatBitSet] | compare s1 s2 compares two bitsets using a lexicographic
ordering.
| ||
| compare [BatBig_int] | |||
| compare [BatArray.Cap] | |||
| compare [BatArray] | compare c generates the lexicographical order on arrays induced
by c.
| ||
| compare_big_int [BatBig_int] | compare_big_int a b returns 0 if a and b are equal,
1 if a is greater than b, and -1 if a is smaller
than b.
| ||
| compare_index [BatUTF8] | compare_index s i1 i2 returns
a value < 0 if i1 is the position located before i2,
0 if i1 and i2 points the same location,
a value > 0 if i1 is the position located after i2.
| ||
| compare_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 [BatBytes] | concat sep sl concatenates the list of byte sequences sl,
inserting the separator byte sequence sep between each, and
returns the result as a new byte sequence.
| ||
| concat [BatAvlTree] | |||
| concat [BatArray.Cap] | |||
| concat [BatArray] |
Same as
Array.append, but concatenates a list of arrays.
| ||
| concat_map [BatStream] |
Composition of
BatStream.concat and BatStream.map.
| ||
| concat_map [BatEnum] |
Synonym of
BatEnum.Monad.bind, with flipped arguments.
| ||
| concat_with_separators [BatPathGen.StringType] | concat_with_separators sep lst catenates all n elements of lst inserting (n-1) copies of sep in between.
| ||
| conj [BatComplex] |
Conjugate: given the complex
x + i.y, returns x - i.y.
| ||
| connect [BatUnix] |
Connect a socket to an address.
| ||
| cons [BatStream] | cons x stream equals [<'x; stream>].
| ||
| cons [BatSeq] | cons e s = fun () -> Cons(e, s)
| ||
| cons [BatParserCo] | cons p q applies parser p then parser q and
conses the results into a list.
| ||
| cons [BatList] | cons h t returns the list starting with h and continuing as t
| ||
| cons [BatLazyList] |
Build a list from a head and a tail.
| ||
| cons [BatFingerTree.S] | cons t elt adds elt to the left of t.
| ||
| cons [BatDeque] | cons x dq adds x to the front of dq.
| ||
| conservative_exponential_resizer [BatDynArray] | conservative_exponential_resizer is an example resizer function
which uses the oldlength parameter.
| ||
| const [BatPervasives] |
Ignore its second argument.
| ||
| const [BatInnerPervasives] | |||
| contains [BatText] | contains s c tests if character c
appears in the rope s.
| ||
| contains [BatSubstring] | contains s c tests if character c appears in the substring s.
| ||
| contains [BatString.Cap] | |||
| contains [BatString] | String.contains s c tests if character c
appears in the string s.
| ||
| contains [BatBytes] | contains s c tests if byte c appears in s.
| ||
| contains_from [BatText] | contains_from s start c tests if character c appears in
the subrope of s starting from start to the end of s.
| ||
| contains_from [BatString.Cap] | |||
| contains_from [BatString] | String.contains_from s start c tests if character c
appears in s after position start.
| ||
| contains_from [BatBytes] | contains_from s start c tests if byte c appears in s after
position start.
| ||
| contents [BatUTF8.Buf] | contents buf returns the contents of the buffer.
| ||
| contents [BatBuffer] |
Return a copy of the current contents of the buffer.
| ||
| convert_raw_backtrace_slot [BatPrintexc] |
Extracts the user-friendly
backtrace_slot from a low-level
raw_backtrace_slot.
| ||
| copy [BatVect.RANDOMACCESS] | |||
| copy [BatString.Cap] | |||
| copy [BatString] |
Return a copy of the given string.
| ||
| copy [BatStack] |
Return a copy of the given stack.
| ||
| copy [BatRefList] |
Makes a copy of a ref list - O(1)
| ||
| copy [BatRef] | copy r returns a new reference with the same initial
content as r.
| ||
| copy [BatRandom.Incubator.Private_state_enums.State] |
Return a copy of the given state.
| ||
| copy [BatRandom.State] |
Return a copy of the given state.
| ||
| copy [BatQueue] |
Return a copy of the given queue.
| ||
| copy [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 [BatBytes] |
Return a new byte sequence that contains the same bytes as the
argument.
| ||
| copy [BatBitSet] |
Copy a bitset : further modifications of first one will not affect the
copy.
| ||
| copy [BatArray.Cap] | |||
| copy [BatArray] | Array.copy a returns a copy of a, that is, a fresh array
containing the same elements as a.
| ||
| copy_enum [BatRefList] |
Makes a copy of a enum.
| ||
| copy_list [BatRefList] |
Makes a copy of a list - O(1)
| ||
| copysign [BatInt] | copysign n o multiplies o by the "sign" of n, i.e.
| ||
| copysign [BatFloat] | copysign x y returns a copy of x with the same sign as y.
| ||
| cos [BatFloat.Safe_float] | |||
| cos [BatFloat] |
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 [BatBytes] | create n returns a new byte sequence of length n.
| ||
| create [BatBuffer] | create n returns a fresh buffer, initially empty.
| ||
| create [BatBitSet] |
Create an empty bitset with at least an initial capacity (in number of bits).
| ||
| create [BatBigarray.Array3] | Array3.create kind layout dim1 dim2 dim3 returns a new bigarray of
three dimension, whose size is dim1 in the first dimension,
dim2 in the second dimension, and dim3 in the third.
| ||
| create [BatBigarray.Array2] | Array2.create kind layout dim1 dim2 returns a new bigarray of
two dimension, whose size is dim1 in the first dimension
and dim2 in the second dimension.
| ||
| create [BatBigarray.Array1] | Array1.create kind layout dim returns a new bigarray of
one dimension, whose size is dim.
| ||
| create [BatBigarray.Genarray] | Genarray.create kind layout dimensions returns a new big array
whose element kind is determined by the parameter kind (one of
float32, float64, int8_signed, etc) and whose layout is
determined by the parameter layout (one of c_layout or
fortran_layout).
| ||
| create [BatAvlTree] | create l v r is similar to make_tree l v r but performs no rebalancing;
in other words, you should use this only when you know that l and r
are already balanced.
| ||
| create [BatArray.Cap.Labels] | |||
| create [BatArray.Cap] | |||
| create [BatArray.Labels] | |||
| create [BatArray] | |||
| create_alarm [BatGc] | create_alarm f will arrange for f to be called at the end of each
major GC cycle, starting with the current cycle or the next one.
| ||
| create_float [BatArray] | |||
| create_full [BatBitSet] |
Create a full bitset with at least initial capacity (in number of bits).
| ||
| create_in [BatInnerIO] |
Fully create an input by giving all the needed functions.
| ||
| create_in [BatIO] |
Fully create an input by giving all the needed functions.
| ||
| create_matrix [BatArray.Cap.Labels] | |||
| create_matrix [BatArray.Cap] | |||
| create_matrix [BatArray.Labels] | |||
| create_matrix [BatArray] | |||
| create_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] | |||
| create_with [BatDynArray] |
create a new dynamic array that uses the given resizer.
| ||
| 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.
| ||
| cygwin [BatSys] |
True if
Sys.os_type = "Cygwin".
| ||
D | |||
| data_size [BatMarshal] |
See
Marshal.header_size.
| ||
| dbg_formatter [BatLogger] | dbg_formatter is a debug formatter that outputs log events to
stderr using the same format as make_dbg_formatter.
| ||
| debug_mode [BatParserCo] |
If set to
true, debugging information will be printed to the standard error.
| ||
| decode [BatBase64] |
Generic base64 decoding over an input.
| ||
| decorate_fast_sort [BatArray] |
As
Array.decorate_stable_sort, but uses fast_sort internally.
| ||
| decorate_stable_sort [BatArray] | decorate_stable_sort f a returns a sorted copy of a such that if f
x < f y then x is earlier in the result than y.
| ||
| decr_num [BatNum] | |||
| decr_option [BatOptParse.StdOpt] |
Exactly identical to
count_option ~dest:dest ~increment:(-1) ().
| ||
| default [BatResult] | default d r evaluates to d if r is Bad else x when r is
Ok x
| ||
| default [BatOption] | default x (Some v) returns v and default x None returns x.
| ||
| default_browse [BatteriesConfig] |
The default function to open a www browser.
| ||
| default_buffer_size [BatInnerIO] |
The default size of buffers.
| ||
| default_buffer_size [BatIO] |
The default size for internal buffers.
| ||
| default_delayed [BatOption] |
Like
BatOption.default, but the default value is passed as a thunk that
is only computed if needed.
| ||
| default_level [BatLog.Level_sig] |
a comparison function between levels, to know whether logging at a
particular level should be printed
| ||
| default_permission [BatFile] |
Default permissions.
| ||
| default_resizer [BatDynArray] |
The default resizer function the library is using - in this version
of DynArray, this is the
exponential_resizer but should change in
next versions.
| ||
| default_validator [BatPathGen.PathType] |
Forward slash and code zero are considered invalid.
| ||
| del_min [BatHeap.H] |
See
BatHeap.del_min.
| ||
| del_min [BatHeap] |
Delete the minimal element of the heap.
| ||
| delay [BatEnum] | delay (fun () -> e) produces an enumeration which behaves as e.
| ||
| delete [BatDynArray] | delete darr idx deletes the element of darr at idx.
| ||
| delete_alarm [BatGc] | delete_alarm a will stop the calls to the function associated
to a.
| ||
| delete_last [BatDynArray] | delete_last darr deletes the last element of darr.
| ||
| delete_range [BatDynArray] | delete_range darr p len deletes len elements starting at index p.
| ||
| demote [BatDllist] | demote n Swaps n with prev n.
| ||
| descr_of_in_channel [BatUnix] |
Return the descriptor corresponding to an input channel.
| ||
| descr_of_input [BatUnix] |
Return the descriptor corresponding to an input.
| ||
| descr_of_out_channel [BatUnix] |
Return the descriptor corresponding to an output channel.
| ||
| descr_of_output [BatUnix] |
Return the descriptor corresponding to an output.
| ||
| destructive_set [BatVect.Make] | destructive_set n e v sets the element of index n in the v vect
to e.
| ||
| destructive_set [BatVect] | destructive_set n e v sets the element of index n in the v vect
to e.
| ||
| diff [BatSet.PSet] | diff s t returns the set of all elements in s but not in
t.
| ||
| diff [BatSet.S] |
Set difference.
| ||
| diff [BatSet] | diff s t returns the set of all elements in s but not in
t.
| ||
| diff [BatMap.PMap] | diff m1 m2 removes all bindings of keys found in m2 from m1,
using the comparison function of m1.
| ||
| diff [BatMap] | diff m1 m2 removes all bindings of keys found in m2 from m1,
using the comparison function of m1.
| ||
| diff [BatISet] |
Compute the difference between two sets.
| ||
| diff [BatBitSet] | diff s t returns s-t.
| ||
| differentiate [BatBitSet] | differentiate s t removes the elements of t from s.
| ||
| differentiate_sym [BatBitSet] | differentiate_sym s t sets s to the symmetrical difference of the
sets s and t.
| ||
| digit [BatCharParser] |
Recognizes one decimal digit
| ||
| dim [BatBigarray.Array1] |
Return the size (dimension) of the given one-dimensional
big array.
| ||
| dim1 [BatBigarray.Array3] |
Return the first dimension of the given three-dimensional big array.
| ||
| dim1 [BatBigarray.Array2] |
Return the first dimension of the given two-dimensional big array.
| ||
| dim2 [BatBigarray.Array3] |
Return the second dimension of the given three-dimensional big array.
| ||
| dim2 [BatBigarray.Array2] |
Return the second dimension of the given two-dimensional big array.
| ||
| dim3 [BatBigarray.Array3] |
Return the third dimension of the given three-dimensional big array.
| ||
| dims [BatBigarray.Genarray] | Genarray.dims a returns all dimensions of the big array a,
as an array of integers of length Genarray.num_dims a.
| ||
| disjoint [BatSet.PSet] | disjoint s1 s2 tests whether the sets s1 and s2 contain no
shared elements.
| ||
| disjoint [BatSet.S] | disjoint s1 s2 tests whether the sets s1 and s2 contain no shared
elements.
| ||
| disjoint [BatSet] | disjoint s1 s2 tests whether the sets s1 and s2 contain no
shared elements.
| ||
| div [BatNumber.Numeric] | |||
| div [BatNum] | |||
| div [BatNativeint] |
Integer division.
| ||
| div [BatInt64] |
Integer division.
| ||
| div [BatInt32] |
Integer division.
| ||
| div [BatInt.Safe_int] |
Integer division.
| ||
| div [BatInt] |
Integer division.
| ||
| div [BatFloat.Safe_float] | |||
| div [BatFloat] | |||
| div [BatComplex] |
Division
| ||
| div [BatBool] | |||
| div [BatBig_int] | |||
| div_big_int [BatBig_int] |
Euclidean quotient of two big integers.
| ||
| div_num [BatNum] | |||
| documentation_root [BatteriesConfig] | |||
| domain [BatIMap] | domain t returns the set of ints that are bound in t
| ||
| domain_of_sockaddr [BatUnix] |
Return the socket domain adequate for the given socket address.
| ||
| doubles_of [BatIO.BigEndian] |
Read an enumeration of IEEE double precision floating point values.
| ||
| doubles_of [BatIO] |
Read an enumeration of IEEE double precision floating point values.
| ||
| drive_letter [BatPathGen.PathType] |
Return drive letter of the given absolute path.
| ||
| drop [BatStream] | drop n stream returns the suffix of stream after the first n elements,
or a empty stream if n is greater than the length of stream
| ||
| drop [BatSeq] | drop n s returns s without the first n elements, or the
empty sequence if s have less than n elements.
| ||
| drop [BatList] | drop n l returns l without the first n elements, or the empty
list if l have less than n elements.
| ||
| drop [BatLazyList] | drop n l returns l without the first n elements, or the empty
list if l have less than n elements.
| ||
| drop [BatEnum] | drop n e removes the first n element from the enumeration, if any.
| ||
| drop [BatDllist] |
Remove node from the list no matter where it is.
| ||
| drop_bits [BatIO] |
Drop up to 7 buffered bits and restart to next input character.
| ||
| drop_while [BatStream.StreamLabels] | |||
| drop_while [BatStream] | drop_while test stream returns the remaining suffix of take_while test
stream.
| ||
| drop_while [BatSeq] | drop_while f s returns the sequence s with the first
elements satisfying the predicate f dropped.
| ||
| drop_while [BatList.Labels] | |||
| drop_while [BatList] | drop_while p xs returns the suffix remaining after
take_while p xs.
| ||
| drop_while [BatLazyList.Labels] | |||
| drop_while [BatLazyList] | drop_while f xs returns the list xs with the first
elements satisfying the predicate f dropped.
| ||
| drop_while [BatEnum.Labels] | |||
| drop_while [BatEnum] | drop_while p e produces a new enumeration in which only
all the first elements such that f e have been junked.
| ||
| dropl [BatSubstring] | dropl p sus drops the longest prefix (left substring) of sus
all of whose characters satisfy predicate p.
| ||
| dropr [BatSubstring] | dropr p sus drops the longest suffix (right substring) of sus all
of whose characters satisfy predicate p.
| ||
| dropwhile [BatList] |
obsolete, as
BatList.drop_while
| ||
| dummy_class [BatOo.Internal] | |||
| dummy_pos [BatLexing] |
A value of type
position, guaranteed to be different from any
valid position.
| ||
| dummy_table [BatOo.Internal] | |||
| dump [BatPervasives] |
Attempt to convert a value to a string.
| ||
| dup [BatUnix] |
Return a new file descriptor referencing the same file as
the given descriptor.
| ||
| dup [BatStream] | dup stream returns a pair of streams which are identical to stream.
| ||
| dup [BatEnum] | dup stream returns a pair of streams which are identical to stream.
| ||
| dup2 [BatUnix] | dup2 fd1 fd2 duplicates fd1 to fd2, closing fd2 if already
opened.
| ||
E | |||
| e [BatFloat] |
Euler? ...
| ||
| eager_append [BatLazyList] |
Evaluate a list and append another list after this one.
| ||
| eager_fold_right [BatLazyList] |
Eager fold_right
| ||
| eager_of_list [BatLazyList] |
Eager conversion from lists.
| ||
| edit_distance [BatString] |
Edition distance (also known as "Levenshtein distance").
| ||
| either [BatParserCo] |
Accept one of several parsers.
| ||
| elements [BatSet.PSet] |
Return the list of all elements of the given set.
| ||
| elements [BatSet.S] |
Return the list of all elements of the given set.
| ||
| elements [BatSet] |
Return the list of all elements of the given set.
| ||
| elements [BatISet] |
Returns a list of all elements in the set
| ||
| elems [BatHeap.H] | |||
| elems [BatHeap] | |||
| empty [BatVect.RANDOMACCESS] | |||
| empty [BatVect.Make] |
The empty vect.
| ||
| empty [BatVect] |
The empty vect.
| ||
| empty [BatText] |
The empty rope.
| ||
| empty [BatSubstring] | |||
| empty [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 [BatBytes] |
A byte sequence of size 0.
| ||
| empty [BatBitSet] |
Create an empty bitset of capacity 0, the bitset will
automatically expand when needed.
| ||
| empty [BatAvlTree] | |||
| enable_runtime_warnings [BatSys] |
Control whether the OCaml runtime system can emit warnings
on stderr.
| ||
| encode [BatBase64] |
Generic base64 encoding over an output.
| ||
| end_of_input [BatScanf.Scanning] | Scanning.end_of_input ib tests the end-of-input condition of the given
scanning buffer.
| ||
| ends_with [BatText] | ends_with s x returns true if the rope s is ending with x, false otherwise.
| ||
| ends_with [BatString.Cap] | |||
| ends_with [BatString] | ends_with s x returns true if the string s is ending with x, false otherwise.
| ||
| enum [BatVect.RANDOMACCESS] | |||
| enum [BatVect.Make] |
Returns an enumeration of the elements of the vector.
| ||
| enum [BatVect] |
Returns an enumeration of the elements of the vector.
| ||
| enum [BatTuple.Tuple5] | |||
| enum [BatTuple.Tuple4] | |||
| enum [BatTuple.Tuple3] | |||
| enum [BatTuple.Tuple2] | |||
| enum [BatText] |
enumerate the rope's characters
| ||
| enum [BatSubstring] | enum ss returns an enumeration of the characters represented by ss.
| ||
| enum [BatString.Cap] |
Conversions
| ||
| enum [BatString] |
Returns an enumeration of the characters of a string.
| ||
| enum [BatStream] |
Convert a stream to an enumeration.
| ||
| enum [BatStack] | enum s returns an enumeration of the elements of stack s, from
the most recently entered to the least recently entered.
| ||
| enum [BatSet.PSet] |
Return an enumeration of all elements of the given set.
| ||
| enum [BatSet.S] |
Return an enumeration of all elements of the given set.
| ||
| enum [BatSet] |
Return an enumeration of all elements of the given set.
| ||
| enum [BatSeq] | enum s returns the enumeration of all element of s.
| ||
| enum [BatRefList] |
Returns an enumeration of current elements in the ref list
| ||
| enum [BatQueue] | enum q returns a destructive enumeration of the elements of queue
q, from the least recently entered to the most recently entered.
| ||
| enum [BatOption] | enum (Some x) returns the singleton x, while enum None returns
the empty enumeration.
| ||
| enum [BatMultiPMap] |
creates an enumeration for this map.
| ||
| enum [BatMultiMap] |
creates an enumeration for this map.
| ||
| enum [BatMap.PMap] |
creates an enumeration for this map, enumerating key,value pairs with the keys in increasing order.
| ||
| enum [BatMap.S] |
Return an enumeration of (key, value) pairs of a map.
| ||
| enum [BatMap] |
creates an enumeration for this map, enumerating key,value pairs with the keys in increasing order.
| ||
| enum [BatList] |
Returns an enumeration of the elements of a list.
| ||
| enum [BatLazyList] |
Lazy conversion to enumeration
| ||
| enum [BatISet] |
Enumerates all contiguous ranges in the set
| ||
| enum [BatIMap] | enum t returns an enumeration of the bindings in t
| ||
| enum [BatHeap.H] |
See
BatHeap.enum.
| ||
| enum [BatHeap] |
Enumerate the elements of the heap in heap order.
| ||
| enum [BatHashtbl.Cap] | |||
| enum [BatHashtbl.S] | |||
| enum [BatHashtbl] |
Return an enumeration of (key,value) pairs of a hashtable.
| ||
| enum [BatFingerTree.S] | enum t builds an enumeration of the elements of t going from
left to right.
| ||
| enum [BatEnum.Enumerable] |
Return an enumeration of the elements of the data structure
| ||
| enum [BatEnum] |
identity : added for consistency with the other data structures
| ||
| enum [BatDynArray] | enum darr returns the enumeration of darr elements.
| ||
| enum [BatDllist] |
Create an enum of the list.
| ||
| enum [BatDeque] | enum dq is an enumeration of the elements of dq from the
front to the rear.
| ||
| enum [BatChar] |
Produce the enumeration of all characters
| ||
| enum [BatBuffer] |
Returns an enumeration of the characters of a buffer.
| ||
| enum [BatBitSet] | enum s returns an enumeration of bits which are set
in the bitset s.
| ||
| enum [BatBigarray.Array3] | enum e returns an enumeration on the elements of e.
| ||
| enum [BatBigarray.Array2] | enum e returns an enumeration on the elements of e.
| ||
| enum [BatBigarray.Array1] | Array1.enum e returns an enumeration on the elements of e.
| ||
| enum [BatBigarray.Genarray] | enum e returns an enumeration on the elements of e.
| ||
| enum [BatAvlTree] | |||
| enum [BatArray.Cap] | |||
| enum [BatArray] |
Returns an enumeration of the elements of an array.
| ||
| enum_bits [BatRandom.Incubator.Private_state_enums.State] |
A copy of the input state is made to start these generators;
the input state is not modified.
| ||
| enum_bits [BatRandom.Incubator.Private_state_enums] |
These enumerations are built on a copy of the global RNG
state.
| ||
| enum_bits [BatRandom.State] | |||
| enum_bits [BatRandom] | |||
| enum_bool [BatRandom.Incubator.Private_state_enums.State] | |||
| enum_bool [BatRandom.Incubator.Private_state_enums] | |||
| enum_bool [BatRandom.State] | |||
| enum_bool [BatRandom] | |||
| enum_char [BatRandom.Incubator.Private_state_enums.State] | |||
| enum_char [BatRandom.Incubator.Private_state_enums] | |||
| enum_char [BatRandom.State] | |||
| enum_char [BatRandom] | |||
| enum_destruct [BatStack] | enum s returns a destructive enumeration of the elements of
stack s, from the most recently entered to the least recently
entered.
| ||
| enum_float [BatRandom.Incubator.Private_state_enums.State] | |||
| enum_float [BatRandom.Incubator.Private_state_enums] | |||
| enum_float [BatRandom.State] | |||
| enum_float [BatRandom] | |||
| enum_int [BatRandom.Incubator.Private_state_enums.State] | |||
| enum_int [BatRandom.Incubator.Private_state_enums] | |||
| enum_int [BatRandom.State] | |||
| enum_int [BatRandom] | |||
| enum_int32 [BatRandom.Incubator.Private_state_enums.State] | |||
| enum_int32 [BatRandom.Incubator.Private_state_enums] | |||
| enum_int32 [BatRandom.State] | |||
| enum_int32 [BatRandom] | |||
| enum_int64 [BatRandom.Incubator.Private_state_enums.State] | |||
| enum_int64 [BatRandom.Incubator.Private_state_enums] | |||
| enum_int64 [BatRandom.State] | |||
| enum_int64 [BatRandom] | |||
| enum_nativeint [BatRandom.Incubator.Private_state_enums.State] | |||
| enum_nativeint [BatRandom.Incubator.Private_state_enums] | |||
| enum_nativeint [BatRandom.State] | |||
| enum_nativeint [BatRandom] | |||
| enum_print [BatteriesPrint] | |||
| enum_print_limit [BatteriesPrint] | |||
| environment [BatUnix] |
Return the process environment, as an array of strings
with the format ``variable=value''.
| ||
| eof [BatParserCo] |
Accept the end of an enumeration.
| ||
| eprintf [BatPrintf] |
The usual
eprintf function, prints to the standard error output stderr, used
to display warnings and errors.
| ||
| eprintf [BatFormat] |
Same as
fprintf above, but output on err_formatter.
| ||
| epsilon [BatFloat.Safe_float] |
The smallest positive float
x such that 1.0 +. x <> 1.0.
| ||
| epsilon [BatFloat] |
The smallest positive float
x such that 1.0 +. x <> 1.0.
| ||
| eq [BatUChar] |
Equality by code point comparison
| ||
| eq [BatTuple.Tuple5] | |||
| eq [BatTuple.Tuple4] | |||
| eq [BatTuple.Tuple3] | |||
| eq [BatTuple.Tuple2] | |||
| eq [BatRef] | |||
| eq [BatOrd] |
Derives an equality function from an ordering function.
| ||
| eq [BatOption] |
Test for equality between option types, possibly using a custom
equality predicate.
| ||
| eq [BatList] | |||
| eq [BatDeque] | eq dq1 dq2 is true if dq1 and dq2 have the same sequence
of elements.
| ||
| eq [BatOrd.Eq] | |||
| eq [BatArray.Incubator.Eq] | |||
| eq_big_int [BatBig_int] | |||
| eq_by [BatOrd.Incubator] | |||
| eq_comp [BatOrd] | |||
| eq_comp0 [BatOrd] | |||
| eq_num [BatNum] | |||
| eq_ord [BatOrd] | |||
| eq_ord0 [BatOrd] | |||
| equal [BatVect] | |||
| equal [BatUref] | equal ur1 ur2 returns true iff ur1 and ur2 are equal
urefs, either because they are physically the same or because
they have been BatUref.united.
| ||
| equal [BatUnit] |
Always returns true.
| ||
| equal [BatText] |
Equality of ropes (based on compare)
| ||
| equal [BatSubstring] |
Substring equality
| ||
| equal [BatString] |
String equality
| ||
| equal [BatStack] | |||
| equal [BatSet.PSet] | equal s1 s2 tests whether the sets s1 and s2 are
equal, that is, contain equal elements.
| ||
| equal [BatSet.S] | equal s1 s2 tests whether the sets s1 and s2 are
equal, that is, contain equal elements.
| ||
| equal [BatSet] | equal s1 s2 tests whether the sets s1 and s2 are
equal, that is, contain equal elements.
| ||
| equal [BatSeq] | equal ~eq s1 s2 compares elements of s1 and s2 pairwise
using eq
| ||
| equal [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 [BatDigest] |
The equal function for digests.
| ||
| equal [BatComplex] | |||
| equal [BatChar] | |||
| equal [BatBytes] |
The equality function for byte sequences.
| ||
| equal [BatBool] | |||
| equal [BatBitSet] | equal s1 s2 returns true if, and only if, all bits values in s1 are
the same as in s2.
| ||
| equal [BatBig_int] | |||
| equal [BatArray.Cap] | |||
| equal [BatArray] |
Hoist a equality test for elements to arrays.
| ||
| err_formatter [BatFormat] |
A formatter to use with formatting functions below for
output to standard error.
| ||
| error [BatOptParse.OptParser] |
Display an error message and exit the program.
| ||
| error_message [BatUnix] |
Return a string describing the given error code.
| ||
| escaped [BatString.Cap] | |||
| escaped [BatString] |
Return a copy of the argument, with special characters
represented by escape sequences, following the lexical
conventions of OCaml.
| ||
| escaped [BatChar] |
Return a string representing the given character,
with special characters escaped following the lexical conventions
of OCaml.
| ||
| escaped [BatBytes] |
Return a copy of the argument, with special characters represented
by escape sequences, following the lexical conventions of OCaml.
| ||
| establish_server [BatUnix] |
Establish a server on the given address.
| ||
| eternity [BatLazyList] |
An infinite list of nothing
| ||
| 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 [a0; a1; ...; an] checks if at least one element of
the list satisfies the predicate p.
| ||
| exists [BatLazyList.Labels] | |||
| exists [BatLazyList] |
Eager existential.
| ||
| exists [BatISet] |
Test whether some element of a set satisfies a predicate
| ||
| exists [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.
| ||
| exn_slot_id [BatPrintexc] | Printexc.exn_slot_id returns an integer which uniquely identifies
the constructor used to create the exception value exn
(in the current runtime).
| ||
| exn_slot_name [BatPrintexc] | Printexc.exn_slot_id exn returns the internal name of the constructor
used to create the exception value exn.
| ||
| exp [BatFloat.Safe_float] |
Exponential.
| ||
| exp [BatFloat] |
Exponential.
| ||
| exp [BatComplex] |
Exponentiation.
| ||
| explode [BatText] | explode s returns the list of characters in the rope s.
| ||
| explode [BatSubstring] | explode sus returns the list of characters of sus, that is,
s(i), s(i+1), ..., s(i+n-1) where sus = (s, i, n).
| ||
| explode [BatString.Cap] | |||
| explode [BatString] | explode s returns the list of characters in the string s.
| ||
| exponential_resizer [BatDynArray] |
The exponential resizer- The default resizer except when the resizer
is being copied from some other darray.
| ||
| ext [BatPathGen.PathType] |
Returns extension of the name of the object the pathname points to.
| ||
| extend [BatBytes] | extend s left right returns a new byte sequence that contains
the bytes of s, with left uninitialized bytes prepended and
right uninitialized bytes appended to it.
| ||
| 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.
| ||
| favg [BatArray] | favg l returns the average of l
| ||
| fchmod [BatUnix] |
Change the permissions of an opened file.
| ||
| fchown [BatUnix] |
Change the owner uid and owner gid of an opened file.
| ||
| feed [BatGenlex.Languages.Make] |
Drop comments, present reserved operators and reserved
names as
Kwd, operators and identifiers as Ident,
integer numbers as Int, floating-point numbers as
Float and characters as Char.
| ||
| fields [BatSubstring] | fields p sus returns the list of fields in sus, from left to right,
where a field is a (possibly empty) maximal substring of sus not
containing any delimiter, and a delimiter is a character satisfying p.
| ||
| fifth [BatTuple.Tuple5] | |||
| file [BatDigest] |
Return the digest of the file whose name is given.
| ||
| file_exists [BatSys] |
Test if a file with the given name exists.
| ||
| files_of [BatSys] |
As
BatSys.readdir but the results are presented as an enumeration
of names.
| ||
| fill [BatText] | fill s start len c returns the rope in which
characters number start to start + len - 1 of s has
been replaced by c.
| ||
| fill [BatString.Cap] | |||
| fill [BatString] | String.fill s start len c modifies string s in place,
replacing len characters by c, starting at start.
| ||
| fill [BatOptParse.Formatter] |
See
OptParse.Formatter.wrap.
| ||
| fill [BatBytes] | fill s start len c modifies s in place, replacing len
characters with c, starting at start.
| ||
| fill [BatBigarray.Array3] |
Fill the given big array with the given value.
| ||
| fill [BatBigarray.Array2] |
Fill the given big array with the given value.
| ||
| fill [BatBigarray.Array1] |
Fill the given big array with the given value.
| ||
| fill [BatBigarray.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 [BatQueue] | filter p q returns a new queue that contain the elements of q
that satisfy the predicate p, in the same order.
| ||
| filter [BatPervasives] | filter f e returns an enumeration over all elements x of e such
as f x returns true.
| ||
| filter [BatParserCo] | filter f p is only accepts values x such that p
accepts x and f (p x) is true
| ||
| filter [BatOption] | filter f None returns None, filter f (Some x) returns Some x
if f x is true, and None otherwise.
| ||
| filter [BatMap.PMap] | filter f m returns a map where only the (key, value) pairs
key, a of m such that f key a = true remain.
| ||
| filter [BatMap.S.Labels] | |||
| filter [BatMap.S] | filter f m returns a map where only the key, values pairs
key, a of m such that f key a = true remain.
| ||
| filter [BatMap] | filter f m returns a map where only the (key, value) pairs
key, a of m such that f key a = true remain.
| ||
| filter [BatList.Labels] | |||
| filter [BatList] | filter p l returns all the elements of the list l
that satisfy the predicate p.
| ||
| filter [BatLazyList.Labels] | |||
| filter [BatLazyList] |
Lazy filtering.
| ||
| filter [BatISet] |
Builds the subset of those elements that satisfy the predicate
| ||
| filter [BatHashtbl.Cap.Labels] | |||
| filter [BatHashtbl.Cap] | |||
| filter [BatHashtbl.S.Labels] | |||
| filter [BatHashtbl.S] | |||
| filter [BatHashtbl.Labels] | |||
| filter [BatHashtbl] | filter f m returns a new hashtable where only the values a of m
such that f a = true remain.
| ||
| filter [BatEnum.Labels] | |||
| filter [BatEnum] | filter f e returns an enumeration over all elements x of e such
as f x returns true.
| ||
| filter [BatDynArray] | filter p a returns all the elements of the array a
that satisfy the predicate p.
| ||
| filter [BatDllist] | filter p l returns a new list, with entirely new nodes, whose
values are all the elements of the list l that satisfy the
predicate p.
| ||
| filter [BatArray.Cap.Labels] | |||
| filter [BatArray.Cap] | |||
| filter [BatArray.Labels] | |||
| filter [BatArray] | filter p a returns all the elements of the array a
that satisfy the predicate p.
| ||
| filter_inplace [BatQueue] | filter_inplace p q removes all the elements of the queue q that
don't satisfy the predicate p.
| ||
| filter_inplace [BatHashtbl.Cap.Labels] | |||
| filter_inplace [BatHashtbl.Cap] | |||
| filter_inplace [BatHashtbl.S.Labels] | |||
| filter_inplace [BatHashtbl.S] | |||
| filter_inplace [BatHashtbl.Labels] | |||
| filter_inplace [BatHashtbl] | filter_inplace f m removes from m all bindings that does not
satisfy the predicate f.
| ||
| filter_map [BatVect.Make] | filter_map f e returns a vect consisting of all elements
x such that f y returns Some x , where y is an element
of e.
| ||
| filter_map [BatVect] | filter_map f e returns a vect consisting of all elements
x such that f y returns Some x , where y is an element
of e.
| ||
| filter_map [BatText] | filter_map f l calls (f a0) (f a1).... (f an) where a0..an are
the characters of l.
| ||
| filter_map [BatString.Cap] | |||
| filter_map [BatString] | filter_map f s calls (f a0) (f a1).... (f an) where a0..an are
the characters of s.
| ||
| filter_map [BatSet.PSet] | filter_map f m combines the features of filter and
map.
| ||
| filter_map [BatSet.S.Labels] | |||
| filter_map [BatSet.S] | filter_map f m combines the features of filter and
map.
| ||
| filter_map [BatSet] | filter_map f m combines the features of filter and
map.
| ||
| filter_map [BatSeq] | filter_map f s returns the sequence of elements filtered and
mapped by f.
| ||
| filter_map [BatQueue] | filter_map f q applies f to the elements a0,a1..an of q in order,
and returns the queue of the elements bi such that f ai = Some bi,
in the corresponding order.
| ||
| filter_map [BatPervasives] |
Similar to a map, except that you can skip over some items of the
incoming enumeration by returning None instead of Some value.
| ||
| filter_map [BatMap.PMap] | filter_map f m combines the features of filter and
map.
| ||
| filter_map [BatMap.S] | filter_map f m combines the features of filter and
map.
| ||
| filter_map [BatMap] | filter_map f m combines the features of filter and
map.
| ||
| filter_map [BatList.Labels] | |||
| filter_map [BatList] | filter_map f l calls (f a0) (f a1).... (f an) where a0,a1..an are
the elements of l.
| ||
| filter_map [BatLazyList.Labels] | |||
| filter_map [BatLazyList] |
Lazily eliminate some elements and transform others.
| ||
| filter_map [BatHashtbl.Cap.Labels] | |||
| filter_map [BatHashtbl.Cap] | |||
| filter_map [BatHashtbl.S.Labels] | |||
| filter_map [BatHashtbl.S] | |||
| filter_map [BatHashtbl.Labels] | |||
| filter_map [BatHashtbl] | filter_map f m combines the features of filteri and map.
| ||
| filter_map [BatEnum.Labels] | |||
| filter_map [BatEnum] | filter_map f e returns an enumeration over all elements x such as
f y returns Some x , where y is an element of e.
| ||
| filter_map [BatDynArray] | filter_map f e returns an array consisting of all elements
x such that f y returns Some x , where y is an element
of e.
| ||
| filter_map [BatDllist] | filter_map f l calls (f a0) (f a1) ... (f an) where a0,a1...an
are the elements of l.
| ||
| filter_map [BatArray.Cap.Labels] | |||
| filter_map [BatArray.Cap] | |||
| filter_map [BatArray.Labels] | |||
| filter_map [BatArray] | filter_map f e returns an array consisting of all elements
x such that f y returns Some x , where y is an element
of e.
| ||
| filter_map_inplace [BatHashtbl.Cap.Labels] | |||
| filter_map_inplace [BatHashtbl.Cap] | |||
| filter_map_inplace [BatHashtbl.S.Labels] | |||
| filter_map_inplace [BatHashtbl.S] | |||
| filter_map_inplace [BatHashtbl.Labels] | |||
| filter_map_inplace [BatHashtbl] | filter_map_inplace f m performs like filter_map but modify m
inplace instead of creating a new Hashtbl.
| ||
| filteri [BatList] | filter p [a0; a1; ...; an] returns all the elements ai of index i
that satisfy the predicate p i ai.
| ||
| filteri [BatHashtbl.Cap.Labels] | |||
| filteri [BatHashtbl.Cap] | |||
| filteri [BatHashtbl.S.Labels] | |||
| filteri [BatHashtbl.S] | |||
| filteri [BatHashtbl.Labels] | |||
| filteri [BatHashtbl] | filter f m returns a hashtbl where only the key, values pairs
key, a of m such that f key a = true remain.
| ||
| filteri [BatArray] |
As
filter but with the index passed to the predicate.
| ||
| filteri_inplace [BatHashtbl.Cap.Labels] | |||
| filteri_inplace [BatHashtbl.Cap] | |||
| filteri_inplace [BatHashtbl.S.Labels] | |||
| filteri_inplace [BatHashtbl.S] | |||
| filteri_inplace [BatHashtbl.Labels] | |||
| filteri_inplace [BatHashtbl] | filteri_inplace f m performs as filter_inplace but f
receive the value in additiuon to the key.
| ||
| filteri_map [BatList] | filter_map f l calls (f 0 a0) (f 1 a1).... (f n an) where a0,a1..an are
the elements of l.
| ||
| filterv [BatMap.PMap] | filterv f m returns a map where only the values a of m
such that f a = true remain.
| ||
| filterv [BatMap.S.Labels] | |||
| filterv [BatMap.S] | filterv f m returns a map where only the values a of m
such that f a = true remain.
| ||
| filterv [BatMap] | filterv f m returns a map where only the values a of m
such that f a = true remain.
| ||
| finalise [BatGc] | finalise f v registers f as a finalisation function for v.
| ||
| finalise_release [BatGc] |
A finalisation function may call
finalise_release to tell the
GC that it can launch the next finalisation function without waiting
for the current one to return.
| ||
| finally [BatPervasives] | finally fend f x calls f x and then fend() even if f x raised
an exception.
| ||
| finally [BatInnerPervasives] | |||
| find [BatVect.Make] | find p a returns the first element of vect a
that satisfies the predicate p.
| ||
| find [BatVect] | find p a returns the first element of vect a
that satisfies the predicate p.
| ||
| find [BatText] | find s x returns the starting index of the first occurrence of
rope x within rope s.
| ||
| find [BatString.Cap.Exceptionless] | |||
| find [BatString.Cap] | |||
| find [BatString.Exceptionless] | find s x returns Some i, the starting index of the first
occurrence of string x within string s, or None if x
is not a substring of s.
| ||
| find [BatString] | find s x returns the starting index of the first occurrence of
string x within string s.
| ||
| find [BatSet.PSet] | find x s returns the element in s that tests equal to x under its comparison function.
| ||
| find [BatSet.S.Exceptionless] | |||
| find [BatSet.S] | find x s returns the element in s that tests equal to x under its comparison function.
| ||
| find [BatSet] | find x s returns the set element that compares equal to x.
| ||
| find [BatSeq] | find p s returns the first element of s such as p e
returns true, if any.
| ||
| find [BatRefList] |
Find the first element matching
the specified predicate
raise
Not_found if no element is found
| ||
| find [BatPervasives] | find f e returns the first element x of e such that f x returns
true, consuming the enumeration up to and including the
found element, or, raises Not_found if no such element exists
in the enumeration, consuming the whole enumeration in the search.
| ||
| find [BatMultiPMap] | find x m returns the current binding of x in m
| ||
| find [BatMultiMap] | find x m returns the current binding of x in m
| ||
| find [BatMap.PMap.Exceptionless] | |||
| find [BatMap.PMap] | find x m returns the current binding of x in m,
or raises Not_found if no such binding exists.
| ||
| find [BatMap.Exceptionless] | |||
| find [BatMap.S.Exceptionless] | |||
| find [BatMap.S] | find x m returns the current binding of x in m,
or raises Not_found if no such binding exists.
| ||
| find [BatMap] | find x m returns the current binding of x in m,
or raises Not_found if no such binding exists.
| ||
| find [BatList.Labels.LExceptionless] | |||
| find [BatList.Labels] | |||
| find [BatList.Exceptionless] | find p l returns Some x where x is the first element
of l such as p x returns true or None if such an
element has not been found.
| ||
| find [BatList] | find p l returns the first element of the list l
that satisfies the predicate p.
| ||
| find [BatLazyList.Labels.Exceptionless] | |||
| find [BatLazyList.Labels] | |||
| find [BatLazyList.Exceptionless] | 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 [BatString] | find_all s x enumerates positions of s at which x occurs.
| ||
| find_all [BatList.Labels] | |||
| find_all [BatList] | find_all is another name for List.filter.
| ||
| find_all [BatInnerWeaktbl] | 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 [b0; b1; ...; bn] is
f (... (f (f a b0) b1) ...) bn.
| ||
| fold_left [BatLazyList.Labels] | |||
| fold_left [BatLazyList] |
Eager fold_left
| ||
| fold_left [BatFingerTree.S] | fold_left is equivalent to List.fold_left.
| ||
| fold_left [BatDynArray] | fold_left f x darr computes f ( ... ( f ( f a0 x) a1) ) ... )
aN, where a0,a1..aN are the indexed elements of darr.
| ||
| fold_left [BatDllist] |
Accumulate a value over the entire list.
| ||
| fold_left [BatDeque] | fold_left f acc dq is equivalent to List.fold_left f acc
(to_list dq), but more efficient.
| ||
| fold_left [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 [BatSubstring] |
As
fold_left, but with the index of the element as additional argument
| ||
| fold_lefti [BatString.Cap] | |||
| fold_lefti [BatString] |
As
fold_left, but with the index of the element as additional argument
| ||
| fold_lefti [BatList] |
As
fold_left, but with the index of the element, from 0 to
length li - 1, as additional argument.
| ||
| fold_lefti [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 [BatSubstring] |
As
fold_right, but with the index of the element as additional argument
| ||
| fold_righti [BatString.Cap] | |||
| fold_righti [BatString] |
As
fold_right, but with the index of the element as additional argument
| ||
| fold_righti [BatList] |
As
fold_right, but with the index of the element, from 0 to
length li - 1, as additional argument.
| ||
| fold_righti [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 [a0; a1; ...; an] checks if all elements of the list
satisfy the predicate p.
| ||
| for_all [BatLazyList.Labels] | |||
| for_all [BatLazyList] |
Eager universal.
| ||
| for_all [BatISet] |
Tests whether a predicate applies to all elements of the set
| ||
| for_all [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 [BatPrintexc.Slot] | format pos slot returns the string representation of slot as
raw_backtrace_to_string would format it, assuming it is the
pos-th element of the backtrace: the 0-th element is
pretty-printed differently than the others.
| ||
| format_from_string [BatScanf] | format_from_string s fmt converts a string argument to a format string,
according to the given format string fmt.
| ||
| format_timestamp [BatLogger] | format_timestamp oc timestamp prints an ISO-8601 formatted
timestamp (extended to specify higher-resolution seconds) to
the output channel, oc.
| ||
| formatter_of_buffer [BatFormat] | formatter_of_buffer b returns a new formatter writing to
buffer b.
| ||
| formatter_of_out_channel [BatFormat] | formatter_of_out_channel oc returns a new formatter that
writes to the corresponding channel oc.
| ||
| formatter_of_output [BatFormat] | formatter_of_output out returns a new formatter that
writes to the corresponding output out.
| ||
| fortran_layout [BatBigarray] | |||
| fourth [BatTuple.Tuple5] | |||
| fourth [BatTuple.Tuple4] | |||
| fprintf [BatPrintf] |
General function.
| ||
| fprintf [BatFormat] | |||
| frexp [BatFloat.Safe_float] | frexp f returns the pair of the significant
and the exponent of f.
| ||
| frexp [BatFloat] | frexp f returns the pair of the significant and the exponent
of f.
| ||
| from [BatStream] | Stream.from f returns a stream built from the function f.
| ||
| from [BatLazyList] | from next creates a (possibly infinite) lazy list from the successive
results of next.
| ||
| from [BatISet] | from x t returns the portion of t in the range x, max_int
| ||
| from [BatIMap] |
Return the sub-map of bindings in the range
x,max_int
| ||
| from [BatEnum.Labels] | |||
| from [BatEnum] | from next creates an enumeration from the next function.
| ||
| from_bytes [BatMarshal] | Marshal.from_bytes buff ofs unmarshals a structured value
like Marshal.from_channel does, except that the byte
representation is not read from a channel, but taken from
the byte sequence buff, starting at position ofs.
| ||
| from_channel [BatScanf.Scanning] | |||
| from_channel [BatMarshal] | |||
| from_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] |
Same as
from_bytes but take a string as argument instead of a
byte sequence.
| ||
| from_string [BatLexing] |
Create a lexer buffer which reads from
the given string.
| ||
| from_while [BatLazyList] | from next creates a (possibly infinite) lazy list from the successive
results of next.
| ||
| from_while [BatEnum.Labels] | |||
| from_while [BatEnum] | from_while next creates an enumeration from the next function.
| ||
| front [BatFingerTree.S] | front t returns None when t is empty,
or Some (tl, hd) when hd is the first element of the sequence
and tl is the rest of the sequence.
| ||
| front [BatDeque] | front dq returns Some (x, dq') iff x is at the front of
dq and dq' is the rest of dq excluding x, and None if
dq has no elements.
| ||
| front_exn [BatFingerTree.S] | front_exn t returns (tl, hd) when hd is the first element
of the sequence and tl is the rest of the sequence.
| ||
| fscanf [BatScanf] |
Same as
Scanf.bscanf, but reads from the given channel.
| ||
| fstat [BatUnix.LargeFile] | |||
| fstat [BatUnix] |
Return the information for the file associated with the given
descriptor.
| ||
| fsum [BatList] | fsum l returns the sum of the floats of l
| ||
| fsum [BatEnum] | |||
| fsum [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 [BatBytes] | get s n returns the byte at index n in argument s.
| ||
| get [BatBigarray.Array3] | Array3.get a x y z, also written a.{x,y,z},
returns the element of a at coordinates (x, y, z).
| ||
| get [BatBigarray.Array2] | Array2.get a x y, also written a.{x,y},
returns the element of a at coordinates (x, y).
| ||
| get [BatBigarray.Array1] | Array1.get a x, or alternatively a.{x},
returns the element of a at index x.
| ||
| get [BatBigarray.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_bucket [BatGc] | get_bucket n returns the current size of the n-th future bucket
of the GC smoothing system.
| ||
| get_callstack [BatPrintexc] | Printexc.get_callstack n returns a description of the top of the
call stack on the current program point (for the current thread),
with at most n entries.
| ||
| get_cmp [BatSet.PSet] |
get the comparison function used for a polymorphic map
| ||
| get_cmp [BatMap.PMap] |
returns the comparison function of the given map
| ||
| get_credit [BatGc] | get_credit () returns the current size of the "work done in advance"
counter of the GC smoothing system.
| ||
| get_dec_eq [BatIMap] |
Get the equality function used in an IMap.t
| ||
| get_ellipsis_text [BatFormat] |
Return the text of the ellipsis.
| ||
| get_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_minor_free [BatGc] |
Return the current size of the free space inside the minor heap.
| ||
| get_print_tags [BatFormat] | |||
| get_public_method [BatOo.Internal] | |||
| get_raw_backtrace [BatPrintexc] | Printexc.get_raw_backtrace () returns the same exception
backtrace that Printexc.print_backtrace would print, but in
a raw format.
| ||
| get_raw_backtrace_slot [BatPrintexc] | get_slot bckt pos returns the slot in position pos in the
backtrace bckt.
| ||
| get_resizer [BatDynArray] |
Get the current resizer function for a given array
| ||
| get_state [BatRandom] |
Return the current state of the generator used by the basic functions.
| ||
| get_state [BatParserCo.Source] | |||
| get_variable [BatOo.Internal] | |||
| get_variables [BatOo.Internal] | |||
| getaddrinfo [BatUnix] | getaddrinfo host service opts returns a list of Unix.addr_info
records describing socket parameters and addresses suitable for
communicating with the given host and service.
| ||
| getc [BatSubstring] | getc sus returns Some(c, rst) where c is the first character and
rst the remainder of sus, if sus is non-empty; otherwise returns
None.
| ||
| getcwd [BatUnix] |
Return the name of the current working directory.
| ||
| getcwd [BatSys] |
Return the current working directory of the process.
| ||
| getegid [BatUnix] |
Return the effective group id under which the process runs.
| ||
| getenv [BatUnix] |
Return the value associated to a variable in the process
environment.
| ||
| getenv [BatSys] |
Return the value associated to a variable in the process
environment.
| ||
| geteuid [BatUnix] |
Return the effective user id under which the process runs.
| ||
| getgid [BatUnix] |
Return the group id of the user executing the process.
| ||
| getgrgid [BatUnix] |
Find an entry in
group with the given group id.
| ||
| getgrnam [BatUnix] |
Find an entry in
group with the given name.
| ||
| getgroups [BatUnix] |
Return the list of groups to which the user executing the process
belongs.
| ||
| gethostbyaddr [BatUnix] |
Find an entry in
hosts with the given address.
| ||
| gethostbyname [BatUnix] |
Find an entry in
hosts with the given name.
| ||
| gethostname [BatUnix] |
Return the name of the local host.
| ||
| getitimer [BatUnix] |
Return the current status of the given interval timer.
| ||
| getlogin [BatUnix] |
Return the login name of the user executing the process.
| ||
| getnameinfo [BatUnix] | getnameinfo addr opts returns the host name and service name
corresponding to the socket address addr.
| ||
| getpeername [BatUnix] |
Return the address of the host connected to the given socket.
| ||
| getpid [BatUnix] |
Return the pid of the process.
| ||
| getppid [BatUnix] |
Return the pid of the parent process.
| ||
| getprotobyname [BatUnix] |
Find an entry in
protocols with the given name
| ||
| getprotobynumber [BatUnix] |
Find an entry in
protocols with the given protocol number.
| ||
| getpwnam [BatUnix] |
Find an entry in
passwd with the given name.
| ||
| getpwuid [BatUnix] |
Find an entry in
passwd with the given user id.
| ||
| getservbyname [BatUnix] |
Find an entry in
services with the given name.
| ||
| getservbyport [BatUnix] |
Find an entry in
services with the given service number.
| ||
| getsockname [BatUnix] |
Return the address of the given socket.
| ||
| getsockopt [BatUnix] |
Return the current status of a boolean-valued option
in the given socket.
| ||
| getsockopt_error [BatUnix] |
Return the error condition associated with the given socket,
and clear it.
| ||
| getsockopt_float [BatUnix] |
Same as
Unix.getsockopt for a socket option whose value is a
floating-point number.
| ||
| getsockopt_int [BatUnix] |
Same as
Unix.getsockopt for an integer-valued socket option.
| ||
| getsockopt_optint [BatUnix] |
Same as
Unix.getsockopt for a socket option whose value is an
int option.
| ||
| gettimeofday [BatUnix] |
Same as
Unix.time, but with resolution better than 1 second.
| ||
| getuid [BatUnix] |
Return the user id of the user executing the process.
| ||
| gmtime [BatUnix] |
Convert a time in seconds, as returned by
Unix.time, into a date and
a time.
| ||
| group [BatList] | group cmp l returns list of groups and each group consists of
elements judged equal by comparison function cmp.
| ||
| group [BatEnum] | group test e divides e into an enumeration of enumerations,
where each sub-enumeration is the longest continuous enumeration
of elements whose test results are the same.
| ||
| group_by [BatEnum] | group_by eq e divides e into an enumeration of enumerations,
where each sub-enumeration is the longest continuous enumeration
of elements that are equal, as judged by eq.
| ||
| group_consecutive [BatList] |
The
group_consecutive function takes a list and returns a list of lists such
that the concatenation of the result is equal to the argument.
| ||
| group_exec [BatFile] |
Give the permission to execute the file to the group
containing the user.
| ||
| group_read [BatFile] |
Give the permission to read the file to the group
containing the user.
| ||
| group_write [BatFile] |
Give the permission to write the file to the group
containing the user.
| ||
| gt_big_int [BatBig_int] |
Usual boolean comparisons between two big integers.
| ||
| gt_num [BatNum] | |||
H | |||
| handle_unix_error [BatUnix] | handle_unix_error f x applies f to x and returns the result.
| ||
| hard_count [BatEnum] | hard_count returns the number of remaining in elements in e,
consuming the whole enumeration somewhere along the way.
| ||
| has_symlink [BatUnix] |
Returns
true if the user is able to create symbolic links.
| ||
| hash [BatInnerIO.Output] |
A hash function for outputs
| ||
| hash [BatInnerIO.Input] |
A hash function for inputs
| ||
| hash [BatHashtbl.HashedType] |
A hashing function on keys.
| ||
| hash [BatHashtbl] | Hashtbl.hash x associates a positive integer to any value of
any type.
| ||
| hash [BatChar] | |||
| hash_param [BatHashtbl] | Hashtbl.hash_param n m x computes a hash value for x, with the
same properties as for hash.
| ||
| hashcons [BatHashcons.Table] | hashcons tab k returns either k, adding it to the table
tab as a side effect, or if k is already in the table then
it returns the hashed object corresponding to that entry.
| ||
| hc0 [BatHashcons.H] | hc0 ho is the hashcode of a first constructor applied to the
hashed object ho
| ||
| hc0_ [BatHashcons.H] | hc0_ h corresponds to the hashcode of a first constructor
applied to an object of hashcode h
| ||
| hc1 [BatHashcons.H] | hc1 ho k corresponds to the hashcode of the kth
constructor applied to the hashed object ho.
| ||
| hc1_ [BatHashcons.H] | hc1_ h k corresponds to the hashcode of the kth
constructor applied to an object of hashcode h.
| ||
| hd [BatSeq.Exceptionless] | |||
| hd [BatSeq] |
Returns the first element of the sequence or raise
Invalid_argument if
the sequence is empty.
| ||
| hd [BatRefList] |
same as
first
| ||
| hd [BatList.Exceptionless] | hd l returns Some x such that x is the first element of the given
list l.
| ||
| hd [BatList] |
Similar to
first, but
| ||
| hd [BatLazyList] |
Return the first element of the given list.
| ||
| head [BatText] |
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)
| ||
| huge_fallback_count [BatGc] |
Return the number of times we tried to map huge pages and had to fall
back to small pages.
| ||
I | |||
| i [BatComplex] |
The complex number
i.
| ||
| i16s_of [BatIO.BigEndian] |
Read an enumartion of signed 16-bit words.
| ||
| i16s_of [BatIO] |
Read an enumartion of signed 16-bit words.
| ||
| i32s_of [BatIO.BigEndian] |
Read an enumeration of signed 32-bit integers.
| ||
| i32s_of [BatIO] |
Read an enumeration of signed 32-bit integers.
| ||
| i64s_of [BatIO.BigEndian] |
Read an enumeration of signed 64-bit integers as OCaml
int64s.
| ||
| i64s_of [BatIO] |
Read an enumeration of signed 64-bit integers as OCaml
int64s.
| ||
| icompare [BatString.Cap] | |||
| icompare [BatString] |
Compare two strings, case-insensitive.
| ||
| id [BatOo] |
Return an integer identifying this object, unique for
the current execution of the program.
| ||
| ident [BatGenlex.Languages.Make] |
Accepts any non-reserved identifier/operator.
| ||
| ident_letter [BatGenlex.Languages.Definition] | |||
| ident_start [BatGenlex.Languages.Definition] | |||
| identifier [BatGenlex.Languages.Make] | |||
| identity [BatPervasives] |
The identity function.
| ||
| identity [BatInnerPervasives] | |||
| ifprintf [BatPrintf] |
As
BatPrintf.fprintf but doesn't actually print anything.
| ||
| ifprintf [BatFormat] |
Same as
fprintf above, but does not print anything.
| ||
| ignore_exceptions [BatPervasives] | ignore_exceptions f x invokes f on x, ignoring both the returned value
and the exceptions that may be raised.
| ||
| ignore_exceptions [BatInnerPervasives] | |||
| ignore_ok [BatPervasives] | ignore_ok (f x) ignores the result of f x if it's ok, but
throws the exception contained if Bad is returned.
| ||
| ignore_ok [BatInnerPervasives] | |||
| ignore_one_plus [BatParserCo] |
Ignore a (non-empty) list of expressions.
| ||
| ignore_zero_plus [BatParserCo] |
Ignore a (possibly empty) list of expressions.
| ||
| ikfprintf [BatFormat] |
Same as
kfprintf above, but does not print anything.
| ||
| implode [BatText] | implode cs returns a rope resulting from concatenating
the characters in the list cs.
| ||
| implode [BatString.Cap] | |||
| implode [BatString] | implode cs returns a string resulting from concatenating
the characters in the list cs.
| ||
| in_channel_of_descr [BatUnix] |
Create an input channel reading from the given descriptor.
| ||
| in_place_mirror [BatString] | |||
| incr_num [BatNum] | |||
| incr_option [BatOptParse.StdOpt] |
Exactly identical to
count_option ~dest:dest ~increment:1 ().
| ||
| indented_formatter [BatOptParse.Formatter] |
Create an "indented" formatter with the given options.
| ||
| index [BatText] | index s c returns the position of the leftmost
occurrence of character c in rope s.
| ||
| index [BatSubstring] | index sus c returns the index of the first occurence of c in sus or
| ||
| index [BatString.Cap.Exceptionless] | |||
| index [BatString.Cap] | |||
| index [BatString.Exceptionless] | index s c returns Some p, the position of the leftmost
occurrence of character c in string s or
None if c does not occur in s.
| ||
| index [BatString] | String.index s c returns the character number of the first
occurrence of character c in string s.
| ||
| index [BatRefList.Index] |
Return the index (position : 0 starting) of an element in
a ref list, using the specified comparator
raise
Not_found if no element was found
| ||
| index [BatBytes] | index s c returns the index of the first occurrence of byte c
in s.
| ||
| index_from [BatText] | index_from r i c returns the character number of the
first occurrence of character c in rope r after position i.
| ||
| index_from [BatSubstring] | index_from sus i c returns the index of the first occurence of c in
sus after the index i or
| ||
| index_from [BatString.Cap.Exceptionless] | |||
| index_from [BatString.Cap] | |||
| index_from [BatString.Exceptionless] |
Same as
String.Exceptionless.index, but start
searching at the character position given as second argument.
| ||
| index_from [BatString] | String.index_from s i c returns the character number of the
first occurrence of character c in string s after position i.
| ||
| index_from [BatBytes] | index_from s i c returns the index of the first occurrence of
byte c in s after position i.
| ||
| index_of [BatRefList.Index] |
Return the index (position : 0 starting) of an element in
a ref list, using ( = ) for testing element equality
raise
Not_found if no element was found
| ||
| index_of [BatList] | index_of e l returns the index of the first occurrence of e
in l, or None if there is no occurrence of e in l
| ||
| index_of [BatLazyList] | index_of e l returns the index of the first occurrence of e
in l, or None if there is no occurrence of e in l
| ||
| index_of [BatDynArray] | 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 [BatBytes] | Bytes.init n f returns a fresh byte sequence of length n, with
character i initialized to the result of f i (in increasing
index order).
| ||
| init [BatArray.Cap.Labels] | |||
| init [BatArray.Cap] | |||
| init [BatArray.Labels] | |||
| init [BatArray] | Array.init n f returns a fresh array of length n,
with element number i initialized to the result of f i.
| ||
| init_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_size [BatSys] |
Size of an int.
| ||
| int_str_pmap [BatteriesPrint] | |||
| integer [BatGenlex.Languages.Make] |
Parse an integer.
| ||
| integer_num [BatNum] | |||
| inter [BatSet.S] |
Set intersection.
| ||
| inter [BatISet] |
Compute the intersection of two sets.
| ||
| inter [BatBitSet] | inter s t returns the intersection of sets s and t.
| ||
| interactive [BatSys] |
This reference is initially set to
false in standalone
programs and to true if the code is being executed under
the interactive toplevel system ocaml.
| ||
| interleave [BatList] | interleave ~first ~last sep [a0;a1;a2;...;an] returns
first; a0; sep; a1; sep; a2; sep; ...; sep; an; last
| ||
| interleave [BatEnum] | interleave enums creates a new enumeration from an array of enumerations.
| ||
| intersect [BatSet.PSet] | intersect s t returns a new set of those elements that are in
both s and t.
| ||
| intersect [BatSet] | intersect s t returns a new set of those elements that are in
both s and t.
| ||
| intersect [BatMap.PMap] | intersect merge_f m1 m2 returns a map with bindings only for
keys bound in both m1 and m2, and with k bound to merge_f
v1 v2, where v1 and v2 are k's bindings in m1 and m2.
| ||
| intersect [BatMap] | intersect merge_f m1 m2 returns a map with bindings only for
keys bound in both m1 and m2, and with k bound to merge_f
v1 v2, where v1 and v2 are k's bindings in m1 and m2.
| ||
| intersect [BatBitSet] | intersect s t sets s to the intersection of the sets s and t.
| ||
| inv [BatComplex] |
Multiplicative inverse (
1/z).
| ||
| invpi [BatFloat] | 1. /. pi
| ||
| invpi2 [BatFloat] | 2. /. pi
| ||
| invsqrt2 [BatFloat] | 1. /. sqrt 2.
| ||
| is_absolute [BatPathGen.PathType] | |||
| is_ascii [BatUChar] | true if the char is a regular ascii char, i.e.
| ||
| is_bad [BatResult] | 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_raise [BatPrintexc.Slot] | is_raise slot is true when slot refers to a raising
point in the code, and false when it comes from a simple
function call.
| ||
| is_relative [BatPathGen.PathType] | |||
| is_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 [a0; a1; ...; an] applies function f in turn to
a0; a1; ...; an.
| ||
| iter [BatLazyList.Labels] | |||
| iter [BatLazyList] |
Eager iteration
| ||
| iter [BatInnerWeaktbl] | Weaktbl.iter f tbl applies f to all bindings in table tbl.
| ||
| iter [BatISet] | iter f t calls f once for each element of t
| ||
| iter [BatIMap] | iter f t calls f on every binding
| ||
| iter [BatHashtbl.Cap.Labels] | |||
| iter [BatHashtbl.Cap] | |||
| iter [BatHashtbl.S.Labels] | |||
| iter [BatHashtbl.S] | |||
| iter [BatHashtbl.Labels] | |||
| iter [BatHashtbl] | Hashtbl.iter f tbl applies f to all bindings in table tbl.
| ||
| iter [BatHashcons.Table] | iter f tab applies f to every live hashed object in the
table tab.
| ||
| iter [BatFingerTree.S] | iter is equivalent to List.iter.
| ||
| iter [BatEnum.Labels] | |||
| iter [BatEnum] | iter f e calls the function f with each elements of e in turn.
| ||
| iter [BatDynArray] | iter f darr calls the function f on every element of darr.
| ||
| iter [BatDllist] | iter f n Apply f to every element in the list, starting at n.
| ||
| iter [BatDeque] | iter f dq calls f x on each element x of dq.
| ||
| iter [BatBytes] | iter f s applies function f in turn to all the bytes of s.
| ||
| iter [BatBigarray.Genarray] | iter f a applies function f in turn to all
the elements of a.
| ||
| iter [BatAvlTree] | |||
| iter [BatArray.Cap.Labels] | |||
| iter [BatArray.Cap] | |||
| iter [BatArray.Labels] | |||
| iter [BatArray] | Array.iter f a applies function f in turn to all
the elements of a.
| ||
| iter2 [BatSeq] | iter2 f s1 s2 iterates on elements of s1 and s2 pairwise, and
stops when it meets the end of s1 or s2
| ||
| iter2 [BatList.Labels] | |||
| iter2 [BatList] | List.iter2 f [a0; a1; ...; an] [b0; b1; ...; bn] calls in turn
f a0 b0; f a1 b1; ...; f an bn.
| ||
| iter2 [BatLazyList.Labels] | |||
| iter2 [BatLazyList] | iter2 f [^ a0; ...; an ^] [^ b0; ...; bn ^] calls in turn
f a0 b0; ...; f an bn.
| ||
| iter2 [BatEnum.Labels] | |||
| iter2 [BatEnum] | iter2 f e1 e2 calls the function f with the next elements of e1 and
e2 repeatedly until one of the two enumerations ends.
| ||
| iter2 [BatArray.Cap.Labels] | |||
| iter2 [BatArray.Cap] | |||
| iter2 [BatArray.Labels] | |||
| iter2 [BatArray] | Array.iter2 f [|a0; a1; ...; an|] [|b0; b1; ...; bn|]
performs calls f a0 b0; f a1 b1; ...; f an bn in that order.
| ||
| iter2i [BatEnum.Labels] | |||
| iter2i [BatEnum] | |||
| iter2i [BatArray.Cap.Labels] | |||
| iter2i [BatArray.Cap] | |||
| iter2i [BatArray.Labels] | |||
| iter2i [BatArray] | Array.iter2i f [|a0; a1; ...; an|] [|b0; b1; ...; bn|]
performs calls f 0 a0 b0; f 1 a1 b1; ...; f n an bn in that
order.
| ||
| iter_range [BatISet] | iter_range f t calls f once for each contiguous range of t.
| ||
| iter_range [BatIMap] | iter_range f t calls f on every contiguous range.
| ||
| iter_right [BatFingerTree.S] | iter_right is equivalent to List.iter o List.rev.
| ||
| iteri [BatVect.Make] |
Operates like iter, but also passes the index of the character
to the given function.
| ||
| iteri [BatVect] |
Operates like iter, but also passes the index of the character
to the given function.
| ||
| iteri [BatText] |
Operates like
iter, but also passes the index of the character
to the given function.
| ||
| iteri [BatSubstring] |
Same as
BatSubstring.iter, but the
function is applied to the index of the element as first argument
(counting from 0), and the character itself as second argument.
| ||
| iteri [BatString] |
Same as
String.iter, but the
function is applied to the index of the element as first argument
(counting from 0), and the character itself as second argument.
| ||
| iteri [BatSeq] | iteri f s is the same as iter f s, but f is given the index
of each element (starting at 0).
| ||
| iteri [BatPathGen.StringType] | |||
| iteri [BatList.Labels] | |||
| iteri [BatList] | iteri f l will call (f 0 a0); (f 1 a1) ... (f n an) where
a0..an are the elements of the list l.
| ||
| iteri [BatLazyList.Labels] | |||
| iteri [BatLazyList] |
Eager iteration, with indices
| ||
| iteri [BatEnum.Labels] | |||
| iteri [BatEnum] | |||
| iteri [BatDynArray] | 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 [BatBytes] |
Same as
Bytes.iter, but the function is applied to the index of
the byte as first argument and the byte itself as second
argument.
| ||
| iteri [BatBigarray.Genarray] |
Same as
BatBigarray.Genarray.iter, but the function is applied to the index of
the element as the first argument, and the element itself as
the second argument.
| ||
| iteri [BatArray.Cap.Labels] | |||
| iteri [BatArray.Cap] | |||
| iteri [BatArray.Labels] | |||
| iteri [BatArray] |
Same as
Array.iter, but the
function is applied to the index of the element as first argument,
and the element itself as second argument.
| ||
J | |||
| join [BatText] |
Same as
BatText.concat
| ||
| join [BatString.Cap] | |||
| join [BatString] |
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 | |||
| kahan_sum [BatList] | kahan_sum l returns a numerically-accurate sum of the floats of
l.
| ||
| kahan_sum [BatEnum] | kahan_sum l returns a numerically-accurate sum of the floats of
l.
| ||
| kahan_sum [BatArray] | kahan_sum l returns a numerically-accurate
sum of the floats of l.
| ||
| kbprintf [BatPrintf] |
Same as
bprintf, but instead of returning immediately,
passes the buffer to its first argument at the end of printing.
| ||
| kbprintf2 [BatPrintf] |
Same as
bprintf2, but instead of returning immediately,
passes the buffer to its first argument at the end of printing.
| ||
| keep [BatDynArray] | keep p darr removes in place all the element x of darr
such that p x = false
| ||
| keys [BatMap.PMap] |
Return an enumeration of all the keys of a map.
| ||
| keys [BatMap.S] |
Return an enumeration of all the keys of a map.
| ||
| keys [BatMap] |
Return an enumeration of all the keys of a map.
| ||
| keys [BatHashtbl.Cap] | |||
| keys [BatHashtbl.S] | |||
| keys [BatHashtbl] |
Return an enumeration of all the keys of a hashtable.
| ||
| keyword [BatGenlex.Languages.Make] | |||
| kfprintf [BatPrintf] |
Same as
fprintf, but instead of returning immediately, passes the output to its first
argument at the end of printing.
| ||
| kfprintf [BatFormat] |
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.
| ||
| kind_size_in_bytes [BatBigarray] | kind_size_in_bytes k is the number of bytes used to store
an element of type k.
| ||
| kprintf [BatPrintf] | |||
| kprintf [BatFormat] |
A deprecated synonym for
ksprintf.
| ||
| kscanf [BatScanf] |
Same as
Scanf.bscanf, but takes an additional function argument
ef that is called in case of error: if the scanning process or
some conversion fails, the scanning function aborts and calls the
error handling function ef with the scanning buffer and the
exception that aborted the scanning process.
| ||
| ksprintf [BatPrintf] |
Same as
sprintf above, but instead of returning the string,
passes it to the first argument.
| ||
| ksprintf [BatFormat] |
Same as
sprintf above, but instead of returning the string,
passes it to the first argument.
| ||
| ksprintf2 [BatPrintf] |
Same as
sprintf2 above, but instead of returning the string,
passes it to the first argument.
| ||
| kwd [BatGenlex.Languages.Make] |
Accepts any identifier.
| ||
L | |||
| label [BatReturn] | label f creates a new label x and invokes
f x.
| ||
| label [BatParserCo] |
Give a name to a parser, for debugging purposes.
| ||
| last [BatVect.Make] |
These return the first and last values in the vector
| ||
| last [BatVect] |
These return the first and last values in the vector
| ||
| last [BatUTF8] |
The position of the head of the last Unicode character.
| ||
| last [BatSeq.Exceptionless] | |||
| last [BatSeq] |
Returns the last element of the sequence, or raise
Invalid_argument if
the sequence is empty.
| ||
| last [BatRefList] |
Returns the last element - O(n) or
raises
Empty_list if the ref list is empty
| ||
| last [BatList.Exceptionless] | last l returns either Some x where x is the last element of the list, or None if
the list is empty.
| ||
| last [BatList] |
Returns the last element of the list, or
| ||
| last [BatLazyList] |
Returns the last element of the list.
| ||
| last [BatFingerTree.S] | last t returns None if t is empty,
or Some hd otherwise, where hd is the last element
of the sequence.
| ||
| last [BatDynArray] | last darr returns the last element of darr.
| ||
| last_exn [BatFingerTree.S] | last_exn t returns the last element of the sequence.
| ||
| latin1 [BatCharParser] |
Recognizes one lower- or upper-case Latin1 character, including
accentuated characters.
| ||
| layout [BatBigarray.Array3] |
Return the layout of the given big array.
| ||
| layout [BatBigarray.Array2] |
Return the layout of the given big array.
| ||
| layout [BatBigarray.Array1] |
Return the layout of the given big array.
| ||
| layout [BatBigarray.Genarray] |
Return the layout of the given big array.
| ||
| lazy_fold_right [BatLazyList] |
Lazy fold_right
lazy_fold_right f (Cons (a0, Cons (a1, Cons (a2, nil)))) b is
lazy (f a0 (lazy (f a1 (lazy (f a2 b))))).
| ||
| lchop [BatText] |
Returns the same rope but without the first character.
| ||
| lchop [BatString.Cap] | |||
| lchop [BatString] |
Returns the same string but without the first
n characters.
| ||
| ldexp [BatFloat.Safe_float] | ldexp x n returns x *. 2 ** n.
| ||
| ldexp [BatFloat] | ldexp x n returns x *. 2 ** n.
| ||
| le_big_int [BatBig_int] | |||
| le_num [BatNum] | |||
| left [BatText] | left r len returns the rope containing the len first characters of r
| ||
| left [BatString.Cap] | |||
| left [BatString] | left r len returns the string containing the len first
characters of r.
| ||
| left [BatArray] | left r len returns the array containing the len first
characters of r.
| ||
| left_branch [BatAvlTree] | |||
| length [BatVect.RANDOMACCESS] | |||
| length [BatVect.Make] |
Returns the length of the vect (
O(1)).
| ||
| length [BatVect] |
Returns the length of the vect (
O(1)).
| ||
| length [BatUTF8] | length s returns the number of Unicode characters contained in s
| ||
| length [BatText] |
Returns the length of the rope (
O(1)).
| ||
| length [BatSubstring] |
Equivalent to
BatSubstring.size.
| ||
| length [BatString.Cap] | |||
| length [BatString] |
Return the length (number of characters) of the given string.
| ||
| length [BatStack] |
Return the number of elements in a stack.
| ||
| length [BatSeq] |
Return the number of elements of the given sequence.
| ||
| length [BatRefList] |
Returns the number of elements - O(n)
| ||
| length [BatQueue] |
Return the number of elements in a queue.
| ||
| length [BatPathGen.StringType] |
Length - number of indexing units
| ||
| length [BatList] |
Return the length (number of elements) of the given list.
| ||
| length [BatLazyList] |
Return the length (number of elements) of the given list.
| ||
| length [BatInnerWeaktbl] | Weaktbl.length tbl returns the number of bindings in tbl.
| ||
| length [BatHashtbl.Cap] | |||
| length [BatHashtbl.S] | |||
| length [BatHashtbl] | Hashtbl.length tbl returns the number of bindings in tbl.
| ||
| length [BatDynArray] |
Return the number of elements in the array.
| ||
| length [BatDllist] |
Returns the length of the list.
| ||
| length [BatBytes] |
Return the length (number of t) of the argument.
| ||
| length [BatBuffer] |
Return the number of characters currently contained in the buffer.
| ||
| length [BatArray.Cap] | |||
| length [BatArray] |
Return the length (number of elements) of the given array.
| ||
| letter [BatPathGen.StringType.Parse] | |||
| letter [BatCharParser] |
Recognizes one lower- or upper-case ASCII character, including
accentuated characters.
| ||
| level [BatLog.Make_lev] | |||
| level [BatLog.Easy] |
Set this ref to the lowest level of log you want logged.
| ||
| level_of_name [BatLogger] | level_of_name str returns the level associated with str.
| ||
| lexeme [BatLexing] | Lexing.lexeme lexbuf returns the string matched by
the regular expression.
| ||
| lexeme_char [BatLexing] | Lexing.lexeme_char lexbuf i returns character number i in
the matched string.
| ||
| lexeme_end [BatLexing] | Lexing.lexeme_end lexbuf returns the offset in the input stream
of the character following the last character of the matched
string.
| ||
| lexeme_end_p [BatLexing] |
Like
lexeme_end, but return a complete position instead
of an offset.
| ||
| lexeme_start [BatLexing] | Lexing.lexeme_start lexbuf returns the offset in the
input stream of the first character of the matched string.
| ||
| lexeme_start_p [BatLexing] |
Like
lexeme_start, but return a complete position instead
of an offset.
| ||
| lift [BatPathGen.StringType] |
Convert from UTF-8 string of primitive
string type.
| ||
| lift_char [BatPathGen.StringType] |
Convert Latin-1 character to
tchar.
| ||
| line_comment [BatGenlex.Languages.Make] | |||
| line_comment_start [BatGenlex.Languages.Definition] | |||
| lines_of [BatText] |
offer the lines of a UTF-8 encoded input as an enumeration
| ||
| lines_of [BatIO] |
Read an enumeration of LF or CRLF terminated strings.
| ||
| lines_of [BatFile] | 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.
| ||
| location [BatPrintexc.Slot] | location slot returns the location information of the slot,
if available, and None otherwise.
| ||
| lock [BatUnix] |
A lock used to synchronize internal operations.
| ||
| lock [BatRMutex] |
Lock the given mutex.
| ||
| lock [BatPervasives] |
A lock used to synchronize internal operations.
| ||
| lock [BatInnerPervasives] | |||
| lock [BatIO] |
A lock used to synchronize internal operations.
| ||
| lock [BatConcurrent.BaseLock] | |||
| lock [BatConcurrent.Lock] | |||
| lock_factory [BatIO] |
A factory used to create locks.
| ||
| lockf [BatUnix] | lockf fd cmd size puts a lock on a region of the file opened
as fd.
| ||
| log [BatLogger] | log logger level event_fun raises a log event if if the
specified level is currently enabled for the logger.
| ||
| log [BatLog.Make_lev] | |||
| log [BatLog.Easy] | log lev msg logs the message msg if the current logging
level is lev or lower.
| ||
| log [BatLog.Make] | print s logs the message s, returning unit.
| ||
| log [BatLog] | log s logs the message s, returning unit.
| ||
| log [BatFloat.Safe_float] |
Natural logarithm.
| ||
| log [BatFloat] |
Natural logarithm.
| ||
| log [BatComplex] |
Natural logarithm (in base
e).
| ||
| log10 [BatFloat.Safe_float] |
Base 10 logarithm.
| ||
| log10 [BatFloat] |
Base 10 logarithm.
| ||
| log10e [BatFloat] | log10 e
| ||
| log2e [BatFloat] | Math.log2 e
| ||
| log_enable [BatLogger] | log_enable logger level enables a log level for a logger.
| ||
| log_enabled [BatLogger] | log_enabled logger level returns true if the specified level is
currently enabled for the logger.
| ||
| log_level [BatLogger] | log_level logger returns the currently enabled level for a logger.
| ||
| log_name [BatLogger] | log_name logger returns the name of the logger.
| ||
| logand [BatNativeint] |
Bitwise logical and.
| ||
| logand [BatInt64] |
Bitwise logical and.
| ||
| logand [BatInt32] |
Bitwise logical and.
| ||
| logf [BatLog.Make_lev] | |||
| logf [BatLog.Easy] |
As
log, but instead of a string message, a printf format is
allowed with whatever arguments are appropriate.
| ||
| logf [BatLog.Make] |
As
Printf.printf, only the message is printed to the logging
output and prefixed with status information per the current flags and
the currently set prefix.
| ||
| logf [BatLog] |
As
Printf.printf, only the message is printed to the logging
output and prefixed with status information per the current flags and
the currently set prefix.
| ||
| lognot [BatNativeint] |
Bitwise logical negation
| ||
| lognot [BatInt64] |
Bitwise logical negation
| ||
| lognot [BatInt32] |
Bitwise logical negation
| ||
| logor [BatNativeint] |
Bitwise logical or.
| ||
| logor [BatInt64] |
Bitwise logical or.
| ||
| logor [BatInt32] |
Bitwise logical or.
| ||
| logxor [BatNativeint] |
Bitwise logical exclusive or.
| ||
| logxor [BatInt64] |
Bitwise logical exclusive or.
| ||
| logxor [BatInt32] |
Bitwise logical exclusive or.
| ||
| look [BatUTF8] | look s i
returns the Unicode character of the location i in the string s.
| ||
| lookahead [BatParserCo] | lookahead p behaves as maybe p but without consuming anything
| ||
| lookup [BatFingerTree.Generic] | lookup p t, when p is monotonic, returns the first element
of the sequence for which the measure of its predecessors in the
sequence (itself included) satisfies p.
| ||
| 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 [BatBytes] |
Return a copy of the argument, with all uppercase letters
translated to lowercase, including accented letters of the ISO
Latin-1 (8859-1) character set.
| ||
| lowercase_ascii [BatString] |
Return a copy of the argument, with all uppercase letters
translated to lowercase, using the US-ASCII character set.
| ||
| lowercase_ascii [BatChar] |
Convert the given character to its equivalent lowercase character,
using the US-ASCII character set.
| ||
| lowercase_ascii [BatBytes] |
Return a copy of the argument, with all uppercase letters
translated to lowercase, using the US-ASCII character set.
| ||
| lowercase_latin1 [BatCharParser] |
Recognizes one lower-case Latin-1 character, including
accentuated characters.
| ||
| lru_cache [BatCache] | |||
| lseek [BatUnix.LargeFile] | |||
| lseek [BatUnix] |
Set the current position for a file descriptor
| ||
| lstat [BatUnix.LargeFile] | |||
| lstat [BatUnix] |
Same as
Unix.stat, but in case the file is a symbolic link,
return the information for the link itself.
| ||
| lt_big_int [BatBig_int] | |||
| lt_num [BatNum] | |||
M | |||
| major [BatGc] |
Do a minor collection and finish the current major collection cycle.
| ||
| major_slice [BatGc] |
Do a minor collection and a slice of major collection.
| ||
| make [BatVect.RANDOMACCESS] | |||
| make [BatVect.Make] | make i c returns a vect of length i whose elements are all equal to
c; it is similar to Array.make
| ||
| make [BatVect] | make i c returns a vect of length i whose elements are all equal to
c; it is similar to Array.make
| ||
| make [BatTuple.Tuple5] | |||
| make [BatTuple.Tuple4] | |||
| make [BatTuple.Tuple3] | |||
| make [BatTuple.Tuple2] | |||
| make [BatText] | make i c returns a rope of length i consisting of c chars;
it is similar to String.make
| ||
| make [BatSubstring] | |||
| make [BatString.Cap] | |||
| make [BatString] | String.make n c returns a fresh string of length n,
filled with the character c.
| ||
| make [BatSeq] | make n e returns the sequence of length n where all elements
are e
| ||
| make [BatRandom.Incubator.Private_state_enums.State] |
Create a new state and initialize it with the given seed.
| ||
| make [BatRandom.State] |
Create a new state and initialize it with the given seed.
| ||
| make [BatRMutex] |
Create a new abstract lock based on Reentrant Mutexes.
| ||
| make [BatOptParse.OptParser] |
Creates a new option parser with the given options.
| ||
| make [BatMutex] |
Create a new abstract lock based on Mutexes.
| ||
| make [BatList] |
Similar to
String.make, make n x returns a
list containing n elements x.
| ||
| make [BatLazyList] |
Similar to
String.make, make n x returns a
list containing n elements x.
| ||
| make [BatEnum] |
This function creates a fully defined enumeration.
| ||
| make [BatDynArray] | make count returns an array with some memory already allocated so
up to count elements can be stored into it without resizing.
| ||
| make [BatConcurrent.Lock] | |||
| make [BatBytes] | make n c returns a new byte sequence of length n, filled with
the byte c.
| ||
| make [BatBounded.S] | |||
| make [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_float [BatArray.Cap] | Array.make_float n returns a fresh float array of length n,
with uninitialized data.
| ||
| make_float [BatArray] | Array.make_float n returns a fresh float array of length n,
with uninitialized data.
| ||
| make_formatter [BatFormat] | make_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 [BatQueue] | map f q applies function f to each element of the queue
and returns a new queue q' with the results returned by f.
| ||
| map [BatPervasives] |
Transformation loop on an enumeration, used to build an enumeration
from another enumeration.
| ||
| map [BatPathGen.PathType] |
Map a path through a function that operates on separate components.
| ||
| map [BatOption.Labels] | |||
| map [BatOption] | map f (Some x) returns Some (f x) and map f None returns None.
| ||
| map [BatMultiPMap] | map f 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 [BatBytes] | map f s applies function f in turn to all the bytes of s
(in increasing index order) and stores the resulting bytes in
a new sequence that is returned as the result.
| ||
| map [BatBounded.S] | map f x applies f to x.
| ||
| map [BatBigarray.Array3] | Array3.map f a applies function f to all the elements of a,
and builds a Bigarray.Array3.t with the results returned by f.
| ||
| map [BatBigarray.Array2] | Array2.map f a applies function f to all the elements of a,
and builds a Bigarray.Array2.t with the results returned by f.
| ||
| map [BatBigarray.Array1] | Array1.map f a applies function f to all the elements of a,
and builds a Bigarray.Array1.t with the results returned by f.
| ||
| map [BatBigarray.Genarray] | map f kind a applies function f to all the elements of a,
and builds a Bigarray.t of kind kind with the results
returned by f.
| ||
| map [BatArray.Cap.Labels] | |||
| map [BatArray.Cap] | |||
| map [BatArray.Labels] | |||
| map [BatArray] | Array.map f a applies function f to all the elements of a,
and builds an array with the results returned by f:
[| f a.(0); f a.(1); ...; f a.(Array.length a - 1) |].
| ||
| map1 [BatTuple.Tuple5] | |||
| map1 [BatTuple.Tuple4] | |||
| map1 [BatTuple.Tuple3] | |||
| map1 [BatTuple.Tuple2] | map1 f (x,y) returns (f x,y)
| ||
| map2 [BatTuple.Tuple5] | |||
| map2 [BatTuple.Tuple4] | |||
| map2 [BatTuple.Tuple3] | |||
| map2 [BatTuple.Tuple2] | map2 f (x,y) returns (x,f y)
| ||
| map2 [BatStream.StreamLabels] | |||
| map2 [BatStream] | map2 f streama streamb applies f in turn to elements of corresponding
positions from streama and streamb.
| ||
| map2 [BatSeq] | map2 f s1 s2 returns a sequence of elements, resulting from combininig
elements of s1 and s2 at the same index using f.
| ||
| map2 [BatList.Labels] | |||
| map2 [BatList] | List.map2 f [a0; a1; ...; an] [b0; b1; ...; bn] is
[f a0 b0; f a1 b1; ...; f an bn].
| ||
| map2 [BatLazyList.Labels] | |||
| map2 [BatLazyList] | map2 f [^ a0; a1; ...^] [^ b0; b1; ... ^] is [^ f a0 b0; f a1
b1; ... ^].
| ||
| map2 [BatBounded.S] | map f x y applies f to x and y.
| ||
| map2 [BatArray] |
As
Array.map but on two arrays.
| ||
| map2_exn [BatBounded.S] | map f x y applies f to x and y.
| ||
| map3 [BatTuple.Tuple5] | |||
| map3 [BatTuple.Tuple4] | |||
| map3 [BatTuple.Tuple3] | |||
| map4 [BatTuple.Tuple5] | |||
| map4 [BatTuple.Tuple4] | |||
| map5 [BatTuple.Tuple5] | |||
| map_comp [BatOrd] | |||
| map_default [BatResult] | map_default d f r evaluates to d if r is Bad else f x
when r is Ok x
| ||
| map_default [BatOption.Labels] | |||
| map_default [BatOption] | map_default f x (Some v) returns f v and map_default f x None
returns x.
| ||
| map_default_delayed [BatOption] |
Like
BatOption.map_default, but the default value is passed as a thunk that
is only computed if needed.
| ||
| map_eq [BatOrd] | |||
| map_exn [BatBounded.S] | map_exn f x applies f to x.
| ||
| map_ext [BatPathGen.PathType] | map_ext fu path returns path but with the name with extension given by fu (BatPathGen.PathType.ext path).
| ||
| map_file [BatBigarray.Array3] |
Memory mapping of a file as a three-dimensional big array.
| ||
| map_file [BatBigarray.Array2] |
Memory mapping of a file as a two-dimensional big array.
| ||
| map_file [BatBigarray.Array1] |
Memory mapping of a file as a one-dimensional big array.
| ||
| map_file [BatBigarray.Genarray] |
Memory mapping of a file as a big array.
| ||
| map_inplace [BatHashtbl.Cap.Labels] | |||
| map_inplace [BatHashtbl.Cap] | |||
| map_inplace [BatHashtbl.S.Labels] | |||
| map_inplace [BatHashtbl.S] | |||
| map_inplace [BatHashtbl.Labels] | |||
| map_inplace [BatHashtbl] | map_inplace f x replace all values currently bound in x
by f applied to each value.
| ||
| map_list [BatRefList] |
Apply a function to all elements
and return the list constructed with
the function returned values
| ||
| map_name [BatPathGen.PathType] | |||
| map_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 [BatString.Cap] | |||
| mapi [BatString] | String.mapi f s calls f with each character of s and its
index (in increasing index order) and stores the results in a new
string that is returned.
| ||
| mapi [BatSeq] | mapi f s lazily maps elements of s into a new sequence,
using f.
| ||
| mapi [BatMultiPMap] |
Same as
map, but the function receives as arguments both the
key and the associated value for each binding of the map.
| ||
| mapi [BatMultiMap] |
Same as
map, but the function receives as arguments both the
key and the associated value for each binding of the map.
| ||
| mapi [BatMap.PMap] |
Same as
map, but the function receives as arguments both the
key and the associated value for each binding of the map.
| ||
| mapi [BatMap.S.Labels] | |||
| mapi [BatMap.S] |
Same as
Map.S.map, but the function receives as arguments both the
key and the associated value for each binding of the map.
| ||
| mapi [BatMap] |
Same as
map, but the function receives as arguments both the
key and the associated value for each binding of the map.
| ||
| mapi [BatList.Labels] | |||
| mapi [BatList] | mapi f l will build the list containing
(f 0 a0); (f 1 a1) ... (f n an) where a0..an are the elements of
the list l.
| ||
| mapi [BatLazyList.Labels] | |||
| mapi [BatLazyList] |
Lazy map, with indices
| ||
| mapi [BatIMap] |
Create a new map by computing new values based on key and value
of the existing bindings.
| ||
| mapi [BatEnum.Labels] | |||
| mapi [BatEnum] | mapi is similar to map except that f is passed one extra argument
which is the index of the element in the enumeration, starting from 0 :
mapi f e returns an enumeration over (f 0 a0, f 1 a1, ...) where
a0,a1... are the elements of e.
| ||
| mapi [BatDynArray] | mapi f darr applies the function f to every element of darr
and creates a dynamic array from the results - similar to List.mapi or
Array.mapi.
| ||
| mapi [BatDeque] | 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 [BatBytes] | mapi f s calls f with each character of s and its
index (in increasing index order) and stores the resulting bytes
in a new sequence that is returned as the result.
| ||
| mapi [BatBigarray.Array1] |
Same as
Bigarray.Array1.map, but the
function is applied to the index of the element as the first argument,
and the element itself as the second argument.
| ||
| mapi [BatBigarray.Genarray] |
Same as
BatBigarray.Genarray.map, but the function is applied to the index of the
coordinates as the first argument, and the element itself as the
second argument.
| ||
| mapi [BatArray.Cap.Labels] | |||
| mapi [BatArray.Cap] | |||
| mapi [BatArray.Labels] | |||
| mapi [BatArray] |
Same as
Array.map, but the
function is applied to the index of the element as first argument,
and the element itself as second argument.
| ||
| mapij [BatBigarray.Array2] |
Same as
Bigarray.Array2.map, but the
function is applied to the index of the element as the first two
arguments, and the element itself as the third argument.
| ||
| mapijk [BatBigarray.Array3] |
Same as
Bigarray.Array3.map, but the
function is applied to the index of the element as the first three
arguments, and the element itself as the fourth argument.
| ||
| mapn [BatTuple.Tuple5] |
Like
BatTuple.Tuple5.map but specialized for tuples with elements of the
same type.
| ||
| mapn [BatTuple.Tuple4] |
Like
BatTuple.Tuple4.map but specialized for tuples with elements of the
same type.
| ||
| mapn [BatTuple.Tuple3] |
Like
BatTuple.Tuple3.map but specialized for tuples with elements of the
same type.
| ||
| mapn [BatTuple.Tuple2] |
Like
BatTuple.Tuple2.map but specialized for tuples with elements of the
same type.
| ||
| max [BatSeq.Exceptionless] | |||
| max [BatSeq] | max s returns the largest value in s as judged by
Pervasives.compare
| ||
| max [BatOrd] | max ord will choose the biggest element according to ord.
| ||
| max [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.
| ||
| mem_cmp [BatList] |
Same as
List.mem, but the comparator function is explicitely
provided.
| ||
| memq [BatVect.Make] |
Same as
Vect.mem but uses physical equality instead of
structural equality to compare vect elements.
| ||
| memq [BatVect] |
Same as
Vect.mem but uses physical equality instead of
structural equality to compare vect elements.
| ||
| memq [BatList] |
Same as
List.mem, but uses physical equality instead of structural
equality to compare list elements.
| ||
| memq [BatLazyList] |
As
mem, but with physical equality
| ||
| memq [BatArray.Cap] | |||
| memq [BatArray] |
Same as
Array.mem but uses physical equality instead of
structural equality to compare array elements.
| ||
| merge [BatStream.StreamLabels] | |||
| merge [BatStream] | merge test (streama, streamb) merge the elements from streama and
streamb into a single stream.
| ||
| merge [BatMap.PMap] | merge f m1 m2 computes a map whose keys is a subset of keys of m1
and of m2.
| ||
| merge [BatMap.S] | merge f m1 m2 computes a map whose keys is a subset of keys of m1
and of m2.
| ||
| merge [BatMap] | merge f m1 m2 computes a map whose keys is a subset of keys of m1
and of m2.
| ||
| merge [BatList.Labels] | |||
| merge [BatList] |
Merge two lists:
Assuming that
l1 and l2 are sorted according to the
comparison function cmp, merge cmp l1 l2 will return a
sorted list containting all the elements of l1 and l2.
| ||
| merge [BatIMap] | |||
| merge [BatHeap.H] |
See
BatHeap.merge.
| ||
| merge [BatHeap] |
Merge two heaps.
| ||
| merge [BatEnum] | merge test a b merge the elements from a and b into a single
enumeration.
| ||
| merge_unsafe [BatMap.PMap] |
Same as merge, but assumes the comparison function of both maps
are equal.
| ||
| mid [BatInt] |
Midpoint function;
mid a b returns floor((a+b)/2), but done
correctly to compensate for numeric overflows.
| ||
| min [BatSeq.Exceptionless] | |||
| min [BatSeq] | min s returns the smallest value in s as judged by
Pervasives.compare
| ||
| min [BatOrd] | min ord will choose the smallest element, according to ord.
| ||
| min [BatList] | min l returns the smallest value in l as judged by
Pervasives.compare
| ||
| min [BatInt] |
The minimum of two integers.
| ||
| min [BatFloat] | |||
| min [BatArray] | min a returns the smallest value in a as judged by
Pervasives.compare
| ||
| min_big_int [BatBig_int] |
Return the smaller of its two arguments.
| ||
| min_binding [BatMap.PMap] |
returns the binding with the smallest key
| ||
| min_binding [BatMap.S] |
return the (
key,value) pair with the smallest key
| ||
| min_binding [BatMap] |
returns the binding with the smallest key
| ||
| min_comp [BatOrd] | |||
| min_elt [BatSet.PSet] |
returns the smallest element of the set.
| ||
| min_elt [BatSet.S.Exceptionless] | |||
| min_elt [BatSet.S] |
Return the smallest element of the given set
(with respect to the
Ord.compare ordering).
| ||
| min_elt [BatSet] |
returns the smallest element of the set.
| ||
| min_elt [BatISet] |
Returns the minimum element in the set
| ||
| min_int [BatNativeint] |
The greatest representable native integer,
either -231 on a 32-bit platform,
or -263 on a 64-bit platform.
| ||
| min_int [BatInt64] |
The smallest representable 64-bit integer, -263.
| ||
| min_int [BatInt32] |
The smallest representable 32-bit integer, -231.
| ||
| min_max [BatList] | min_max l returns the pair (smallest, largest) from l as judged by
Pervasives.compare (by default).
| ||
| min_num [BatNumber.Bounded] | |||
| min_num [BatNum] | |||
| min_num [BatNativeint] | |||
| min_num [BatInt32] | |||
| min_num [BatInt.Safe_int] |
The smallest representable integer, -230 or 262.
| ||
| min_num [BatInt] |
The smallest representable integer, -230 or -262.
| ||
| min_num [BatFloat.Safe_float] | |||
| min_num [BatFloat] | |||
| min_num [BatBool] | |||
| min_ord [BatOrd] | |||
| minor [BatGc] |
Trigger a minor collection.
| ||
| minus_big_int [BatBig_int] |
Unary negation.
| ||
| minus_num [BatNum] | |||
| minus_one [BatNativeint] |
The native integer -1.
| ||
| minus_one [BatInt64] |
The 64-bit integer -1.
| ||
| minus_one [BatInt32] |
The 32-bit integer -1.
| ||
| minus_one [BatInt.Safe_int] |
The integer
-1.
| ||
| minus_one [BatInt] |
The integer
-1.
| ||
| mkdir [BatUnix] |
Create a directory with the given permissions.
| ||
| mkfifo [BatUnix] |
Create a named pipe with the given permissions.
| ||
| mktime [BatUnix] |
Convert a date and time, specified by the
tm argument, into
a time in seconds, as returned by Unix.time.
| ||
| mod_big_int [BatBig_int] |
Euclidean modulus of two big integers.
| ||
| mod_num [BatNum] | |||
| modf [BatFloat.Safe_float] | modf f returns the pair of the fractional and integral
part of f.
| ||
| modf [BatFloat] | modf f returns the pair of the fractional and integral
part of f.
| ||
| modify [BatVect.Make] | modify v n f is equivalent to set v n (f (get v n)), but
more efficient.
| ||
| modify [BatVect] | modify v n f is equivalent to set v n (f (get v n)), but
more efficient.
| ||
| modify [BatMultiPMap] | modify x f m replaces the binding for x with f applied to
these values.
| ||
| modify [BatMultiMap] | modify x f m replaces the binding for x with f applied to
these values.
| ||
| modify [BatMap.PMap] | modify k f m replaces the previous binding for k with f
applied to that value.
| ||
| modify [BatMap.S] | modify k f m replaces the previous binding for k with f applied to
that value.
| ||
| modify [BatMap] | modify k f m replaces the previous binding for k with f
applied to that value.
| ||
| modify [BatList] | modify a f l returns the same list as l but with value associated
to key a replaced with f a.
| ||
| modify [BatIMap] | modify x f t replaces the y that is bound to x in t by f y.
| ||
| modify [BatHashtbl.Cap.Exceptionless] | |||
| modify [BatHashtbl.S.Labels] | |||
| modify [BatHashtbl.S.Exceptionless] | |||
| modify [BatHashtbl.S] | |||
| modify [BatHashtbl.Labels] | |||
| modify [BatHashtbl.Exceptionless] | |||
| modify [BatHashtbl] | Hashtbl.modify k f tbl replaces the first binding for k in tbl
with f applied to that value.
| ||
| modify [BatBigarray.Array3] | modify f a changes each element x in a to f x
in-place.
| ||
| modify [BatBigarray.Array2] | modify f a changes each element x in a to f x
in-place.
| ||
| modify [BatBigarray.Array1] | modify f a changes each element x in a to f x
in-place.
| ||
| modify [BatBigarray.Genarray] | modify f a changes each element x in a to f x
in-place.
| ||
| modify [BatArray.Cap.Labels] | |||
| modify [BatArray.Cap] | |||
| modify [BatArray.Labels] | |||
| modify [BatArray] | modify f a replaces every element x of a with f x.
| ||
| modify_at [BatList] | modify_at n f l returns the same list as l
but with nth-value a replaced with f a.
| ||
| modify_def [BatMultiPMap] | modify_def dfl x f m performs as modify x f m but it adds
f dfl in m instead of raising Not_found if x was unbound.
| ||
| modify_def [BatMultiMap] | modify_def dfl x f m performs as modify x f m but it adds
f dfl in m instead of raising Not_found if x was unbound.
| ||
| modify_def [BatMap.PMap] | modify_def v0 k f m replaces the previous binding for k
with f applied to that value.
| ||
| modify_def [BatMap.S] | modify_def v0 k f m replaces the previous binding for k
with f applied to that value.
| ||
| modify_def [BatMap] | modify_def v0 k f m replaces the previous binding for k
with f applied to that value.
| ||
| modify_def [BatList] | modify_def dfl a f l performs as modify a f l except that it
add an association from a to f dfl instead of raising Not_found.
| ||
| modify_def [BatIMap] | modify_def dft x f t does the same as modify x f t but binds
x to f dft if x was not bound.
| ||
| modify_def [BatHashtbl.S.Labels] | |||
| modify_def [BatHashtbl.S] | |||
| modify_def [BatHashtbl.Labels] | |||
| modify_def [BatHashtbl] | Hashtbl.modify_def v k f tbl does the same as Hashtbl.modify k f tbl
but f v is inserted in tbl if k was unbound.
| ||
| modify_opt [BatMultiPMap] | modify_opt x f m allows to modify the bindings for k in m
or absence thereof.
| ||
| modify_opt [BatMultiMap] | modify_opt x f m allows to modify the bindings for k in m
or absence thereof.
| ||
| modify_opt [BatMap.PMap] | modify_opt k f m allow to modify the binding for k in m
or absence thereof.
| ||
| modify_opt [BatMap.S] | modify_opt k f m allows to modify the binding for k in m
or absence thereof.
| ||
| modify_opt [BatMap] | modify_opt k f m allow to modify the binding for k in m
or absence thereof.
| ||
| modify_opt [BatList] | modify_opt a f l allows to modify the binding for a in l
or absence thereof.
| ||
| modify_opt [BatIMap] | modify_opt x f t allows to modify the binding for x in t
or absence thereof.
| ||
| modify_opt [BatHashtbl.S.Labels] | |||
| modify_opt [BatHashtbl.S] | |||
| modify_opt [BatHashtbl.Labels] | |||
| modify_opt [BatHashtbl] | Hashtbl.modify_opt k f tbl allows to remove, modify or add a binding for
k in tbl.
| ||
| modify_opt_at [BatList] | modify_at_opt n f l returns the same list as l but with
nth-value a removed if f a is None, and replaced by v if
it is Some v.
| ||
| modifyi [BatBigarray.Array1] |
Same as
Bigarray.Array1.modify, but the function is applied
to the index of the element as the first argument, and the
element itself as the second argument.
| ||
| modifyi [BatBigarray.Genarray] |
Same as
BatBigarray.Genarray.modify, but the function is applied to the index of
the coordinates as the first argument, and the element itself
as the second argument.
| ||
| modifyi [BatArray.Cap.Labels] | |||
| modifyi [BatArray.Cap] | |||
| modifyi [BatArray.Labels] | |||
| modifyi [BatArray] |
Same as
BatArray.modify, but the function is applied to the index of
the element as the first argument, and the element itself as
the second argument.
| ||
| modifyij [BatBigarray.Array2] |
Same as
Bigarray.Array2.modify, but the function is applied
to the index of the element as the first two arguments, and the
element itself as the third argument.
| ||
| modifyijk [BatBigarray.Array3] |
Same as
Bigarray.Array3.modify, but the function is applied
to the index of the coordinates as the first three arguments, and the
element itself as the fourth argument.
| ||
| modulo [BatNumber.Numeric] | |||
| modulo [BatNum] | |||
| modulo [BatNativeint] | |||
| modulo [BatInt64] | |||
| modulo [BatInt32] | |||
| modulo [BatInt.Safe_int] | modulo a b computes the remainder of the integer
division of a by b.
| ||
| modulo [BatInt] | modulo a b computes the remainder of the integer
division of a by b.
| ||
| modulo [BatFloat.Safe_float] | |||
| modulo [BatFloat] | |||
| modulo [BatComplex] | |||
| modulo [BatBool] | |||
| modulo [BatBig_int] | |||
| move [BatUTF8] | move s i n
returns n-th Unicode character after i if n >= 0,
n-th Unicode character before i if n < 0.
| ||
| mul [BatNumber.Numeric] | |||
| mul [BatNum] | |||
| mul [BatNativeint] |
Multiplication.
| ||
| mul [BatInt64] |
Multiplication.
| ||
| mul [BatInt32] |
Multiplication.
| ||
| mul [BatInt.Safe_int] |
Multiplication.
| ||
| mul [BatInt] |
Multiplication.
| ||
| mul [BatFloat.Safe_float] | |||
| mul [BatFloat] | |||
| mul [BatComplex] |
Multiplication
| ||
| mul [BatBool] | |||
| mul [BatBig_int] | |||
| mult_big_int [BatBig_int] |
Multiplication of two big integers.
| ||
| mult_int_big_int [BatBig_int] |
Multiplication of a big integer by a small integer
| ||
| mult_num [BatNum] | |||
| multi_choice [BatRandom] | multi_choice n e returns an enumeration of n
randomly-chosen elements of e.
| ||
| multiline_comment [BatGenlex.Languages.Make] | |||
| must [BatParserCo] |
Prevent backtracking.
| ||
N | |||
| n_cartesian_product [BatList] |
Given n lists, return the n-way cartesian product of
these lists.
| ||
| name [BatPathGen.PathType] |
Returns name of the object the pathname points to, i.e.
| ||
| name [BatGlobal] |
Retrieve the name of a global.
| ||
| name_core [BatPathGen.PathType] |
Returns part of the name to the left of rightmost dot.
| ||
| name_of_input [BatScanf.Scanning] | Scanning.file_name_of_input ib returns the name of the character source
for the scanning buffer ib.
| ||
| name_of_level [BatLogger] | name_of_level level returns the name of the specified level.
| ||
| nan [BatFloat.Safe_float] |
A special floating-point value denoting the result of an
undefined operation such as
0.0 /. 0.0.
| ||
| nan [BatFloat] |
A special floating-point value denoting the result of an
undefined operation such as
0.0 /. 0.0.
| ||
| narrow [BatOo.Internal] | |||
| nat_of_num [BatNum] |
Coercions between numerical types
| ||
| nativeint [BatRandom.Incubator.Private_state_enums.State] | |||
| nativeint [BatRandom.State] | |||
| nativeint [BatRandom] | Random.nativeint bound returns a random integer between 0 (inclusive)
and bound (exclusive).
| ||
| nativeint [BatBigarray] |
See
Bigarray.char.
| ||
| nativeint_of_big_int [BatBig_int] |
Convert a big integer to a native integer.
| ||
| neg [BatPervasives] | neg p returns a new predicate that is the negation of the given
predicate.
| ||
| neg [BatNumber.Numeric] | |||
| neg [BatNum] | |||
| neg [BatNativeint] |
Unary negation.
| ||
| neg [BatInt64] |
Unary negation.
| ||
| neg [BatInt32] |
Unary negation.
| ||
| neg [BatInt.Safe_int] |
Unary negation.
| ||
| neg [BatInt] |
Unary negation.
| ||
| neg [BatInnerPervasives] | |||
| neg [BatFloat.Safe_float] | |||
| neg [BatFloat] |
Returns the negation of the input, i.e.
| ||
| neg [BatComplex] |
Unary negation.
| ||
| neg [BatBool] | |||
| neg [BatBig_int] | |||
| neg2 [BatPervasives] |
as
neg but for predicates with two arguments
| ||
| neg2 [BatInnerPervasives] | |||
| neg_infinity [BatFloat.Safe_float] |
Negative infinity.
| ||
| neg_infinity [BatFloat] |
Negative infinity.
| ||
| nested_comments [BatGenlex.Languages.Definition] | |||
| new_line [BatLexing] |
Update the
lex_curr_p field of the lexbuf to reflect the start
of a new line.
| ||
| new_method [BatOo.Internal] | |||
| new_methods_variables [BatOo.Internal] | |||
| new_variable [BatOo.Internal] | |||
| newline [BatCharParser] |
Recognizes a newline
| ||
| next [BatUTF8] | next s i
returns the position of the head of the Unicode character
located immediately after i.
| ||
| next [BatStream] |
Return the first element of the stream and remove it from the
stream.
| ||
| next [BatLazyList] |
Compute and return the next value of the list
| ||
| next [BatDllist] |
Given a node, get the next element in the list after the node.
| ||
| next_set_bit [BatBitSet] | next_set_bit s n returns Some m when m is the next set
element with index greater than or equal n, or None if no such
element exists (i.e.
| ||
| nice [BatUnix] |
Change the process priority.
| ||
| nil [BatSeq] | nil = fun () -> Nil
| ||
| nil [BatLazyList] |
The empty list.
| ||
| nolock [BatConcurrent] |
A lock which does nothing.
| ||
| none_of [BatParserCo] |
Accept any value not in a list
Faster and more convenient than combining
satisfy and either.
| ||
| none_of [BatCharParser] |
Accept any value not in a list
As
ParserCo.none_of, just with improved error message.
| ||
| norm [BatComplex] |
Norm: given
x + i.y, returns sqrt(x^2 + y^2).
| ||
| norm2 [BatComplex] |
Norm squared: given
x + i.y, returns x^2 + y^2.
| ||
| normalize [BatPathGen.PathType] |
Deprecated name for
normalize_in_tree
| ||
| normalize_filepath [BatPathGen.PathType] |
Consumes single dots where possible, e.g.:
| ||
| normalize_in_graph [BatPathGen.PathType] |
Another name for
normalize_filepath.
| ||
| normalize_in_tree [BatPathGen.PathType] |
Consumes single dots and applies double dots where possible, e.g.:
| ||
| not [BatBool] |
The boolean negation.
| ||
| not_char [BatCharParser] |
Accept any value not a given char
As
none_of.
| ||
| npeek [BatStream] | npeek n returns the list of the n first elements of
the stream, or all its remaining elements if less than n
elements are available.
| ||
| npop [BatRefList] |
Removes and returns the n first elements or
raises
Empty_list if the ref list does not
contain enough elements
| ||
| nread [BatInnerIO] | nread i n reads a string of size up to n from an input.
| ||
| nread [BatIO] | nread i n reads a string of size up to n from an input.
| ||
| nreplace [BatString.Cap] | |||
| nreplace [BatString] | nreplace ~str ~sub ~by returns a string obtained by iteratively
replacing each occurrence of sub by by in str, from right to left.
| ||
| nsplit [BatText] | nsplit s sep splits the rope s into a list of ropes
which are separated by sep.
| ||
| nsplit [BatString.Cap] | |||
| nsplit [BatString] | nsplit s sep splits the string s into a list of strings
which are separated by sep (excluded).
| ||
| nsplit [BatList] | nsplit, applied to a predicate p and a list xs, returns a
list of lists.
| ||
| ntake [BatList] | ntake n l cuts l into lists of size at most n.
| ||
| nth [BatUTF8] | nth s n returns the position of the n-th Unicode character.
| ||
| nth [BatList] |
Obsolete.
| ||
| nth [BatLazyList] |
Obsolete.
| ||
| nth [BatBuffer] |
get the n-th character of the buffer.
| ||
| nth_dim [BatBigarray.Genarray] | Genarray.nth_dim a n returns the n-th dimension of the
big array a.
| ||
| null_formatter [BatLogger] | null_formatter is a formatter that does not output any
events, but simply discards them.
| ||
| num_bits_big_int [BatBig_int] |
Return the number of significant bits in the absolute
value of the given big integer.
| ||
| num_digits_big_int [BatBig_int] |
Return the number of machine words used to store the
given big integer.
| ||
| num_dims [BatBigarray.Genarray] |
Return the number of dimensions of the given big array.
| ||
| num_of_big_int [BatNum] | |||
| num_of_int [BatNum] | |||
| num_of_nat [BatNum] | |||
| num_of_ratio [BatNum] | |||
| num_of_string [BatNum] | |||
| number [BatGenlex.Languages.Make] |
Parse either an integer or a floating-point number.
| ||
| numeric_compare [BatString] |
Compare two strings, sorting "abc32def" before "abc210abc".
| ||
| nwrite [BatInnerIO] |
Write a string to an output.
| ||
| nwrite [BatIO] |
Write a string to an output.
| ||
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 [BatSet.PSet] |
builds a set from the given array, using the default comparison
function
| ||
| of_array [BatSet.S] |
builds a set from the given array.
| ||
| of_array [BatSet] |
builds a set from the given array, using the default comparison
function
| ||
| of_array [BatLazyList] |
Eager conversion from array
| ||
| of_array [BatDynArray] | of_array arr returns an array with the elements of arr in it
in order.
| ||
| of_array [BatBigarray.Array3] |
Build a three-dimensional big array initialized from the
given array of arrays of arrays.
| ||
| of_array [BatBigarray.Array2] |
Build a two-dimensional big array initialized from the
given array of arrays.
| ||
| of_array [BatBigarray.Array1] |
Build a one-dimensional big array initialized from the
given array.
| ||
| of_array [BatArray.Cap] |
Adopt a regular array as a capability array, allowing
to decrease capabilities if necessary.
| ||
| of_backwards [BatVect.RANDOMACCESS] | |||
| of_backwards [BatVect.Make] |
Build a vector from an enumeration, from last to first.
| ||
| of_backwards [BatVect] |
Build a vector from an enumeration, from last to first.
| ||
| of_backwards [BatString.Cap] | |||
| of_backwards [BatString] |
Build a string from an enumeration, starting with last character, ending with first.
| ||
| of_backwards [BatRefList] |
Creates a ref list from an enumeration, going from last to first
| ||
| of_backwards [BatList] |
Build a list from an enumeration.
| ||
| of_backwards [BatFingerTree.S] | of_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_bytes [BatStream] |
Return the stream of the characters of the bytes parameter.
| ||
| of_channel [BatStream] |
Return the stream of the characters read from the input channel.
| ||
| of_char [BatUChar] | of_char c returns the Unicode character of the Latin-1 character c
| ||
| of_char [BatText] | of_char c returns a rope containing exactly Latin-1 character c.
| ||
| of_char [BatString.Cap] | |||
| of_char [BatString] |
Returns a string containing one given character.
| ||
| of_container [BatVect.Make] | of_container s returns a vect corresponding to the container s.
| ||
| of_digit [BatChar] |
Return the character representing a given digit.
| ||
| of_enum [BatVect.RANDOMACCESS] | |||
| of_enum [BatVect.Make] |
Build a vector from an enumeration.
| ||
| of_enum [BatVect] |
Build a vector from an enumeration.
| ||
| of_enum [BatTuple.Tuple5] | |||
| of_enum [BatTuple.Tuple4] | |||
| of_enum [BatTuple.Tuple3] | |||
| of_enum [BatTuple.Tuple2] | |||
| of_enum [BatText] |
converts the enumeration into a rope
| ||
| of_enum [BatString.Cap] | |||
| of_enum [BatString] |
Creates a string from a character enumeration.
| ||
| of_enum [BatStream] |
Convert an enumeration to a stream.
| ||
| of_enum [BatStack] | of_enum e returns a new stack containing all the elements of
e.
| ||
| of_enum [BatSet.PSet] | |||
| of_enum [BatSet.S] | |||
| of_enum [BatSet] | |||
| of_enum [BatRefList] |
Creates a ref list from an enumeration
| ||
| of_enum [BatQueue] | of_enum e returns a new queue containing all the elements of e.
| ||
| of_enum [BatParserCo.Source] | |||
| of_enum [BatOption] | of_enum e consumes the first element of e, if it exists, and
returns Some e.
| ||
| of_enum [BatMultiPMap] |
creates a map from an enumeration, using the specified function
for key comparison or
compare by default.
| ||
| of_enum [BatMultiMap] |
creates a map from an enumeration, using the specified function
for key comparison or
compare by default.
| ||
| of_enum [BatMap.PMap] |
creates a map from an enumeration, using the specified function
for key comparison or
compare by default.
| ||
| of_enum [BatMap.S] |
Create a map from a (key, value) enumeration.
| ||
| of_enum [BatMap] |
Creates a map from an enumeration
| ||
| of_enum [BatList] |
Build a list from an enumeration.
| ||
| of_enum [BatLazyList] |
Lazy conversion from enum.
| ||
| of_enum [BatISet] | |||
| of_enum [BatIMap] | of_enum e returns the set of given ranges
| ||
| of_enum [BatHeap.H] |
See
BatHeap.of_enum.
| ||
| of_enum [BatHeap] |
Build a heap from an enumeration.
| ||
| of_enum [BatHashtbl.Cap] | |||
| of_enum [BatHashtbl.S] | |||
| of_enum [BatHashtbl] |
Create a hashtable from a (key,value) enumeration.
| ||
| of_enum [BatFingerTree.S] | of_enum e build the sequence containing the elements of e
in the same order.
| ||
| of_enum [BatEnum.Enumerable] |
Build a data structure from an enumeration
| ||
| of_enum [BatEnum] |
identity : added for consistency with the other data structures
| ||
| of_enum [BatDynArray] | of_enum e returns an array that holds, in order, the elements of e.
| ||
| of_enum [BatDllist] |
Create a dllist from an enum.
| ||
| of_enum [BatDeque] | of_enum e is a deque representation of the elements of e.
| ||
| of_enum [BatBuffer] |
Creates a buffer from a character enumeration.
| ||
| of_enum [BatBitSet] | of_enum ~cap e builds a bitset of capacity cap an enumeration
of ints e.
| ||
| of_enum [BatBigarray.Array1] | Array1.of_enum kind layout enum returns a new one-dimensional
big array of kind kind and layout layout, with elements taken
from the enumeration enum in order.
| ||
| of_enum [BatArray.Cap] | |||
| of_enum [BatArray] |
Build an array from an enumeration.
| ||
| of_enum_cmp [BatSet.PSet] | |||
| of_float [BatString.Cap] | |||
| of_float [BatString] |
Returns the string representation of an float.
| ||
| of_float [BatNumber.Numeric] | |||
| of_float [BatNum] | |||
| of_float [BatNativeint] |
Convert the given floating-point number to a native integer,
discarding the fractional part (truncate towards 0).
| ||
| of_float [BatInt64] |
Convert the given floating-point number to a 64-bit integer,
discarding the fractional part (truncate towards 0).
| ||
| of_float [BatInt32] |
Convert the given floating-point number to a 32-bit integer,
discarding the fractional part (truncate towards 0).
| ||
| of_float [BatInt.Safe_int] |
Convert the given floating-point number to integer,
discarding the fractional part (truncate towards 0).
| ||
| of_float [BatInt] |
Convert the given floating-point number to integer integer,
discarding the fractional part (truncate towards 0).
| ||
| of_float [BatFloat.Safe_float] | |||
| of_float [BatFloat] | |||
| of_float [BatComplex] | Complex.of_float x returns the complex number x+0i
| ||
| of_float [BatBool] | 0., nan +infinity and -infiity are false.
| ||
| of_float [BatBig_int] |
rounds to the nearest integer
| ||
| of_float_string [BatNum] |
Convert a simple floating point literal to a num.
| ||
| of_fun [BatStream] | Stream.of_fun f returns a stream built from the function f.
| ||
| of_input [BatSubstring] | |||
| of_input [BatStream] |
Convert an
input to a stream.
| ||
| of_int [BatUChar] |
Alias of
chr
| ||
| of_int [BatString.Cap] | |||
| of_int [BatString] |
Returns the string representation of an int.
| ||
| of_int [BatNumber.Numeric] | |||
| of_int [BatNum] | |||
| of_int [BatNativeint] |
Convert the given integer (type
int) to a native integer
(type nativeint).
| ||
| of_int [BatInt64] |
Convert the given integer (type
int) to a 64-bit integer
(type int64).
| ||
| of_int [BatInt32] |
Convert the given integer (type
int) to a 32-bit integer
(type int32).
| ||
| of_int [BatInt.Safe_int] | |||
| of_int [BatInt] | |||
| of_int [BatFloat.Safe_float] | |||
| of_int [BatFloat] | |||
| of_int [BatComplex] | |||
| of_int [BatBool] |
anything but
0 is true
| ||
| of_int [BatBig_int] | |||
| of_int32 [BatNativeint] |
Convert the given 32-bit integer (type
int32)
to a native integer.
| ||
| of_int32 [BatInt64] |
Convert the given 32-bit integer (type
int32)
to a 64-bit integer (type int64).
| ||
| of_int64 [BatNativeint] |
Convert the given 64-bit integer (type
int64)
to a native integer.
| ||
| of_int64 [BatInt32] |
Convert the given 64-bit integer (type
int64) to a
32-bit integer (type int32).
| ||
| of_latin1 [BatText] |
Constructs a unicode rope from a latin-1 string.
| ||
| of_list [BatVect.Make] | |||
| of_list [BatVect] | |||
| of_list [BatString.Cap] | |||
| of_list [BatString] |
Converts a list of characters to a string.
| ||
| of_list [BatStream] |
Return the stream holding the elements of the list in the same
order.
| ||
| of_list [BatSplay.Map] | |||
| of_list [BatSet.PSet] |
builds a set from the given list, using the default comparison
function
| ||
| of_list [BatSet.S] |
builds a set from the given list.
| ||
| of_list [BatSet] |
builds a set from the given list, using the default comparison
function
| ||
| of_list [BatSeq] |
Convenience function to build a seq from a list.
| ||
| of_list [BatRefList] |
Creates a ref list from a list - O(1)
| ||
| of_list [BatLazyList] |
Lazy conversion from lists
| ||
| of_list [BatISet] |
Build a ISet.t out of a list or enum of ranges
| ||
| of_list [BatHeap.H] |
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 [BatBytes] |
Return a new byte sequence that contains the same bytes as the
given string.
| ||
| of_string [BatBool] |
Convert the given string to a boolean.
| ||
| of_string [BatBig_int] | |||
| of_table [BatHashtbl.Cap] |
Adopt a regular hashtable as a capability hashtble, allowing
to decrease capabilities if necessary.
| ||
| of_uchar [BatText] | of_uchar c returns a rope containing exactly character c.
| ||
| oget_exn [BatRef] |
Get a value from an option ref;
| ||
| ok [BatPervasives] | f x |> ok unwraps the Ok result of f x and returns it, or
throws the exception contained if Bad is returned.
| ||
| ok [BatInnerPervasives] | |||
| on_close_out [BatInnerIO] |
Register a function to be triggered just before an output is closed.
| ||
| on_output [BatStream] |
Convert an
output to a stream.
| ||
| one [BatNumber.Numeric] | |||
| one [BatNum] | |||
| one [BatNativeint] |
The native integer 1.
| ||
| one [BatInt64] |
The 64-bit integer 1.
| ||
| one [BatInt32] |
The 32-bit integer 1.
| ||
| one [BatInt.Safe_int] |
The integer
1.
| ||
| one [BatInt] |
The integer
1.
| ||
| one [BatFloat.Safe_float] |
Floating number one.
| ||
| one [BatFloat] |
Floating number one.
| ||
| one [BatComplex] |
The complex number
1.
| ||
| one [BatBool] | |||
| one [BatBig_int] | |||
| one_of [BatParserCo] |
Accept one of several values.
| ||
| one_plus [BatParserCo] |
Accept a (non-empty) list of expressions
| ||
| op_letter [BatGenlex.Languages.Definition] | |||
| op_map [BatSet.Incubator] |
Order Preserving map; as
map, but f must be order preserving;
i.e.
| ||
| op_start [BatGenlex.Languages.Definition] | |||
| opaque_identity [BatSys] |
For the purposes of optimization,
opaque_identity behaves like an
unknown (and thus possibly side-effecting) function.
| ||
| 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 [BatInt32] | |||
| operations [BatInt.Safe_int] | |||
| operations [BatInt] | |||
| operations [BatFloat.Safe_float] | |||
| operations [BatFloat] | |||
| operations [BatComplex] | |||
| operations [BatBool] | |||
| operations [BatBig_int] | |||
| opt [BatOptParse.Opt] |
Get the value of an option as an optional value.
| ||
| opt_of_ord [BatBounded] | opt_of_ord ~bounds:(low, high) ord will returning a bounding function
using ord for value comparison and None for values which fall outside
of the requested range.
| ||
| or_big_int [BatBig_int] |
Bitwise logical ``or''.
| ||
| ord [BatVect] | |||
| ord [BatUnit] |
Always returns
BatOrd.Eq
| ||
| ord [BatTuple.Tuple5] | |||
| ord [BatTuple.Tuple4] | |||
| ord [BatTuple.Tuple3] | |||
| ord [BatTuple.Tuple2] | |||
| ord [BatString] |
Ordering function for strings, see
BatOrd
| ||
| ord [BatRef] | |||
| ord [BatOrd] |
Returns a variant ordering from a legacy comparison
| ||
| ord [BatOption] |
Comparison between optional values
| ||
| ord [BatNumber.Numeric] | |||
| ord [BatNum] | |||
| ord [BatNativeint] | |||
| ord [BatList] | |||
| ord [BatInt64] | |||
| ord [BatInt32] | |||
| ord [BatInt.Safe_int] | |||
| ord [BatInt] | |||
| ord [BatISet] |
Same as
compare but returns BatOrd.Lt | BatOrd.Eq | BatOrd.Gt
instead of an int.
| ||
| ord [BatFloat] | |||
| ord [BatEnum] |
Same as
compare but returning a BatOrd.order instead of an 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.
| ||
| pop_max [BatSet.PSet] |
Returns the biggest element of the given set
along with the rest of the set.
| ||
| pop_max [BatSet.S] |
Returns the biggest element of the given set
along with the rest of the set.
| ||
| pop_max [BatSet] |
Returns the biggest element of the given set
along with the rest of the set.
| ||
| pop_max_binding [BatMap.PMap] |
return the binding with the largest key along with the rest of the map
| ||
| pop_max_binding [BatMap.S] |
return the (
key,value) pair with the largest key
along with the rest of the map
| ||
| pop_max_binding [BatMap] |
returns the binding with the largest key along with the rest of the map
| ||
| pop_min [BatSet.PSet] |
Returns the smallest element of the given set
along with the rest of the set.
| ||
| pop_min [BatSet.S] |
Returns the smallest element of the given set
along with the rest of the set.
| ||
| pop_min [BatSet] |
Returns the smallest element of the given set
along with the rest of the set.
| ||
| pop_min_binding [BatMap.PMap] |
return the binding with the smallest key along with the rest of the map
| ||
| pop_min_binding [BatMap.S] |
return the (
key,value) pair with the smallest key
along with the rest of the map
| ||
| pop_min_binding [BatMap] |
returns the binding with the smallest key along with the rest of the map
| ||
| popcount [BatInt] |
Returns the number of 1 bits set in the binary representation of
the number.
| ||
| pos_in [BatIO] |
Create an input that provide a count function of the number of bytes
read from it.
| ||
| pos_out [BatIO] |
Create an output that provide a count function of the number of bytes
written through it.
| ||
| post [BatRef] |
Perform an operation on a reference and return the
previous value of that reference.
| ||
| post_decr [BatRef] |
Decrement an integer, return the old value.
| ||
| post_incr [BatRef] |
Increment an integer, return the old value.
| ||
| post_map [BatParserCo] |
Pass the (successful) result of some parser through a map.
| ||
| pow [BatNumber.Numeric] | |||
| pow [BatNum] | |||
| pow [BatNativeint] | |||
| pow [BatInt64] | |||
| pow [BatInt32] | |||
| pow [BatInt.Safe_int] | pow a b computes ab.
| ||
| pow [BatInt] | pow a b computes ab.
| ||
| pow [BatFloat.Safe_float] | |||
| pow [BatFloat] | |||
| pow [BatComplex] |
Power function.
| ||
| pow [BatBool] | |||
| pow [BatBig_int] | |||
| power_big_int_positive_big_int [BatBig_int] |
Exponentiation functions.
| ||
| power_big_int_positive_int [BatBig_int] | |||
| power_int_positive_big_int [BatBig_int] | |||
| power_int_positive_int [BatBig_int] | |||
| power_num [BatNum] | |||
| pp_close_box [BatFormat] | |||
| pp_close_tag [BatFormat] | |||
| pp_close_tbox [BatFormat] | |||
| pp_force_newline [BatFormat] | |||
| pp_get_all_formatter_output_functions [BatFormat] | |||
| pp_get_ellipsis_text [BatFormat] | |||
| pp_get_formatter_output_functions [BatFormat] | |||
| pp_get_formatter_tag_functions [BatFormat] |
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_list [BatFormat] | pp_print_list ?pp_sep pp_v ppf l prints the list l.
| ||
| pp_print_newline [BatFormat] | |||
| pp_print_space [BatFormat] | |||
| pp_print_string [BatFormat] | |||
| pp_print_tab [BatFormat] | |||
| pp_print_tbreak [BatFormat] | |||
| pp_print_text [BatFormat] | pp_print_text ppf s prints s with spaces and newlines
respectively printed with BatFormat.pp_print_space and
BatFormat.pp_force_newline.
| ||
| pp_set_all_formatter_output_functions [BatFormat] | |||
| pp_set_ellipsis_text [BatFormat] | |||
| pp_set_formatter_out_channel [BatFormat] | |||
| pp_set_formatter_output [BatFormat] | |||
| pp_set_formatter_output_functions [BatFormat] | |||
| pp_set_formatter_tag_functions [BatFormat] | |||
| pp_set_margin [BatFormat] | |||
| pp_set_mark_tags [BatFormat] | |||
| pp_set_max_boxes [BatFormat] | |||
| pp_set_max_indent [BatFormat] | |||
| pp_set_print_tags [BatFormat] | |||
| pp_set_tab [BatFormat] | |||
| pp_set_tags [BatFormat] | |||
| pre [BatRef] |
Perform an operation on a reference and return the
new value of that reference.
| ||
| pre_decr [BatRef] |
Increment an integer, return the new value.
| ||
| pre_incr [BatRef] |
Increment an integer, return the new value.
| ||
| pred [BatNumber.Discrete] | |||
| pred [BatNumber.Numeric] | |||
| pred [BatNum] | |||
| pred [BatNativeint] |
Predecessor.
| ||
| pred [BatInt64] |
Predecessor.
| ||
| pred [BatInt32] |
Predecessor.
| ||
| pred [BatInt.Safe_int] |
Predecessor.
| ||
| pred [BatInt] |
Predecessor.
| ||
| pred [BatFloat.Safe_float] |
Substract
1. from a floating number.
| ||
| pred [BatFloat] |
Substract
1. from a floating number.
| ||
| pred [BatComplex] |
Remove
BatComplex.one from this number.
| ||
| pred [BatBool] | |||
| pred [BatBig_int] | |||
| pred_big_int [BatBig_int] |
Predecessor (subtract 1).
| ||
| pred_num [BatNum] | |||
| prefix [BatLog.Config] | |||
| prefix [BatLog] |
This ref holds the text printed before each log message.
| ||
| prefix_action [BatEnum] | prefix_action f e will behave as e but guarantees that f ()
will be invoked exactly once before the current first element of e
is read.
| ||
| prepend [BatVect.Make] | prepend c r returns a new vect with the c character at the
beginning in amortized O(1) time.
| ||
| prepend [BatVect] | prepend c r returns a new vect with the c character at the
beginning in amortized O(1) time.
| ||
| prepend [BatDllist] | prepend n a Creates a new node containing data a and inserts it into
the list before node n.
| ||
| prepend_char [BatText] | prepend_char c r returns a new rope with the c character at the
beginning in amortized O(1) time.
| ||
| prepend_list [BatDeque] | prepent_list l dq is equivalent to append (of_list l) dq,
but more efficient.
| ||
| prerr_all [BatPervasives] |
Print the contents of an input to the error output.
| ||
| prerr_bool [BatPervasives] |
Print a boolean to stderr.
| ||
| prerr_guess [BatPervasives] |
Attempt to print the representation of a runtime value on the
error output.
| ||
| prev [BatUTF8] | prev s i
returns the position of the head of the Unicode character
located immediately before i.
| ||
| prev [BatDllist] |
Given a node, get the previous element in the list before the node.
| ||
| print [BatVect.Make] | |||
| print [BatVect] | |||
| print [BatUref] |
Print the uref.
| ||
| print [BatUnit] |
Printing
| ||
| print [BatTuple.Tuple5] | |||
| print [BatTuple.Tuple4] | |||
| print [BatTuple.Tuple3] | |||
| print [BatTuple.Tuple2] | |||
| print [BatText] |
Prints a rope to the given out_channel
| ||
| print [BatSubstring] | print oc ss prints ss to the output channel oc
| ||
| print [BatString.Cap] | |||
| print [BatString] |
Print a string.
| ||
| print [BatStack] | |||
| print [BatSet.PSet] | |||
| print [BatSet.S] | |||
| print [BatSet] | |||
| print [BatSeq] |
Print the contents of a sequence
| ||
| print [BatResult] |
Print a result as Ok(x) or Bad(exn)
| ||
| print [BatRef] | |||
| print [BatQueue] | |||
| print [BatPrintexc] |
Print an exception.
| ||
| print [BatPervasives] |
Print and consume the contents of an enumeration.
| ||
| print [BatOption] | |||
| print [BatNum] |
Printing
| ||
| print [BatNativeint] | |||
| print [BatMultiPMap] | |||
| print [BatMultiMap] | |||
| print [BatMap.PMap] | |||
| print [BatMap.S] | |||
| print [BatMap] | |||
| print [BatList] |
Print the contents of a list
| ||
| print [BatLazyList] | |||
| print [BatInt64] |
prints as decimal string
| ||
| print [BatInt32] |
prints as decimal string
| ||
| print [BatInt.Safe_int] | |||
| print [BatInt] |
prints as decimal string
| ||
| print [BatISet] | |||
| print [BatHeap.H] |
See
BatHeap.print.
| ||
| print [BatHeap] |
Print the contents of the heap in heap order.
| ||
| print [BatHashtbl.Cap] | |||
| print [BatHashtbl.S] | |||
| print [BatHashtbl] | |||
| print [BatFloat.Safe_float] |
Printing
| ||
| print [BatFloat] |
Printing
| ||
| print [BatFingerTree.S] | |||
| print [BatEnum] |
Print and consume the contents of an enumeration.
| ||
| print [BatDynArray] | |||
| print [BatDllist] | |||
| print [BatDigest] |
Write a digest on the given output in hexadecimal.
| ||
| print [BatDeque] |
Print the contents of the deque.
| ||
| print [BatComplex] |
Printing
| ||
| print [BatChar] | |||
| print [BatBuffer] | |||
| print [BatBool] |
Printing
| ||
| print [BatBitSet] | |||
| print [BatBig_int] | |||
| print [BatArray.Cap] | |||
| print [BatArray] |
Print the contents of an array, with
~first preceeding the first
item (default: "[|"), ~last following the last item (default:
"|]") and ~sep separating items (default: "; ").
| ||
| print_all [BatPervasives] |
Print the contents of an input to the standard output.
| ||
| print_any [BatPervasives] |
Attempt to print a value to an output.
| ||
| print_as [BatFormat] | print_as len str prints str in the
current box.
| ||
| print_as_list [BatSplay.Map] | |||
| print_at_most [BatEnum] | print_at_most pp limit out enum consumes enum to print its elements
into out (using pp to print individual elements).
| ||
| print_backtrace [BatPrintexc] | print_backtrace oc Prints the an exception backtrace on the
output channel oc.
| ||
| print_bool [BatPervasives] |
Print a boolean on standard output.
| ||
| print_bool [BatFormat] |
Prints a boolean in the current box.
| ||
| print_break [BatFormat] |
Inserts a break hint in a pretty-printing box.
| ||
| print_char [BatFormat] |
Prints a character in the current box.
| ||
| print_cut [BatFormat] | print_cut () is used to mark a good break position.
| ||
| print_float [BatFormat] |
Prints a floating point number in the current box.
| ||
| print_flush [BatFormat] |
Flushes the pretty printer: all opened boxes are closed,
and all pending text is displayed.
| ||
| print_guess [BatPervasives] |
Attempt to print the representation of a runtime value on the
standard output.
| ||
| print_hex [BatInt64] |
prints as hex string
| ||
| print_hex [BatInt32] |
prints as hex string
| ||
| print_hex [BatInt] |
prints as hex string
| ||
| print_if_newline [BatFormat] |
Executes the next formatting command if the preceding line
has just been split.
| ||
| print_int [BatFormat] |
Prints an integer in the current box.
| ||
| print_newline [BatFormat] |
Equivalent to
print_flush followed by a new line.
| ||
| print_quoted [BatString.Cap] | |||
| print_quoted [BatString] |
Print a string, with quotes as added by the
quote function.
| ||
| print_raw_backtrace [BatPrintexc] |
Print a raw backtrace in the same format
Printexc.print_backtrace uses.
| ||
| print_rope [BatteriesPrint] | |||
| print_space [BatFormat] | print_space () is used to separate items (typically to print
a space between two words).
| ||
| print_stat [BatGc] |
Print the current values of the memory management counters (in
human-readable form) into the channel argument.
| ||
| print_string [BatFormat] | print_string str prints str in the current box.
| ||
| print_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 [BatList] | range 1 `To 3 = [1; 2; 3].
| ||
| range [BatLazyList] |
Compute lazily a range of integers a ..
| ||
| range [BatEnum] | range p until:q creates an enumeration of integers [p, p+1, ..., q].
| ||
| range [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] | |||
| raw_backtrace_length [BatPrintexc] | raw_backtrace_length bckt returns the number of slots in the
backtrace bckt.
| ||
| raw_backtrace_to_string [BatPrintexc] |
Return a string from a raw backtrace, in the same format
Printexc.get_backtrace uses.
| ||
| rchop [BatText] |
Returns the same rope but without the last character.
| ||
| rchop [BatString.Cap] | |||
| rchop [BatString] |
Returns the same string but without the last
n characters.
| ||
| rcontains_from [BatText] | rcontains_from s stop c tests if character c
appears in the subrope of s starting from the beginning
of s to index stop.
| ||
| rcontains_from [BatString.Cap] | |||
| rcontains_from [BatString] | String.rcontains_from s stop c tests if character c
appears in s before position stop+1.
| ||
| rcontains_from [BatBytes] | rcontains_from s stop c tests if byte c appears in s before
position stop+1.
| ||
| read [BatUnix] | read fd buff ofs len reads len characters from descriptor
fd, storing them in string buff, starting at position ofs
in string buff.
| ||
| read [BatInnerIO] |
Read a single char from an input or raise
No_more_input if
no input available.
| ||
| read [BatIO] |
Read a single char from an input or raise
No_more_input if
no input is available.
| ||
| read_all [BatText] |
Read the whole contents of a UTF-8 encoded input
| ||
| read_all [BatInnerIO] |
read all the contents of the input until
No_more_input is raised.
| ||
| read_all [BatIO] |
read all the contents of the input until
No_more_input is raised.
| ||
| read_bits [BatIO] |
Read up to 31 bits, raise Bits_error if n < 0 or n > 31
| ||
| read_byte [BatInnerIO] |
Read an unsigned 8-bit integer.
| ||
| read_byte [BatIO] |
Read an unsigned 8-bit integer.
| ||
| read_char [BatText] |
Read one Unicode char from a UTF-8 encoded input
| ||
| read_double [BatInnerIO] |
Read an IEEE double precision floating point value.
| ||
| read_double [BatIO.BigEndian] |
Read an IEEE double precision floating point value.
| ||
| read_double [BatIO] |
Read an IEEE double precision floating point value.
| ||
| read_float [BatInnerIO] |
Read an IEEE single precision floating point value.
| ||
| read_float [BatIO.BigEndian] |
Read an IEEE single precision floating point value.
| ||
| read_float [BatIO] |
Read an IEEE single precision floating point value.
| ||
| read_i16 [BatInnerIO] |
Read a signed 16-bit word.
| ||
| read_i16 [BatIO.BigEndian] |
Read a signed 16-bit word.
| ||
| read_i16 [BatIO] |
Read a signed 16-bit word.
| ||
| read_i32 [BatInnerIO] |
Read a signed 32-bit integer.
| ||
| read_i32 [BatIO.BigEndian] |
Read a signed 32-bit integer.
| ||
| read_i32 [BatIO] |
Read a signed 32-bit integer.
| ||
| read_i64 [BatInnerIO] |
Read a signed 64-bit integer as an OCaml int64.
| ||
| read_i64 [BatIO.BigEndian] |
Read a signed 64-bit integer as an OCaml int64.
| ||
| read_i64 [BatIO] |
Read a signed 64-bit integer as an OCaml int64.
| ||
| read_line [BatText] |
Read a line of UTF-8
| ||
| read_line [BatInnerIO] |
Read a LF or CRLF terminated string.
| ||
| read_line [BatIO] |
Read a LF or CRLF terminated string.
| ||
| read_only [BatString.Cap] |
Drop capabilities to read only.
| ||
| read_only [BatHashtbl.Cap] |
Drop to read-only permissions.
| ||
| read_only [BatArray.Cap] |
Drop to read-only permissions.
| ||
| read_real_i32 [BatInnerIO] |
Read a signed 32-bit integer as an OCaml int32.
| ||
| read_real_i32 [BatIO.BigEndian] |
Read a signed 32-bit integer as an OCaml int32.
| ||
| read_real_i32 [BatIO] |
Read a signed 32-bit integer as an OCaml int32.
| ||
| read_signed_byte [BatInnerIO] |
Read an signed 8-bit integer.
| ||
| read_signed_byte [BatIO] |
Read an signed 8-bit integer.
| ||
| read_string [BatInnerIO] |
Read a null-terminated string.
| ||
| read_string [BatIO] |
Read a null-terminated string.
| ||
| read_text [BatText] |
Read up to n chars from a UTF-8 encoded input
| ||
| read_ui16 [BatInnerIO] |
Read an unsigned 16-bit word.
| ||
| read_ui16 [BatIO.BigEndian] |
Read an unsigned 16-bit word.
| ||
| read_ui16 [BatIO] |
Read an unsigned 16-bit word.
| ||
| readdir [BatUnix] |
Return the next entry in a directory.
| ||
| readdir [BatSys] |
Return the names of all files present in the given directory.
| ||
| readlink [BatUnix] |
Read the contents of a link.
| ||
| real_i32s_of [BatIO.BigEndian] |
Read an enumeration of signed 32-bit integers as OCaml
int32s.
| ||
| real_i32s_of [BatIO] |
Read an enumeration of signed 32-bit integers as OCaml
int32s.
| ||
| really_input [BatPervasives] | really_input ic buf pos len reads len characters from channel ic,
storing them in 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_such f l is similar to remove but removes all elements
that satisfy the predicate f and not only the first one.
| ||
| remove_assoc [BatList] | remove_assoc a l returns the list of
pairs l without the first pair with key a, if any.
| ||
| remove_assq [BatList] |
Same as
List.remove_assoc, but uses physical equality instead
of structural equality to compare keys.
| ||
| remove_at [BatRefList.Index] |
Remove the element at the specified index
raise
Invalid_index if the index is outside 0 ; length-1
| ||
| remove_at [BatList] | remove_at i l returns the list l without the element at index i.
| ||
| remove_if [BatRefList] |
Remove the first element matching the
specified predicate
raise
Not_found if no element has been removed
| ||
| remove_if [BatList.Labels] | |||
| remove_if [BatList] | remove_if cmp l is similar to remove, but with cmp used
instead of ( = ).
| ||
| remove_if [BatLazyList.Labels] | |||
| remove_if [BatLazyList] | remove_if cmp l is similar to remove, but with cmp used
instead of ( = ).
| ||
| remove_range [BatISet] | remove_range lo hi t removes a range of elements from the given set, returning a new set
| ||
| remove_range [BatIMap] |
Remove any bindings within the given range
| ||
| rename [BatUnix] | rename old new changes the name of a file from old to new.
| ||
| rename [BatSys] |
Rename a file.
| ||
| repeat [BatString.Cap] | |||
| repeat [BatString] | repeat s n returns s ^ s ^ ... ^ s
| ||
| repeat [BatEnum] | repeat ~times:n x creates a enum sequence filled with n times of
x.
| ||
| replace [BatText] | replace ~str ~sub ~by returns a tuple constisting of a boolean
and a rope where the first occurrence of the rope sub
within str has been replaced by the rope by.
| ||
| replace [BatString.Cap] | |||
| replace [BatString] | replace ~str ~sub ~by returns a tuple consisting of a boolean
and a string where the first occurrence of the string sub
within str has been replaced by the string by.
| ||
| replace [BatInnerWeaktbl] | Weaktbl.replace tbl x y replaces the current binding of x
in tbl by a binding of x to y.
| ||
| replace [BatHashtbl.Cap.Labels] | |||
| replace [BatHashtbl.Cap] | |||
| replace [BatHashtbl.S.Labels] | |||
| replace [BatHashtbl.S] | |||
| replace [BatHashtbl.Labels] | |||
| replace [BatHashtbl] | Hashtbl.replace tbl x y replaces the current binding of x
in tbl by a binding of x to y.
| ||
| replace_chars [BatString.Cap] | |||
| replace_chars [BatString] | replace_chars f s returns a string where all chars c of s have been
replaced by the string returned by f c.
| ||
| reserved_names [BatGenlex.Languages.Definition] | |||
| reset [BatUTF8.Buf] |
Empty the buffer and de-allocate the internal storage.
| ||
| reset [BatBuffer] |
Empty the buffer and deallocate the internal string holding the
buffer contents, replacing it with the initial internal string
of length
n that was allocated by Buffer.create n.
| ||
| reshape [BatBigarray] | reshape b [|d1;...;dN|] converts the big array b to a
N-dimensional array of dimensions d1...
| ||
| reshape_1 [BatBigarray] |
Specialized version of
Bigarray.reshape for reshaping to
one-dimensional arrays.
| ||
| reshape_2 [BatBigarray] |
Specialized version of
Bigarray.reshape for reshaping to
two-dimensional arrays.
| ||
| reshape_3 [BatBigarray] |
Specialized version of
Bigarray.reshape for reshaping to
three-dimensional arrays.
| ||
| restart_on_EINTR [BatUnix] | restart_on_EINTR f x invokes f on x repetedly until the function returns
a value or raises another exception than EINTR.
| ||
| return [BatReturn] |
Return to a label.
| ||
| return [BatResult.Monad] |
Monadic return, just encapsulates the given value with Ok
| ||
| return [BatParserCo] |
A parser which always succeds
| ||
| return [BatOption.Monad] | return x puts a value in the Option monad, that is, returns Some x.
| ||
| return [BatInterfaces.Monad] |
Return a value, that is, put a value in the monad.
| ||
| return [BatEnum.Monad] |
This function puts a single value in the BatEnum monad, that is to say it creates an enumeration containing a single element.
| ||
| rev [BatString] | string s returns the reverse of string s
| ||
| rev [BatRefList] |
Reverses the ref list - O(n)
| ||
| rev [BatOrd] |
Reverse a given ordering.
| ||
| rev [BatList] |
List reversal.
| ||
| rev [BatLazyList] |
Eager list reversal.
| ||
| rev [BatDllist] |
List reversal.
| ||
| rev [BatDeque] | rev dq reverses dq.
| ||
| rev [BatArray.Cap] | |||
| rev [BatArray] |
Array reversal.
| ||
| rev_append [BatList] | List.rev_append l1 l2 reverses l1 and concatenates it to l2.
| ||
| rev_append [BatLazyList] |
Eager reverse-and-append
| ||
| rev_comp [BatOrd] | |||
| rev_comp0 [BatOrd] | |||
| rev_drop [BatDllist] |
Remove node from the list no matter where it is.
| ||
| rev_enum [BatDllist] |
Create a reverse enum of the list.
| ||
| rev_in_place [BatString] | rev_in_place s mutates the string s, so that its new value is
the mirror of its old one: for instance if s contained "Example!", after
the mutation it will contain "!elpmaxE".
| ||
| rev_in_place [BatArray.Cap] | |||
| rev_in_place [BatArray] |
In-place array reversal.
| ||
| rev_map [BatList.Labels] | |||
| rev_map [BatList] | List.rev_map f l gives the same result as
List.rev (List.map f l).
| ||
| rev_map2 [BatList.Labels] | |||
| rev_map2 [BatList] | List.rev_map2 f l1 l2 gives the same result as
List.rev (List.map2 f l1 l2), but is tail-recursive and
more efficient.
| ||
| rev_ord [BatOrd] | |||
| rev_ord0 [BatOrd] | |||
| reverse [BatFingerTree.S] | reverse t is equivalent to of_list (List.rev (to_list t)).
| ||
| rewinddir [BatUnix] |
Reposition the descriptor to the beginning of the directory
| ||
| rfind [BatText] | rfind s x returns the starting index of the last occurrence
of rope x within rope s.
| ||
| rfind [BatString.Cap.Exceptionless] | |||
| rfind [BatString.Cap] | |||
| rfind [BatString.Exceptionless] | rfind s x returns Some i, the starting index of the last occurrence
of string x within string s, or None if x is not a substring
of s.
| ||
| rfind [BatString] | rfind s x returns the starting index of the last occurrence
of string x within string s.
| ||
| rfind [BatRefList] |
Find the first element in the reversed ref list matching
the specified predicate
raise
Not_found if no element is found
| ||
| rfind [BatList.Labels.LExceptionless] | |||
| rfind [BatList.Labels] | |||
| rfind [BatList.Exceptionless] | rfind p l returns Some x where x is the last element of l
such
that p x returns true or None if such element as not been found.
| ||
| rfind [BatList] | rfind p l returns the last element x of l such as p x returns
true or
| ||
| rfind [BatLazyList.Labels.Exceptionless] | |||
| rfind [BatLazyList.Labels] | |||
| rfind [BatLazyList.Exceptionless] | rfind p l returns Some x where x is the last element of l such
that p x returns true or None if such element as not been found.
| ||
| rfind [BatLazyList] | rfind p l returns the last element x of l such as p x returns
true.
| ||
| rfind_exn [BatLazyList.Labels] | |||
| rfind_exn [BatLazyList] | find_exn p e l returns the last element of l such as p x
returns true or raises e if such an element has not been found.
| ||
| rfind_from [BatText] | rfind_from s ofs x behaves as rfind s x but starts searching
at offset ofs.
| ||
| rfind_from [BatString.Cap.Exceptionless] | |||
| rfind_from [BatString.Cap] | |||
| rfind_from [BatString.Exceptionless] | rfind_from s ofs x behaves as rfind s x but starts searching
at offset ofs.
| ||
| rfind_from [BatString] | rfind_from s pos x behaves as rfind s x but starts searching
from the right at position pos + 1.
| ||
| rfindi [BatLazyList.Labels.Exceptionless] | |||
| rfindi [BatLazyList.Labels] | |||
| rfindi [BatLazyList.Exceptionless] | findi p e l returns Some (i, ai) where ai and i are respectively the
last element of l and its index, such that p i ai is true,
or None if no such element has been found.
| ||
| rfindi [BatLazyList] | findi p e l returns the last element ai of l along with its
index i such that p i ai is true.
| ||
| right [BatText] | left r len returns the rope containing the len last characters of r
| ||
| right [BatString.Cap] | |||
| right [BatString] | left r len returns the string containing the len last characters of r.
| ||
| right [BatArray] | left r len returns the array containing the len last characters of r.
| ||
| right_branch [BatAvlTree] | |||
| rindex [BatText] | Rope.rindex s c returns the position of the rightmost
occurrence of character c in rope s.
| ||
| rindex [BatSubstring] | rindex sus c returns the index of the last occurence of c in sus or
| ||
| rindex [BatString.Cap.Exceptionless] | |||
| rindex [BatString.Cap] | |||
| rindex [BatString.Exceptionless] | rindex s c returns Some p, the position of the rightmost
occurrence of character c in string s or
None if c does not occur in s.
| ||
| rindex [BatString] | String.rindex s c returns the character number of the last
occurrence of character c in string s.
| ||
| rindex [BatPathGen.StringType] | |||
| rindex [BatBytes] | rindex s c returns the index of the last occurrence of byte c
in s.
| ||
| rindex_from [BatText] |
Same as
BatText.rindex, but start
searching at the character position given as second argument.
| ||
| rindex_from [BatSubstring] | index_from sus i c returns the index of the last 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_from [BatBytes] | rindex_from s i c returns the index of the last occurrence of
byte c in s before position i+1.
| ||
| rindex_of [BatList] | rindex_of e l returns the index of the last occurrence of e
in l, or None if there is no occurrence of e in l
| ||
| rindex_of [BatLazyList] | index_of e l returns the index of the last occurrence of e
in l, or None if there is no occurrence of e in l
| ||
| rindex_ofq [BatList] | rindex_ofq e l behaves as rindex_of e l except it uses
physical equality
| ||
| rindex_ofq [BatLazyList] | rindex_ofq e l behaves as rindex_of e l except it uses
physical equality
| ||
| 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] | |||
| rotate_backward [BatDeque] |
A cyclic shift of deque elements from front to rear by one position.
| ||
| rotate_forward [BatDeque] |
A cyclic shift of deque elements from rear to front by one position.
| ||
| round [BatNum] | |||
| round [BatFloat] | round x rounds x to the nearest integral floating-point
(the nearest of floor x and ceil x).
| ||
| round_num [BatNum] | |||
| round_to_int [BatFloat] | round_to_int x is int_of_float (round x).
| ||
| round_to_string [BatFloat] | round_to_string ~digits:d x will return a string
representation of x -- in base 10 -- rounded to d digits
after the decimal point.
| ||
| rsplit [BatText] | rsplit s sep splits the rope s between the last
occurrence of sep.
| ||
| rsplit [BatString.Cap.Exceptionless] | |||
| rsplit [BatString.Cap] | |||
| rsplit [BatString.Exceptionless] | rsplit s sep splits the string s between the last
occurrence of sep, or returns None if the separator
is not found.
| ||
| rsplit [BatString] | rsplit s sep splits the string s between the last occurrence
of sep, and returns the two parts before and after the
occurence (excluded).
| ||
| run [BatParserCo] | run p s executes parser p on source s.
| ||
| run_and_read [BatUnix] | (stat, output) = run_and_read cmd run the command cmd
(via Unix.system) then return its exit status stat and
output string output as read from its standard output (which
was redirected to a temporary file).
| ||
| run_initializers [BatOo.Internal] | |||
| run_initializers_opt [BatOo.Internal] | |||
| runtime_parameters [BatSys] |
Return the value of the runtime parameters, in the same format
as the contents of the
OCAMLRUNPARAM environment variable.
| ||
| runtime_variant [BatSys] |
Return the name of the runtime variant the program is running on.
| ||
| runtime_warnings_enabled [BatSys] |
Return whether runtime warnings are currently enabled.
| ||
S | |||
| s [BatPathGen.PathType] | |||
| sat [BatParserCo] | satisfy p accepts one value p x such that p x = true
| ||
| satisfy [BatParserCo] | satisfy p accepts one value p x such that p x = true
| ||
| saturate_of_ord [BatBounded] | saturate_of_ord ~bounds:(low, high) ord will returning a bounding
function using ord for value comparison and low and high for values
which fall outside of the requested range.
| ||
| scan [BatStream.StreamLabels] | |||
| scan [BatStream] | scan is similar to scanl but without the init value:
scanl f init [< 'e0; 'e1; 'e2; ... >] is equivalent to
[< 'e0; '(f e0 e1); '(f (f e0 e1) e2); ... >]
| ||
| scan [BatParserCo] |
Use a parser to extract list of tokens, but return
that list of tokens instead of whatever the original
parser returned.
| ||
| scan [BatEnum] | scan is similar to scanl but without the init value: if e
contains x0, x1, x2 ..., scan f e is the enumeration containing
x0, f x0 x1, f (f x0 x1) x2...
| ||
| scanf [BatScanf] |
Same as
Scanf.bscanf, but reads from the predefined scanning
buffer Scanf.Scanning.stdib that is connected to stdin.
| ||
| scanl [BatStream.StreamLabels] | |||
| scanl [BatStream] | scanl f init stream returns a stream of successive reduced
values from the left: scanl f init [< 'e0; 'e1; ... >] is
equivalent to
[< 'init; '(f init e0); '(f (f init e0) e1); ... >]
| ||
| scanl [BatPervasives] |
Functional loop on an enumeration, used to build an enumeration
from both an enumeration and an initial value.
| ||
| scanl [BatEnum] |
A variant of
fold producing an enumeration of its intermediate values.
| ||
| second [BatTuple.Tuple5] | |||
| second [BatTuple.Tuple4] | |||
| second [BatTuple.Tuple3] | |||
| second [BatTuple.Tuple2] |
Equivalent to
Pervasives.snd.
| ||
| select [BatUnix] |
Wait until some input/output operations become possible on
some channels.
| ||
| self_init [BatRandom] |
Initialize the generator with a more-or-less random seed chosen
in a system-dependent way.
| ||
| send [BatUnix] |
Send data over a connected socket.
| ||
| send [BatOo.Internal] | |||
| send_substring [BatUnix] |
Same as
send, but take the data from a string instead of a byte
sequence.
| ||
| sendcache [BatOo.Internal] | |||
| sendself [BatOo.Internal] | |||
| sendto [BatUnix] |
Send data over an unconnected socket.
| ||
| sendto_substring [BatUnix] |
Same as
sendto, but take the data from a string instead of a
byte sequence.
| ||
| seq [BatLazyList] | seq 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 [BatBytes] | set s n c modifies s in place, replacing the byte at index n
with c.
| ||
| set [BatBitSet] | set s n sets the nth-bit in the bitset s to true.
| ||
| set [BatBigarray.Array3] | Array3.set a x y v, or alternatively a.{x,y,z} <- v,
stores the value v at coordinates (x, y, z) in a.
| ||
| set [BatBigarray.Array2] | Array2.set a x y v, or alternatively a.{x,y} <- v,
stores the value v at coordinates (x, y) in a.
| ||
| set [BatBigarray.Array1] | Array1.set a x v, also written a.{x} <- v,
stores the value v at index x in a.
| ||
| set [BatBigarray.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.
| ||
| set_uncaught_exception_handler [BatPrintexc] | Printexc.set_uncaught_exception_handler fn registers fn as the handler
for uncaught exceptions.
| ||
| setgid [BatUnix] |
Set the real group id and effective group id for the process.
| ||
| setgroups [BatUnix] | setgroups groups sets the supplementary group IDs for the
calling process.
| ||
| setitimer [BatUnix] | setitimer t s sets the interval timer t and returns
its previous status.
| ||
| setsid [BatUnix] |
Put the calling process in a new session and detach it from
its controlling terminal.
| ||
| setsockopt [BatUnix] |
Set or clear a boolean-valued option in the given socket.
| ||
| setsockopt_float [BatUnix] |
Same as
Unix.setsockopt for a socket option whose value is a
floating-point number.
| ||
| setsockopt_int [BatUnix] |
Same as
Unix.setsockopt for an integer-valued socket option.
| ||
| setsockopt_optint [BatUnix] |
Same as
Unix.setsockopt for a socket option whose value is an
int option.
| ||
| setuid [BatUnix] |
Set the real user id and effective user id for the process.
| ||
| shift [BatVect.Make] |
Return the first element of a vector and its last
n-1 elements.
| ||
| shift [BatVect] |
Return the first element of a vector and its last
n-1 elements.
| ||
| shift_left [BatNativeint] | Nativeint.shift_left x y shifts x to the left by y bits.
| ||
| shift_left [BatInt64] | Int64.shift_left x y shifts x to the left by y bits.
| ||
| shift_left [BatInt32] | Int32.shift_left x y shifts x to the left by y bits.
| ||
| shift_left_big_int [BatBig_int] | shift_left_big_int b n returns b shifted left by n bits.
| ||
| shift_right [BatNativeint] | Nativeint.shift_right x y shifts x to the right by y bits.
| ||
| shift_right [BatInt64] | Int64.shift_right x y shifts x to the right by y bits.
| ||
| shift_right [BatInt32] | Int32.shift_right x y shifts x to the right by y bits.
| ||
| shift_right_big_int [BatBig_int] | shift_right_big_int b n returns b shifted right by n bits.
| ||
| shift_right_logical [BatNativeint] | Nativeint.shift_right_logical x y shifts x to the right
by y bits.
| ||
| shift_right_logical [BatInt64] | Int64.shift_right_logical x y shifts x to the right by y bits.
| ||
| shift_right_logical [BatInt32] | Int32.shift_right_logical x y shifts x to the right by y bits.
| ||
| shift_right_towards_zero_big_int [BatBig_int] | shift_right_towards_zero_big_int b n returns b shifted
right by n bits.
| ||
| should [BatParserCo] |
Prevent backtracking.
| ||
| shuffle [BatRandom] | shuffle e returns a new array, containing the
same set of elements as e, but in a random order.
| ||
| shutdown [BatUnix] |
Shutdown a socket connection.
| ||
| shutdown_connection [BatUnix] |
``Shut down'' a connection established with
Unix.open_connection;
that is, transmit an end-of-file condition to the server reading
on the other side of the connection.
| ||
| sigabrt [BatSys] |
Abnormal termination
| ||
| sigalrm [BatSys] |
Timeout
| ||
| sigbus [BatSys] |
Bus error
| ||
| sigchld [BatSys] |
Child process terminated
| ||
| sigcont [BatSys] |
Continue
| ||
| sigfpe [BatSys] |
Arithmetic exception
| ||
| sighup [BatSys] |
Hangup on controlling terminal
| ||
| sigill [BatSys] |
Invalid hardware instruction
| ||
| sigint [BatSys] |
Interactive interrupt (ctrl-C)
| ||
| sigkill [BatSys] |
Termination (cannot be ignored)
| ||
| sign [BatNum] |
Return
-1, 0 or 1 according to the sign of the argument.
| ||
| sign_big_int [BatBig_int] |
Return
0 if the given big integer is zero,
1 if it is positive, and -1 if it is negative.
| ||
| sign_num [BatNum] | |||
| signal [BatSys] |
Set the behavior of the system on receipt of a given signal.
| ||
| signbit [BatFloat] | |||
| signed_bytes_of [BatIO] |
Read an enumeration of signed 8-bit integers.
| ||
| sigpending [BatUnix] |
Return the set of blocked signals that are currently pending.
| ||
| sigpipe [BatSys] |
Broken pipe
| ||
| sigpoll [BatSys] |
Pollable event
| ||
| sigprocmask [BatUnix] | sigprocmask cmd sigs changes the set of blocked signals.
| ||
| sigprof [BatSys] |
Profiling interrupt
| ||
| sigquit [BatSys] |
Interactive termination
| ||
| sigsegv [BatSys] |
Invalid memory reference
| ||
| sigstop [BatSys] |
Stop
| ||
| sigsuspend [BatUnix] | sigsuspend sigs atomically sets the blocked signals to sigs
and waits for a non-ignored, non-blocked signal to be delivered.
| ||
| sigsys [BatSys] |
Bad argument to routine
| ||
| sigterm [BatSys] |
Termination
| ||
| sigtrap [BatSys] |
Trace/breakpoint trap
| ||
| sigtstp [BatSys] |
Interactive stop
| ||
| sigttin [BatSys] |
Terminal read from background process
| ||
| sigttou [BatSys] |
Terminal write from background process
| ||
| sigurg [BatSys] |
Urgent condition on socket
| ||
| sigusr1 [BatSys] |
Application-defined signal 1
| ||
| sigusr2 [BatSys] |
Application-defined signal 2
| ||
| sigvtalrm [BatSys] |
Timeout in virtual time
| ||
| sigxcpu [BatSys] |
Timeout in cpu time
| ||
| sigxfsz [BatSys] |
File size limit exceeded
| ||
| sin [BatFloat.Safe_float] | |||
| sin [BatFloat] |
See
BatFloat.atan2.
| ||
| single_write [BatUnix] |
Same as
write, but attempts to write only once.
| ||
| single_write_substring [BatUnix] |
Same as
single_write, but take the data from a string instead of
a byte sequence.
| ||
| singleton [BatVect.Make] |
Returns a vect of length 1 holding only the given element.
| ||
| singleton [BatVect] |
Returns a vect of length 1 holding only the given element.
| ||
| singleton [BatSet.PSet] |
Creates a new set with the single given element in it.
| ||
| singleton [BatSet.S] | singleton x returns the one-element set containing only x.
| ||
| singleton [BatSet] |
Creates a new set with the single given element in it.
| ||
| singleton [BatMap.PMap] |
creates a new map with a single binding
| ||
| singleton [BatMap.S] | singleton x y returns the one-element map that contains a binding y
for x.
| ||
| singleton [BatMap] |
creates a new map with a single binding
| ||
| singleton [BatList] |
Create a list consisting of exactly one element.
| ||
| singleton [BatISet] |
Return the singleton set containing only the given element
| ||
| singleton [BatIMap] | |||
| singleton [BatFingerTree.S] | singleton elt build the sequence containing elt as its sole
element.
| ||
| singleton [BatEnum] |
Create an enumeration consisting of exactly one element.
| ||
| singleton [BatArray] |
Create an array consisting of 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_in_bytes [BatBigarray.Array3] | |||
| size_in_bytes [BatBigarray.Array2] | |||
| size_in_bytes [BatBigarray.Array1] | |||
| size_in_bytes [BatBigarray.Genarray] | |||
| size_of [BatFile] | size_of name returns the size of file name in bytes.
| ||
| size_of_big [BatFile] | size_of_big name returns the size of file name in bytes, as a 64-bit integer.
| ||
| skip [BatEnum] | skip n e removes the first n element from the enumeration, if any,
then returns e.
| ||
| skip [BatDllist] | skip n i Return the node that is i nodes after node n in the list.
| ||
| sleep [BatUnix] |
Stop execution for the given number of seconds.
| ||
| sleepf [BatUnix] |
Stop execution for the given number of seconds.
| ||
| slice [BatText] | slice ?first ?last s returns a "slice" of the rope
which corresponds to the characters s.[first],
s.[first+1], ..., s[last-1].
| ||
| slice [BatSubstring] | slice sus i' None returns the substring (s, i+i', n-i'),
where sus = (s, i, n).
| ||
| slice [BatString.Cap] | |||
| slice [BatString] | slice ?first ?last s returns a "slice" of the string
which corresponds to the characters s.[first],
s.[first+1], ..., s[last-1].
| ||
| slice_left [BatBigarray.Array2] |
Extract a row (one-dimensional slice) of the given two-dimensional
big array.
| ||
| slice_left [BatBigarray.Genarray] |
Extract a sub-array of lower dimension from the given big array
by fixing one or several of the first (left-most) coordinates.
| ||
| slice_left_1 [BatBigarray.Array3] |
Extract a one-dimensional slice of the given three-dimensional
big array by fixing the first two coordinates.
| ||
| slice_left_2 [BatBigarray.Array3] |
Extract a two-dimensional slice of the given three-dimensional
big array by fixing the first coordinate.
| ||
| slice_right [BatBigarray.Array2] |
Extract a column (one-dimensional slice) of the given
two-dimensional big array.
| ||
| slice_right [BatBigarray.Genarray] |
Extract a sub-array of lower dimension from the given big array
by fixing one or several of the last (right-most) coordinates.
| ||
| slice_right_1 [BatBigarray.Array3] |
Extract a one-dimensional slice of the given three-dimensional
big array by fixing the last two coordinates.
| ||
| slice_right_2 [BatBigarray.Array3] |
Extract a two-dimensional slice of the given
three-dimensional big array by fixing the last coordinate.
| ||
| snoc [BatFingerTree.S] | snoc t elt adds elt to the right of t.
| ||
| snoc [BatDeque] | snoc x dq adds x to the rear of dq.
| ||
| socket [BatUnix] |
Create a new socket in the given domain, and with the
given kind.
| ||
| socketpair [BatUnix] |
Create a pair of unnamed sockets, connected together.
| ||
| some [BatOption] | some x returns Some x.
| ||
| sort [BatRefList] |
Sort elements using the specified comparator
| ||
| sort [BatList] |
Sort a list in increasing order according to a comparison
function.
| ||
| sort [BatLazyList] |
Sort the list using optional comparator (by default
compare).
| ||
| sort [BatArray.Cap.Labels] | |||
| sort [BatArray.Cap] | |||
| sort [BatArray.Labels] | |||
| sort [BatArray] |
Sort an array in increasing order according to a comparison
function.
| ||
| sort_uniq [BatList] | sort_uniq cmp l returns the list l sorted and without any
duplicate element.
| ||
| sort_unique [BatList] |
synonym for
sort_uniq
| ||
| source [BatPathGen.StringType.Parse] | |||
| source_map [BatParserCo] | |||
| source_of_enum [BatCharParser] |
Create a source from a latin-1 character.
| ||
| source_of_string [BatCharParser] |
Create a source from a latin-1 character string.
| ||
| span [BatSubstring] | span sus1 sus2 returns a substring spanning from the start of
sus1 to the end of sus2, provided this is well-defined: sus1
and sus2 must have the same underlying string, and the start of
sus1 must not be to the right of the end of sus2; otherwise
| ||
| span [BatList] | span, applied to a predicate p and a list xs, returns a
tuple where first element is longest prefix (possibly empty) of xs
of elements that satisfy p and second element is the remainder of
the list.
| ||
| span [BatEnum] | span test e produces two enumerations (hd, tl), such that
hd is the same as take_while test e and tl is the same
as drop_while test e.
| ||
| splice [BatText] | splice s off len rep returns the rope in which the section of s
indicated by off and len has been cut and replaced by rep.
| ||
| splice [BatString.Cap] | |||
| splice [BatString] | String.splice s off len rep cuts out the section of s
indicated by off and len and replaces it by rep
| ||
| splice [BatDllist] | splice n1 n2 Connects n1 and n2 so that
next n1 == n2 && prev n2 == n1.
| ||
| split [BatText] | split s sep splits the rope s between the first
occurrence of sep.
| ||
| split [BatString.Cap.Exceptionless] | |||
| split [BatString.Cap] |
Splitting around
| ||
| split [BatString.Exceptionless] | split s sep splits the string s between the first
occurrence of sep, or returns None if the separator
is not found.
| ||
| split [BatString] | split s sep splits the string s between the first
occurrence of sep, and returns the two parts before
and after the 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_le [BatSet.PSet] | split_le x s returns a pair of sets (l, r), such that
l is the subset of s with elements <= x;
r is the subset of s with elements > x.
| ||
| split_le [BatSet.S] | split_le x s returns a pair of sets (l, r), such that
l is the subset of s with elements <= x;
r is the subset of s with elements > x.
| ||
| split_le [BatSet] | split_le x s returns a pair of sets (l, r), such that
l is the subset of s with elements <= x;
r is the subset of s with elements > x.
| ||
| split_leftmost [BatAvlTree] | |||
| split_lt [BatSet.PSet] | split_lt x s returns a pair of sets (l, r), such that
l is the subset of s with elements < x;
r is the subset of s with elements >= x.
| ||
| split_lt [BatSet.S] | split_lt x s returns a pair of sets (l, r), such that
l is the subset of s with elements < x;
r is the subset of s with elements >= x.
| ||
| split_lt [BatSet] | split_lt x s returns a pair of sets (l, r), such that
l is the subset of s with elements < x;
r is the subset of s with elements >= x.
| ||
| split_nth [BatList] |
Obsolete.
| ||
| split_nth [BatLazyList] |
Obsolete.
| ||
| split_on_char [BatSubstring] | split_on_char c ss returns substrings of input ss as divided
by c
| ||
| split_on_comma [BatSubstring] | |||
| split_on_dot [BatSubstring] | |||
| split_on_pipe [BatSubstring] | |||
| split_on_slash [BatSubstring] | |||
| split_opt [BatSet.PSet] | split_opt x s returns a triple (l, maybe_v, r), where
l is the set of elements of s that are
strictly less than x;
r is the set of elements of s that are
strictly greater than x;
maybe_v is None if s contains no element equal to x,
or Some v if s contains an element v that compares equal to x.
| ||
| split_opt [BatSet.S] | split_opt x s returns a triple (l, maybe_v, r), where
l is the set of elements of s that are
strictly less than x;
r is the set of elements of s that are
strictly greater than x;
maybe_v is None if s contains no element equal to x,
or Some v if s contains an element v that compares equal to x.
| ||
| split_opt [BatSet] | split_opt x s returns a triple (l, maybe_v, r), where
l is the set of elements of s that are
strictly less than x;
r is the set of elements of s that are
strictly greater than x;
maybe_v is None if s contains no element equal to x,
or Some v if s contains an element v that compares equal to x.
| ||
| split_rightmost [BatAvlTree] | |||
| splitl [BatSubstring] | splitl p sus splits sus into a pair (sus1, sus2) of
substrings where sus1 is the longest prefix (left substring) all
of whose characters satisfy p, and sus2 is the rest.
| ||
| splitr [BatSubstring] | splitr p sus splits sus into a pair (sus1, sus2) of
substrings where sus2 is the longest suffix (right substring) all
of whose characters satisfy p, and sus1 is the rest.
| ||
| sprintf [BatPrintf] |
A function which doesn't print its result but returns it as a string.
| ||
| sprintf [BatFormat] |
Same as
printf above, but instead of printing on a formatter,
returns a string containing the result of formatting the arguments.
| ||
| sprintf2 [BatPrintf] |
A function which doesn't print its result but returns it as a string.
| ||
| sqrt [BatFloat] |
Square root.
| ||
| sqrt [BatComplex] |
Square root.
| ||
| sqrt2 [BatFloat] | sqrt 2.
| ||
| sqrt_big_int [BatBig_int] | sqrt_big_int a returns the integer square root of a,
that is, the largest big integer r such that r * r <= a.
| ||
| sqrtpi2 [BatFloat] | 2. *. sqrt pi
| ||
| square [BatNum] | |||
| square_big_int [BatBig_int] |
Return the square of the given big integer
| ||
| square_num [BatNum] | |||
| sscanf [BatScanf] |
Same as
Scanf.bscanf, but reads from the given string.
| ||
| sscanf_format [BatScanf] |
Same as
Scanf.bscanf_format, but reads from the given string.
| ||
| stable_sort [BatList.Labels] | |||
| stable_sort [BatList] |
Same as
List.sort, but the sorting algorithm is guaranteed to
be stable (i.e.
| ||
| stable_sort [BatLazyList] | |||
| stable_sort [BatArray.Cap.Labels] | |||
| stable_sort [BatArray.Cap] | |||
| stable_sort [BatArray.Labels] | |||
| stable_sort [BatArray] |
Same as
Array.sort, but the sorting algorithm is stable (i.e.
| ||
| start [BatGenlex.Languages.Make] |
Medium-level API
| ||
| 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 [BatBytes] | sub s start len returns a new byte sequence of length len,
containing the subsequence of s that starts at position start
and has length len.
| ||
| sub [BatBuffer] | Buffer.sub b off len returns (a copy of) 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.
| ||
| sub_string [BatBytes] |
Same as
sub but return a string instead of a byte sequence.
| ||
| subbytes [BatDigest] | Digest.subbytes s ofs len returns the digest of the subsequence
of s starting at index ofs and containing len bytes.
| ||
| subset [BatSet.PSet] | subset a b returns true if a is a subset of b.
| ||
| subset [BatSet.S] | subset s1 s2 tests whether the set s1 is a subset of
the set s2.
| ||
| subset [BatSet] | subset a b returns true if a is a subset of b.
| ||
| subset [BatList.Labels] | |||
| subset [BatList] | subset cmp l l' check if all elements of the list l
is contained in the list l' by applying cmp as comparator.
| ||
| subset [BatISet] | subset t u returns true if t is a subset of u
| ||
| substring [BatSubstring] | substring s o l returns a substring with base-string s, offset
o and length l.
| ||
| substring [BatDigest] | Digest.substring s ofs len returns the digest of the substring
of s starting at character number ofs and containing len
characters.
| ||
| succ [BatNumber.Discrete] | |||
| succ [BatNumber.Numeric] | |||
| succ [BatNum] | |||
| succ [BatNativeint] |
Successor.
| ||
| succ [BatInt64] |
Successor.
| ||
| succ [BatInt32] |
Successor.
| ||
| succ [BatInt.Safe_int] |
Successor.
| ||
| succ [BatInt] |
Successor.
| ||
| succ [BatFloat.Safe_float] |
Add
1. to a floating number.
| ||
| succ [BatFloat] |
Add
1. to a floating number.
| ||
| succ [BatComplex] |
Add
BatComplex.one to this number.
| ||
| succ [BatBool] | |||
| succ [BatBig_int] | |||
| succ_big_int [BatBig_int] |
Successor (add 1).
| ||
| succ_num [BatNum] | |||
| suffix_action [BatEnum] | suffix_action f e will behave as e but guarantees that f ()
will be invoked after the contents of e are exhausted.
| ||
| sum [BatList] | sum l returns the sum of the integers of l
| ||
| sum [BatEnum] | sum returns the sum of the given int enum.
| ||
| sum [BatArray] | sum l returns the sum of the integers of l
| ||
| suspend [BatParserCo] | suspend s returns the state of the parser in a form that can be
resumed by calling the returned function.
| ||
| swap [BatTuple.Tuple2] | |||
| swap [BatRef] | swap a b puts !b in a and !a in b
| ||
| switch [BatStream.StreamLabels] | |||
| switch [BatStream] | switch test stream split stream into two streams, where the first stream have
all the elements satisfying test, the second stream is opposite.
| ||
| switch [BatEnum.Labels] | |||
| switch [BatEnum] | switch test enum splits enum into two enums, where the first enum have
all the elements satisfying test, the second enum is opposite.
| ||
| sym_diff [BatSet.PSet] | sym_diff s t returns the set of all elements in s or t but not both.
| ||
| sym_diff [BatSet.S] | sym_diff s t returns the set of all elements in s or t
but not both.
| ||
| sym_diff [BatSet] | sym_diff s t returns the set of all elements in s or t but
not both, also known as the symmetric difference.
| ||
| sym_diff [BatBitSet] | sym_diff s t returns the symmetrical difference of s and t.
| ||
| symlink [BatUnix] |
Symbolic links
| ||
| sync [BatConcurrent] |
Specialized version of
synchronized.
| ||
| synchronize [BatRMutex] |
Protect a function.
| ||
| synchronize [BatMutex] |
Protect a function.
| ||
| synchronize [BatConcurrent.Lock] | |||
| synchronize [BatConcurrent] | synchronize locker f returns a function f' which behaves as
f but whose executions are protected by one lock obtained from
locker.
| ||
| synchronize_in [BatIO] | |||
| synchronize_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
| ||
| takedrop [BatList] | take_drop n l is equivalent to (take n l, drop n l)
but is done in one pass.
| ||
| takel [BatSubstring] | takel p sus returns the longest prefix (left substring) of sus
all of whose characters satisfy predicate p.
| ||
| taker [BatSubstring] | taker p sus returns the longest suffix (right substring) of sus
all of whose characters satisfy predicate p.
| ||
| takewhile [BatList] |
obsolete, as
BatList.take_while
| ||
| tan [BatFloat.Safe_float] | |||
| tan [BatFloat] |
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 [BatSet.PSet] |
Same as
to_list but with an array instead of a list.
| ||
| to_array [BatSet.S] |
Same as
to_list but with an array instead of a list.
| ||
| to_array [BatSet] |
Same as
to_list but with an array instead of a list.
| ||
| to_array [BatLazyList] |
Eager conversion to array.
| ||
| to_array [BatDynArray] | to_array darr returns the elements of darr in order as an array.
| ||
| to_array [BatBigarray.Array3] |
Build a three-dimensional array initialized from the
given big array.
| ||
| to_array [BatBigarray.Array2] |
Build a two-dimensional array initialized from the
given big array.
| ||
| to_array [BatBigarray.Array1] |
Build a one-dimensional array initialized from the
given big array.
| ||
| to_array [BatArray.Cap] |
Return a capability array as an array.
| ||
| to_buffer [BatMarshal] | Marshal.to_buffer buff ofs len v flags marshals the value v,
storing its byte representation in the sequence buff,
starting at index ofs, and writing at most
len bytes.
| ||
| to_byte [BatInt32] | |||
| to_bytes [BatMarshal] | Marshal.to_bytes v flags returns a byte sequence containing
the representation of v.
| ||
| to_bytes [BatBuffer] |
Return a copy of the current contents of the buffer.
| ||
| to_channel [BatMarshal] | |||
| to_container [BatVect.Make] | to_container r returns a container corresponding to the vect r.
| ||
| to_enum_filter [BatGenlex] |
Apply the lexer to an enum.
| ||
| to_f_printer [BatIO] | |||
| to_float [BatString.Cap.Exceptionless] | |||
| to_float [BatString.Cap] | |||
| to_float [BatString.Exceptionless] |
Returns the float represented by the given string or
None if the string does not represent a float.
| ||
| to_float [BatString] |
Returns the float represented by the given string
or
| ||
| to_float [BatNumber.Numeric] | |||
| to_float [BatNum] | |||
| to_float [BatNativeint] |
Convert the given native integer to a floating-point number.
| ||
| to_float [BatInt64] |
Convert the given 64-bit integer to a floating-point number.
| ||
| to_float [BatInt32] |
Convert the given 32-bit integer to a floating-point number.
| ||
| to_float [BatInt.Safe_int] |
Convert the given integer to a floating-point number.
| ||
| to_float [BatInt] |
Convert the given integer to a floating-point number.
| ||
| to_float [BatFloat.Safe_float] | |||
| to_float [BatFloat] | |||
| to_float [BatComplex] | Complex.to_float (a+bi) returns the float a
| ||
| to_float [BatBool] | |||
| to_float [BatBig_int] | |||
| to_hex [BatDigest] |
Return the printable hexadecimal representation of the given digest.
| ||
| to_input_channel [BatIO] |
Create a channel that will read from an input.
| ||
| to_int [BatString.Cap.Exceptionless] | |||
| to_int [BatString.Cap] | |||
| to_int [BatString.Exceptionless] |
Returns the integer represented by the given string or
None if the string does not represent an integer.
| ||
| to_int [BatString] |
Returns the integer represented by the given string
or
| ||
| to_int [BatNumber.Discrete] | |||
| to_int [BatNumber.Numeric] | |||
| to_int [BatNum] | |||
| to_int [BatNativeint] |
Convert the given native integer (type
nativeint) to an
integer (type int).
| ||
| to_int [BatInt64] |
Convert the given 64-bit integer (type
int64) to an
integer (type int).
| ||
| to_int [BatInt32] |
Convert the given 32-bit integer (type
int32) to an
integer (type int).
| ||
| to_int [BatInt.Safe_int] | |||
| to_int [BatInt] | |||
| to_int [BatFloat.Safe_float] | |||
| to_int [BatFloat] | |||
| to_int [BatComplex] | to_int c is the integer part of the real part of c
| ||
| to_int [BatBool] | |||
| to_int [BatBig_int] | |||
| to_int32 [BatNativeint] |
Convert the given native integer to a
32-bit integer (type
int32).
| ||
| to_int32 [BatInt64] |
Convert the given 64-bit integer (type
int64) to a
32-bit integer (type int32).
| ||
| to_int64 [BatNativeint] |
Convert the given native integer to a
64-bit integer (type
int64).
| ||
| to_int64 [BatInt32] |
Convert the given 32-bit integer (type
int32)
to a 64-bit integer (type int64).
| ||
| to_lazy_list_filter [BatGenlex] |
Apply the lexer to a lazy list.
| ||
| to_list [BatVect.Make] |
Returns a list with the elements contained in the vect.
| ||
| to_list [BatVect] |
Returns a list with the elements contained in the vect.
| ||
| to_list [BatString.Cap] | |||
| to_list [BatString] |
Converts a string to the list of its characters.
| ||
| to_list [BatStream] |
Convert a stream to a list
| ||
| to_list [BatSplay.Map] | |||
| to_list [BatSet.PSet] |
Alias for
elements.
| ||
| to_list [BatSet.S] |
Alias for
elements.
| ||
| to_list [BatSet] |
Alias for
elements.
| ||
| to_list [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] |
Same as
to_bytes but return the result as a string instead of
a byte sequence.
| ||
| 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 [BatBytes] |
Return a new string that contains the same bytes as the given byte
sequence.
| ||
| 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.
| ||
| trim [BatBytes] |
Return a copy of the argument, without leading and trailing
whitespace.
| ||
| triml [BatSubstring] | triml k sus returns sus less its leftmost k characters; or the
empty string at the end of sus if it has less than k characters.
| ||
| trimr [BatSubstring] | trimr k sus returns sus less its rightmost k characters; or the
empty string at the beginning of sus if it has less than k
characters.
| ||
| truncate [BatUnix.LargeFile] | |||
| truncate [BatUnix] |
Truncates the named file to the given size.
| ||
| try_lock [BatRMutex] |
Same as
RMutex.lock, but does not suspend the calling thread if
the mutex is already locked: just return false immediately
in that case.
| ||
| try_lock [BatConcurrent.BaseLock] | |||
| try_lock [BatConcurrent.Lock] | |||
U | |||
| uget [BatUref] | uget ur returns the value stored in the uref ur.
| ||
| ui16s_of [BatIO.BigEndian] |
Read an enumeration of unsigned 16-bit words.
| ||
| ui16s_of [BatIO] |
Read an enumeration of unsigned 16-bit words.
| ||
| umask [BatUnix] |
Set the process's file mode creation mask, and return the previous
mask.
| ||
| uncapitalize [BatString.Cap] | |||
| uncapitalize [BatString] |
Return a copy of the argument, with the first character set to lowercase.
| ||
| uncapitalize [BatBytes] |
Return a copy of the argument, with the first byte set to
lowercase.
| ||
| uncapitalize_ascii [BatString] |
Return a copy of the argument, with the first character set to lowercase,
using the US-ASCII character set.
| ||
| uncapitalize_ascii [BatBytes] |
Return a copy of the argument, with the first character set to lowercase,
using the US-ASCII character set.
| ||
| uncombine [BatLazyList] |
Divide a list of pairs into a pair of lists.
| ||
| uncombine [BatEnum] | uncombine is the opposite of combine
| ||
| uncurry [BatTuple.Tuple5] | |||
| uncurry [BatTuple.Tuple4] | |||
| uncurry [BatTuple.Tuple3] | |||
| uncurry [BatTuple.Tuple2] | |||
| uncurry [BatPervasives] |
Convert a function which accepts a two arguments into a function
which accepts a pair of arguments.
| ||
| uncurry [BatInnerPervasives] | |||
| undef [BatGlobal] |
Reset the global value contents to undefined.
| ||
| undefined [BatPervasives] |
The undefined function.
| ||
| unfold [BatList] | unfold init f creates a list by repeatedly applying f to the
second element of its own result, starting from the initial value
init.
| ||
| unfold [BatLazyList] | unfold data next creates a (possibly infinite) lazy list from
the successive results of applying next to data, then to the
result, etc.
| ||
| unfold [BatEnum.Labels] | |||
| unfold [BatEnum] |
As
from_loop, except uses option type to signal the end of the enumeration.
| ||
| unfold_exc [BatList] |
Creates a list containing the results of sequential calls
to
f().
| ||
| union [BatSet.PSet] | union s t returns the union of s and t - the set containing
all elements in either s and t.
| ||
| union [BatSet.S] |
Set union.
| ||
| union [BatSet] | union s t returns the union of s and t - the set containing
all elements in either s and t.
| ||
| union [BatMap.PMap] | union m1 m2 merges two maps, using the comparison function of
m1.
| ||
| union [BatMap] | 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.Labels] | |||
| uniq [BatEnum] | uniq e returns a duplicate of e with repeated values
omitted (similar to unix's uniq command).
| ||
| uniq_by [BatEnum] | uniqq cmp e behaves as uniq e except it allows to specify a
comparison function.
| ||
| uniqq [BatEnum] | uniqq e behaves as uniq e except it uses physical equality
to compare consecutive elements.
| ||
| unique [BatPervasives] |
Returns an unique identifier every time it is called.
| ||
| unique [BatList] | unique cmp l returns the list l without any duplicate element.
| ||
| unique [BatLazyList] | unique cmp l returns the list l without any duplicate element.
| ||
| unique [BatInnerPervasives] | |||
| unique_cmp [BatList] |
As
unique, except comparator parameter returns an int.
| ||
| unique_eq [BatLazyList] |
as
unique except only uses an equality function.
| ||
| unique_hash [BatList] |
As
unique, except uses a hash table to cut down the expected
runtime to linear, assuming a good hash function.
| ||
| unique_value [BatInnerPervasives] | |||
| unit_big_int [BatBig_int] |
The big integer
1.
| ||
| unite [BatUref] | unite ~sel ur1 ur2 unites the urefs ur1 and ur2, selecting
the result of sel (uget ur1) (uget ur2) for the contents of
the resulting united uref.
| ||
| unite [BatBitSet] | unite s t sets s to the union of the sets s and t.
| ||
| unix [BatSys] |
True if
Sys.os_type = "Unix".
| ||
| unix_perm [BatFile] |
Create a permission from a Unix-style octal integer.
| ||
| unlink [BatUnix] |
Removes the named file
| ||
| unlock [BatRMutex] |
Unlock the given mutex.
| ||
| unlock [BatConcurrent.BaseLock] | |||
| unlock [BatConcurrent.Lock] | |||
| unpack [BatInt32] | unpack 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_of_string [BatBytes] |
Unsafely convert a shared string to a byte sequence that should
not be mutated.
| ||
| unsafe_set [BatVect.RANDOMACCESS] | |||
| unsafe_set [BatDynArray] | |||
| unsafe_set [BatBigarray.Array3] |
Like
Bigarray.Array3.set, but bounds checking is not always
performed.
| ||
| unsafe_set [BatBigarray.Array2] |
Like
Bigarray.Array2.set, but bounds checking is not always
performed.
| ||
| unsafe_set [BatBigarray.Array1] |
Like
Bigarray.Array1.set, but bounds checking is not always performed.
| ||
| unsafe_substring [BatSubstring] | unsafe_substring behaves like substring, but does not perform
any sanity check on the position and length.
| ||
| unsafe_to_string [BatBytes] |
Unsafely convert a byte sequence into a string.
| ||
| unset [BatBitSet] | unset s n sets the nth-bit in the bitset s to false.
| ||
| until [BatISet] | until x t returns the portion of t in the range min_int, x
| ||
| until [BatIMap] |
Return the sub-map of bindings in the range
min_int, x
| ||
| update [BatSet.PSet] | update x y s replace x by y in s.
| ||
| update [BatSet.S] | update x y s replace x by y in s.
| ||
| update [BatSet] | update x y s replace x by y in s.
| ||
| update [BatMap.PMap] | update k1 k2 v2 m replace the previous binding of k1 in m by
k2 associated to v2.
| ||
| update [BatMap.S] | update k1 k2 v2 m replace the previous binding of k1 in m by
k2 associated to v2.
| ||
| update [BatMap] | update k1 k2 v2 m replace the previous binding of k1 in m by
k2 associated to v2.
| ||
| update [BatFingerTree] | update t i f returns t where the i-th element is now f (get i t).
| ||
| uppercase [BatString.Cap] | |||
| uppercase [BatString] |
Return a copy of the argument, with all lowercase letters
translated to uppercase, including accented letters of the ISO
Latin-1 (8859-1) character set.
| ||
| uppercase [BatCharParser] |
Recognizes one upper-case ASCII character, including
accentuated characters.
| ||
| uppercase [BatChar] |
Convert the given character to its equivalent uppercase character.
| ||
| uppercase [BatBytes] |
Return a copy of the argument, with all lowercase letters
translated to uppercase, including accented letters of the ISO
Latin-1 (8859-1) character set.
| ||
| uppercase_ascii [BatString] |
Return a copy of the argument, with all lowercase letters
translated to uppercase, using the US-ASCII character set.
| ||
| uppercase_ascii [BatChar] |
Convert the given character to its equivalent uppercase character,
using the US-ASCII character set.
| ||
| uppercase_ascii [BatBytes] |
Return a copy of the argument, with all lowercase letters
translated to uppercase, using the US-ASCII character set.
| ||
| uppercase_latin1 [BatCharParser] |
Recognizes one upper-case Latin-1 character, including
accentuated characters.
| ||
| uref [BatUref] | uref x allocates a new uref and places the value x in it.
| ||
| usage [BatOptParse.OptParser] |
Display the usage message to the channel
chn (default is
Pervasives.stdout) and return.
| ||
| 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] | |||
| win32 [BatSys] |
True if
Sys.os_type = "Win32".
| ||
| with_dispose [BatPervasives] | with_dispose dispose f x invokes f on x, calling dispose x
when f terminates (either with a return value or an
exception).
| ||
| with_dispose [BatInnerPervasives] | |||
| with_file_in [BatFile] | with_file_in file_name f opens the file named file_name for reading,
invokes f to process the contents of that file then, once f has returned
or triggered an exception, closes the file before proceeding.
| ||
| with_file_out [BatFile] | with_file_out file_name f opens the file named file_name for writing,
invokes f to write onto that file then, once f has returned or triggered
an exception, closes the file before proceeding.
| ||
| with_label [BatReturn] |
as
label
| ||
| with_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_substring [BatUnix] |
Same as
write, but take the data from a string instead of a byte
sequence.
| ||
| write_text [BatText] |
Write a character text onto a UTF-8 encoded output.
| ||
| write_ui16 [BatInnerIO] |
Write an unsigned 16-bit word.
| ||
| write_ui16 [BatIO.BigEndian] |
Write an unsigned 16-bit word.
| ||
| write_ui16 [BatIO] |
Write an unsigned 16-bit word.
| ||
X | |||
| xor_big_int [BatBig_int] |
Bitwise logical ``exclusive or''.
| ||
Z | |||
| zero [BatNumber.Numeric] | |||
| zero [BatNum] |
Usual operations
| ||
| zero [BatNativeint] |
The native integer 0.
| ||
| zero [BatInt64] |
The 64-bit integer 0.
| ||
| zero [BatInt32] |
The 32-bit integer 0.
| ||
| zero [BatInt.Safe_int] |
The integer
0.
| ||
| zero [BatInt] |
The integer
0.
| ||
| zero [BatFloat.Safe_float] |
Floating number zero.
| ||
| zero [BatFloat] |
Floating number zero.
| ||
| zero [BatComplex] |
The complex number
0.
| ||
| zero [BatBool] | |||
| zero [BatBig_int] | |||
| zero_big_int [BatBig_int] |
The big integer
0.
| ||
| zero_plus [BatParserCo] |
Accept a (possibly empty) list of expressions.
|