| ( * ) [BatNum] | |||
| ( * ) [BatNativeint] | |||
| ( * ) [BatInt.Safe_int] |
Multiplication.
| ||
| ( * ) [BatInt] |
Multiplication.
| ||
| ( * ) [BatFloat.Safe_float] | |||
| ( * ) [BatFloat] | |||
| ( * ) [BatComplex] | |||
| ( * ) [BatBounded.NumericSig] | |||
| ( * ) [BatBool] | |||
| ( * ) [BatNumber.Infix] | |||
| ( * ) [BatBig_int] | |||
| ( ** ) [BatNum] | |||
| ( ** ) [BatNativeint] | |||
| ( ** ) [BatInt.Safe_int] | a ** b computes ab
| ||
| ( ** ) [BatInt] | a ** b computes ab
| ||
| ( ** ) [BatFloat.Safe_float] | |||
| ( ** ) [BatFloat] | |||
| ( ** ) [BatComplex] | |||
| ( ** ) [BatBool] | |||
| ( ** ) [BatNumber.Infix] | |||
| ( ** ) [BatBig_int] | |||
| ( **/ ) [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] | |||
| (+) [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] | |||
| (-) [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] | |||
| (/) [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_BASE] | |||
| 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_BASE] | |||
| 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_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] | 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] |
as
get
| ||
| at [BatSeq.Exceptionless] | |||
| at [BatSeq] | at l n returns the element at index n (starting from 0 ) in
the sequence l or raise Invalid_argument is the index is
outside of l bounds.
| ||
| at [BatList.Labels.LExceptionless] | |||
| at [BatList.Exceptionless] |
If
n is inside the bounds of l , at l n returns Ok x , where
x is the n-th element of the list l .
| ||
| at [BatList] | at l n returns the n-th element of the list l or
| ||
| at [BatLazyList.Labels.Exceptionless] | |||
| at [BatLazyList.Exceptionless] |
If
n is inside the bounds of l , at l n returns `Ok x , where
x is the n-th element of the list l .
| ||
| at [BatLazyList] | at l n returns the element at index n (starting from 0 ) in
the list l .
| ||
| at [BatDeque] | at ~backwards dq k returns the k th element of dq , from
the front if backwards is false, and from the rear if
backwards is true.
| ||
| at_index [BatRefList.Index] |
Return the element of ref list at the specified index
raise
Invalid_index if the index is outside 0 ; length-1
| ||
| 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] |
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] | 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_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.
| ||
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.
| ||
| 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
| ||
| 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.
| ||
| 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.
| ||
| comb [BatIO] |
Old name of
combine
| ||
| 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 [BatEnum] | combine transform two streams 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_BASE] | |||
| 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] | 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 [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] | 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 [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_matrix [BatArray.Cap.Labels] | |||
| create_matrix [BatArray.Cap] | |||
| create_matrix [BatArray.Labels] | |||
| create_matrix [BatArray] | |||
| create_out [BatInnerIO] |
Fully create an output by giving all the needed functions.
| ||
| create_process [BatUnix] | create_process prog args new_stdin new_stdout new_stderr
forks a new process that executes the program
in file prog , with arguments args .
| ||
| create_process_env [BatUnix] | create_process_env prog args env new_stdin new_stdout new_stderr
works as Unix.create_process , except that the extra argument
env specifies the environment passed to the program.
| ||
| create_with [BatDynArray] |
create a new dynamic array that uses the given resizer.
| ||
| current_browse [BatteriesConfig] | |||
| 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_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] | 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_BASE] | |||
| 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.
| ||
| 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_while [BatStream.StreamLabels] | |||
| drop_while [BatStream] | drop_while test stream returns the remaining suffix of take_while test
stream .
| ||
| drop_while [BatSeq] | drop_while f s returns the sequence s with the first
elements satisfying the predicate f dropped.
| ||
| drop_while [BatList.Labels] | |||
| drop_while [BatList] | drop_while p xs returns the suffix remaining after
take_while p xs .
| ||
| drop_while [BatLazyList.Labels] | |||
| drop_while [BatLazyList] | drop_while f xs returns the list xs with the first
elements satisfying the predicate f dropped.
| ||
| drop_while [BatEnum.Labels] | |||
| drop_while [BatEnum] | drop_while p e produces a new enumeration in which only
all the first elements such that f e have been junked.
| ||
| dropl [BatSubstring] | dropl p sus drops the longest prefix (left substring) of sus
all of whose characters satisfy predicate p .
| ||
| dropr [BatSubstring] | dropr p sus drops the longest suffix (right substring) of sus all
of whose characters satisfy predicate p .
| ||
| dropwhile [BatList] |
obsolete, as
BatList.drop_while
| ||
| dummy_pos [BatLexing] |
A value of type
position , guaranteed to be different from any
valid position.
| ||
| dump [BatPervasives] |
Attempt to convert a value to a string.
| ||
| dup [BatUnix] |
Return a new file descriptor referencing the same file as
the given descriptor.
| ||
| dup [BatStream] | dup stream returns a pair of streams which are identical to stream .
| ||
| dup [BatEnum] | dup stream returns a pair of streams which are identical to stream .
| ||
| dup2 [BatUnix] | dup2 fd1 fd2 duplicates fd1 to fd2 , closing fd2 if already
opened.
| ||
E | |||
| e [BatFloat] |
Euler? ...
| ||
| eager_append [BatLazyList] |
Evaluate a list and append another list after this one.
| ||
| eager_fold_right [BatLazyList] |
Eager fold_right
| ||
| eager_of_list [BatLazyList] |
Eager conversion from lists.
| ||
| edit_distance [BatString] |
Edition distance (also known as "Levenshtein distance").
| ||
| either [BatParserCo] |
Accept one of several parsers.
| ||
| elements [BatSet.PSet] |
Return the list of all elements of the given set.
| ||
| elements [BatSet.S] |
Return the list of all elements of the given set.
| ||
| elements [BatSet] |
Return the list of all elements of the given set.
| ||
| elements [BatISet] |
Returns a list of all elements in the set
| ||
| elems [BatHeap.H] | |||
| elems [BatHeap] | |||
| empty [BatVect] |
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] | |||
| 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] |
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.unite d.
| ||
| 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] | 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] | 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] | 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] | 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] | 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] | 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] | |||
| 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 .
| ||
| 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_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] |
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] | 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] | 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] |
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] | 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 [BatNativeint] | Nativeint.format fmt n return the string representation of the
native integer n in the format specified by fmt .
| ||
| format [BatInt64] | Int64.format fmt n return the string representation of the
64-bit integer n in the format specified by fmt .
| ||
| format [BatInt32] | Int32.format fmt n return the string representation of the
32-bit integer n in the format specified by fmt .
| ||
| 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_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_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.
| ||
| generic_pow [BatNumber] | |||
| 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.
| ||