| get [BatBytes] | get s n returns the byte at index n in argument s .
| ||
| get [BatBigarray.Array3] | Array3.get a x y z , also written a.{x,y,z} ,
returns the element of a at coordinates (x , y , z ).
| ||
| get [BatBigarray.Array2] | Array2.get a x y , also written a.{x,y} ,
returns the element of a at coordinates (x , y ).
| ||
| get [BatBigarray.Array1] | Array1.get a x , or alternatively a.{x} ,
returns the element of a at index x .
| ||
| get [BatBigarray.Genarray] |
Read an element of a generic big array.
| ||
| get [BatArray.Cap] | |||
| get [BatArray] | Array.get a n returns the element number n of array a .
| ||
| get12 [BatTuple.Tuple5] | |||
| get12 [BatTuple.Tuple4] | |||
| get12 [BatTuple.Tuple3] | |||
| get123 [BatTuple.Tuple5] | |||
| get123 [BatTuple.Tuple4] | |||
| get1234 [BatTuple.Tuple5] | |||
| get1235 [BatTuple.Tuple5] | |||
| get124 [BatTuple.Tuple5] | |||
| get124 [BatTuple.Tuple4] | |||
| get1245 [BatTuple.Tuple5] | |||
| get125 [BatTuple.Tuple5] | |||
| get13 [BatTuple.Tuple5] | |||
| get13 [BatTuple.Tuple4] | |||
| get13 [BatTuple.Tuple3] | |||
| get134 [BatTuple.Tuple5] | |||
| get1345 [BatTuple.Tuple5] | |||
| get135 [BatTuple.Tuple5] | |||
| get14 [BatTuple.Tuple5] | |||
| get14 [BatTuple.Tuple4] | |||
| get145 [BatTuple.Tuple5] | |||
| get15 [BatTuple.Tuple5] | |||
| get23 [BatTuple.Tuple5] | |||
| get23 [BatTuple.Tuple4] | |||
| get23 [BatTuple.Tuple3] | |||
| get234 [BatTuple.Tuple5] | |||
| get234 [BatTuple.Tuple4] | |||
| get2345 [BatTuple.Tuple5] | |||
| get235 [BatTuple.Tuple5] | |||
| get24 [BatTuple.Tuple5] | |||
| get24 [BatTuple.Tuple4] | |||
| get245 [BatTuple.Tuple5] | |||
| get25 [BatTuple.Tuple5] | |||
| get34 [BatTuple.Tuple5] | |||
| get34 [BatTuple.Tuple4] | |||
| get345 [BatTuple.Tuple5] | |||
| get35 [BatTuple.Tuple5] | |||
| get45 [BatTuple.Tuple5] | |||
| get_all_formatter_output_functions [BatFormat] |
Return the current output functions of the pretty-printer,
including line breaking and indentation functions.
| ||
| get_backtrace [BatPrintexc] | Printexc.get_backtrace () returns a string containing the same
exception backtrace that Printexc.print_backtrace would print.
| ||
| get_callstack [BatPrintexc] | Printexc.get_callstack n returns a description of the top of the
call stack on the current program point (for the current thread),
with at most n entries.
| ||
| get_cmp [BatSet.PSet] |
get the comparison function used for a polymorphic map
| ||
| get_cmp [BatMap.PMap] |
returns the comparison function of the given map
| ||
| get_dec_eq [BatIMap] |
Get the equality function used in an IMap.t
| ||
| get_ellipsis_text [BatFormat] |
Return the text of the ellipsis.
| ||
| get_exn [BatOption] | get_exn (Some x) e returns x and get_exn None e raises e .
| ||
| get_exn [BatGlobal] |
Get the global value contents - raise Global_not_initialized if not
defined.
| ||
| get_exn [BatEnum] | get_exn e returns the first element of e .
| ||
| get_flush [BatInnerIO] | |||
| get_formatter_output_functions [BatFormat] |
Return the current output functions of the pretty-printer.
| ||
| get_formatter_tag_functions [BatFormat] |
Return the current tag functions of the pretty-printer.
| ||
| get_input_id [BatInnerIO] | |||
| get_input_id [BatIO] | |||
| get_margin [BatFormat] |
Returns the position of the right margin.
| ||
| get_mark_tags [BatFormat] |
Return the current status of tags printing and tags marking.
| ||
| get_max_boxes [BatFormat] |
Returns the maximum number of boxes allowed before ellipsis.
| ||
| get_max_indent [BatFormat] |
Return the value of the maximum indentation limit (in characters).
| ||
| get_output [BatInnerIO] | |||
| get_output_id [BatInnerIO] | |||
| get_output_id [BatIO] | |||
| get_print_tags [BatFormat] | |||
| get_raw_backtrace [BatPrintexc] | Printexc.get_raw_backtrace () returns the same exception
backtrace that Printexc.print_backtrace would print, but in
a raw format.
| ||
| get_raw_backtrace_slot [BatPrintexc] | get_slot bckt pos returns the slot in position pos in the
backtrace bckt .
| ||
| get_resizer [BatDynArray] |
Get the current resizer function for a given array
| ||
| get_state [BatRandom] |
Return the current state of the generator used by the basic functions.
| ||
| get_state [BatParserCo.Source] | |||
| getaddrinfo [BatUnix] | getaddrinfo host service opts returns a list of Unix.addr_info
records describing socket parameters and addresses suitable for
communicating with the given host and service.
| ||
| getc [BatSubstring] | getc sus returns Some(c, rst) where c is the first character and
rst the remainder of sus , if sus is non-empty; otherwise returns
None .
| ||
| getcwd [BatUnix] |
Return the name of the current working directory.
| ||
| getcwd [BatSys] |
Return the current working directory of the process.
| ||
| getegid [BatUnix] |
Return the effective group id under which the process runs.
| ||
| getenv [BatUnix] |
Return the value associated to a variable in the process
environment.
| ||
| getenv [BatSys] |
Return the value associated to a variable in the process
environment.
| ||
| geteuid [BatUnix] |
Return the effective user id under which the process runs.
| ||
| getgid [BatUnix] |
Return the group id of the user executing the process.
| ||
| getgrgid [BatUnix] |
Find an entry in
group with the given group id.
| ||
| getgrnam [BatUnix] |
Find an entry in
group with the given name.
| ||
| getgroups [BatUnix] |
Return the list of groups to which the user executing the process
belongs.
| ||
| gethostbyaddr [BatUnix] |
Find an entry in
hosts with the given address.
| ||
| gethostbyname [BatUnix] |
Find an entry in
hosts with the given name.
| ||
| gethostname [BatUnix] |
Return the name of the local host.
| ||
| getitimer [BatUnix] |
Return the current status of the given interval timer.
| ||
| getlogin [BatUnix] |
Return the login name of the user executing the process.
| ||
| getnameinfo [BatUnix] | getnameinfo addr opts returns the host name and service name
corresponding to the socket address addr .
| ||
| getpeername [BatUnix] |
Return the address of the host connected to the given socket.
| ||
| getpid [BatUnix] |
Return the pid of the process.
| ||
| getppid [BatUnix] |
Return the pid of the parent process.
| ||
| getprotobyname [BatUnix] |
Find an entry in
protocols with the given name
| ||
| getprotobynumber [BatUnix] |
Find an entry in
protocols with the given protocol number.
| ||
| getpwnam [BatUnix] |
Find an entry in
passwd with the given name.
| ||
| getpwuid [BatUnix] |
Find an entry in
passwd with the given user id.
| ||
| getservbyname [BatUnix] |
Find an entry in
services with the given name.
| ||
| getservbyport [BatUnix] |
Find an entry in
services with the given service number.
| ||
| getsockname [BatUnix] |
Return the address of the given socket.
| ||
| getsockopt [BatUnix] |
Return the current status of a boolean-valued option
in the given socket.
| ||
| getsockopt_error [BatUnix] |
Return the error condition associated with the given socket,
and clear it.
| ||
| getsockopt_float [BatUnix] |
Same as
Unix.getsockopt for a socket option whose value is a
floating-point number.
| ||
| getsockopt_int [BatUnix] |
Same as
Unix.getsockopt for an integer-valued socket option.
| ||
| getsockopt_optint [BatUnix] |
Same as
Unix.getsockopt for a socket option whose value is an
int option .
| ||
| gettimeofday [BatUnix] |
Same as
Unix.time , but with resolution better than 1 second.
| ||
| getuid [BatUnix] |
Return the user id of the user executing the process.
| ||
| gmtime [BatUnix] |
Convert a time in seconds, as returned by
Unix.time , into a date and
a time.
| ||
| group [BatList] | group cmp l returns list of groups and each group consists of
elements judged equal by comparison function cmp .
| ||
| group [BatEnum] | group test e divides e into an enumeration of enumerations,
where each sub-enumeration is the longest continuous enumeration
of elements whose test results are the same.
| ||
| group_by [BatEnum] | group_by eq e divides e into an enumeration of enumerations,
where each sub-enumeration is the longest continuous enumeration
of elements that are equal, as judged by eq .
| ||
| group_consecutive [BatList] |
The
group_consecutive function takes a list and returns a list of lists such
that the concatenation of the result is equal to the argument.
| ||
| group_exec [BatFile] |
Give the permission to execute the file to the group
containing the user.
| ||
| group_read [BatFile] |
Give the permission to read the file to the group
containing the user.
| ||
| group_write [BatFile] |
Give the permission to write the file to the group
containing the user.
| ||
| gt_big_int [BatBig_int] |
Usual boolean comparisons between two big integers.
| ||
| gt_num [BatNum] | |||
H | |||
| handle_unix_error [BatUnix] | handle_unix_error f x applies f to x and returns the result.
| ||
| hard_count [BatEnum] | hard_count returns the number of remaining in elements in e ,
consuming the whole enumeration somewhere along the way.
| ||
| hash [BatInnerIO.Output] |
A hash function for outputs
| ||
| hash [BatInnerIO.Input] |
A hash function for inputs
| ||
| hash [BatHashtbl.HashedType] |
A hashing function on keys.
| ||
| hash [BatHashtbl] | Hashtbl.hash x associates a positive integer to any value of
any type.
| ||
| hash [BatChar] | |||
| hash_param [BatHashtbl] | Hashtbl.hash_param n m x computes a hash value for x , with the
same properties as for hash .
| ||
| hashcons [BatHashcons.Table] | hashcons tab k returns either k , adding it to the table
tab as a side effect, or if k is already in the table then
it returns the hashed object corresponding to that entry.
| ||
| hc0 [BatHashcons.H] | hc0 ho is the hashcode of a first constructor applied to the
hashed object ho
| ||
| hc0_ [BatHashcons.H] | hc0_ h corresponds to the hashcode of a first constructor
applied to an object of hashcode h
| ||
| hc1 [BatHashcons.H] | hc1 ho k corresponds to the hashcode of the k th
constructor applied to the hashed object ho .
| ||
| hc1_ [BatHashcons.H] | hc1_ h k corresponds to the hashcode of the k th
constructor applied to an object of hashcode h .
| ||
| hd [BatSeq.Exceptionless] | |||
| hd [BatSeq] |
Returns the first element of the sequence or raise
Invalid_argument if
the sequence is empty.
| ||
| hd [BatRefList] |
same as
first
| ||
| hd [BatList.Exceptionless] | hd l returns Some x such that x is the first element of the given
list l .
| ||
| hd [BatList] |
Similar to
first , but
| ||
| hd [BatLazyList] |
Return the first element of the given list.
| ||
| head [BatText] |
as
BatText.left
| ||
| head [BatString.Cap] | |||
| head [BatString] | |||
| head [BatFingerTree.S] | head t returns None if t is empty,
or Some hd otherwise, where hd is the first element
of the sequence.
| ||
| head [BatArray] | |||
| head_exn [BatFingerTree.S] | head_exn t returns the first element of the sequence.
| ||
| header_size [BatMarshal] |
The bytes representing a marshaled value are composed of
a fixed-size header and a variable-sized data part,
whose size can be determined from the header.
| ||
| height [BatVect] |
Returns the height (depth) of the vect.
| ||
| height [BatText] |
Returns the height (depth) of the rope.
| ||
| height [BatAvlTree] | |||
| help_option [BatOptParse.StdOpt] | help_option () returns the standard help option which
displays a usage message and exits the program when encountered
on the command line.
| ||
| hex [BatCharParser] |
Recognizes one hexadecimal digit (case-insensitive)
| ||
I | |||
| i [BatComplex] |
The complex number
i .
| ||
| iapp [BatEnum] | |||
| icompare [BatString.Cap] | |||
| icompare [BatString] |
Compare two strings, case-insensitive.
| ||
| icons [BatEnum] | |||
| id [BatOo] |
Return an integer identifying this object, unique for
the current execution of the program.
| ||
| ident [BatGenlex.Languages.Make] |
Accepts any non-reserved identifier/operator.
| ||
| ident_letter [BatGenlex.Languages.Definition] | |||
| ident_start [BatGenlex.Languages.Definition] | |||
| identifier [BatGenlex.Languages.Make] | |||
| identity [BatPervasives] |
The identity function.
| ||
| identity [BatInnerPervasives] | |||
| ifprintf [BatPrintf] |
As
BatPrintf.fprintf but doesn't actually print anything.
| ||
| ifprintf [BatFormat] |
Same as
fprintf above, but does not print anything.
| ||
| ignore_exceptions [BatPervasives] | ignore_exceptions f x invokes f on x , ignoring both the returned value
and the exceptions that may be raised.
| ||
| ignore_exceptions [BatInnerPervasives] | |||
| ignore_ok [BatPervasives] | ignore_ok (f x) ignores the result of f x if it's ok, but
throws the exception contained if Bad is returned.
| ||
| ignore_ok [BatInnerPervasives] | |||
| ignore_one_plus [BatParserCo] |
Ignore a (non-empty) list of expressions.
| ||
| ignore_zero_plus [BatParserCo] |
Ignore a (possibly empty) list of expressions.
| ||
| ikfprintf [BatFormat] |
Same as
kfprintf above, but does not print anything.
| ||
| implode [BatText] | implode cs returns a rope resulting from concatenating
the characters in the list cs .
| ||
| implode [BatString.Cap] | |||
| implode [BatString] | implode cs returns a string resulting from concatenating
the characters in the list cs .
| ||
| in_channel_of_descr [BatUnix] |
Create an input channel reading from the given descriptor.
| ||
| in_place_mirror [BatString] | |||
| incr_num [BatNum] | |||
| incr_option [BatOptParse.StdOpt] |
Exactly identical to
count_option ~dest:dest ~increment:1 () .
| ||
| indented_formatter [BatOptParse.Formatter] |
Create an "indented" formatter with the given options.
| ||
| index [BatText] | index s c returns the position of the leftmost
occurrence of character c in rope s .
| ||
| index [BatSubstring] | index sus c returns the index of the first occurence of c in sus or
| ||
| index [BatString.Cap.Exceptionless] | |||
| index [BatString.Cap] | |||
| index [BatString.Exceptionless] | index s c returns Some p , the position of the leftmost
occurrence of character c in string s or
None if c does not occur in s .
| ||
| index [BatString] | String.index s c returns the character number of the first
occurrence of character c in string s .
| ||
| index [BatRefList.Index] |
Return the index (position : 0 starting) of an element in
a ref list, using the specified comparator
raise
Not_found if no element was found
| ||
| index [BatBytes] | index s c returns the index of the first occurrence of byte c
in s .
| ||
| index_from [BatText] | index_from r i c returns the character number of the
first occurrence of character c in rope r after position i .
| ||
| index_from [BatSubstring] | index_from sus i c returns the index of the first occurence of c in
sus after the index i or
| ||
| index_from [BatString.Cap.Exceptionless] | |||
| index_from [BatString.Cap] | |||
| index_from [BatString.Exceptionless] |
Same as
String.Exceptionless.index , but start
searching at the character position given as second argument.
| ||
| index_from [BatString] | String.index_from s i c returns the character number of the
first occurrence of character c in string s after position i .
| ||
| index_from [BatBytes] | index_from s i c returns the index of the first occurrence of
byte c in s after position i .
| ||
| index_of [BatRefList.Index] |
Return the index (position : 0 starting) of an element in
a ref list, using ( = ) for testing element equality
raise
Not_found if no element was found
| ||
| index_of [BatList] | index_of e l returns the index of the first occurrence of e
in l , or None if there is no occurrence of e in l
| ||
| index_of [BatLazyList] | index_of e l returns the index of the first occurrence of e
in l , or None if there is no occurrence of e in l
| ||
| index_of [BatDynArray] | index_of f darr returns the index of the first element x in darr such
as f x returns true or raise Not_found if not found.
| ||
| index_ofq [BatList] | index_ofq e l behaves as index_of e l except it uses
physical equality
| ||
| index_ofq [BatLazyList] | index_ofq e l behaves as index_of e l except it uses
physical equality
| ||
| inet6_addr_any [BatUnix] |
A special IPv6 address, for use only with
bind , representing
all the Internet addresses that the host machine possesses.
| ||
| inet6_addr_loopback [BatUnix] |
A special IPv6 address representing the host machine (
::1 ).
| ||
| inet_addr_any [BatUnix] |
A special IPv4 address, for use only with
bind , representing
all the Internet addresses that the host machine possesses.
| ||
| inet_addr_loopback [BatUnix] |
A special IPv4 address representing the host machine (
<IP_ADDRESS> ).
| ||
| inet_addr_of_string [BatUnix] |
Conversion from the printable representation of an Internet
address to its internal representation.
| ||
| infinity [BatFloat.Safe_float] |
Positive infinity.
| ||
| infinity [BatFloat] |
Positive infinity.
| ||
| inherit_in [BatInnerIO] |
Simplified and optimized version of
BatInnerIO.wrap_in whenever only
one input appears as dependency.
| ||
| inherit_out [BatInnerIO] |
Simplified and optimized version of
BatInnerIO.wrap_out whenever only
one output appears as dependency.
| ||
| init [BatVect] | init n f returns a fresh vect of length n ,
with element number i initialized to the result of f i .
| ||
| init [BatUTF8] | init len f
returns a new string which contains len Unicode characters.
| ||
| init [BatText] | init l f returns the rope of length l with the chars f 0 , f
1 , f 2 ...
| ||
| init [BatString.Cap] | |||
| init [BatString] | init l f returns the string of length l with the chars
f 0 , f 1 , f 2 ...
| ||
| init [BatSeq] | init n f returns the sequence returning the results of f 0 ,
f 1 ....
| ||
| init [BatRandom] |
Initialize the generator, using the argument as a seed.
| ||
| init [BatLogger] | init name_level_list formatter initializes the logging
system enabling the specified levels for each named
logger.
| ||
| init [BatList.Labels] | |||
| init [BatList] |
Similar to
Array.init , init n f returns the list containing
the results of (f 0),(f 1)....
| ||
| init [BatLazyList] |
Similar to
Array.init , init n f returns the lazy list
containing the results of (f 0),(f 1)....
| ||
| init [BatFingerTree.S] | init t returns None if t is empty,
or Some init where init is the sequence t where the last element
has been removed.
| ||
| init [BatEnum.Labels] | |||
| init [BatEnum] | init n f creates a new enumeration over elements
f 0, f 1, ..., f (n-1)
| ||
| init [BatDynArray] | init n f returns an array of n elements filled with values
returned by f 0 , f 1, ... f (n-1) .
| ||
| init [BatBytes] | Bytes.init n f returns a fresh byte sequence of length n , with
character i initialized to the result of f i (in increasing
index order).
| ||
| init [BatArray.Cap.Labels] | |||
| init [BatArray.Cap] | |||
| init [BatArray.Labels] | |||
| init [BatArray] | Array.init n f returns a fresh array of length n ,
with element number i initialized to the result of f i .
| ||
| init_exn [BatFingerTree.S] | init_exn t returns the sequence t where the last element
has been removed.
| ||
| init_from_string [BatLogger] | init_from_string name_level_string formatter initializes the
logging system enabling the specified levels for each named
logger.
| ||
| initgroups [BatUnix] | initgroups user group initializes the group access list by
reading the group database /etc/group and using all groups of
which user is a member.
| ||
| input [BatPervasives] | input ic buf pos len reads up to len characters from
the given channel ic , storing them in string buf , starting at
character number pos .
| ||
| input [BatMarshal] | input inp reads from inp the
byte representation of a structured value, as produced by
one of the Marshal.to_* functions, and reconstructs and
returns the corresponding value.
| ||
| input [BatInnerIO] | input i s p l reads up to l characters from the given input, storing
them in string s , starting at character number p .
| ||
| input [BatIO] | input i s p l reads up to l characters from the given input,
storing them in string s , starting at character number p .
| ||
| input [BatDigest] |
Read a digest from the given input.
| ||
| input_all [BatPervasives] |
Return the whole contents of an input channel as a single
string.
| ||
| input_binary_float [BatPervasives] |
Read a float encoded in binary format (8 bytes, IEEE 754 double format)
from the given input channel.
| ||
| input_binary_int [BatPervasives] |
Read an integer encoded in binary format (4 bytes, big-endian)
from the given input channel.
| ||
| input_byte [BatPervasives] |
Same as
Pervasives.input_char , but return the 8-bit integer representing
the character.
| ||
| input_channel [BatInnerIO] |
Create an input that will read from a channel.
| ||
| input_char [BatPervasives] |
Read one character from the given input channel.
| ||
| input_chars [BatPervasives] |
Returns an enumeration over characters of an input channel.
| ||
| input_file [BatPervasives] |
returns the data of a given filename.
| ||
| input_line [BatPervasives] |
Read characters from the given input channel, until a
newline character is encountered.
| ||
| input_lines [BatPervasives] |
Returns an enumeration over lines of an input channel, as read by the
input_line function.
| ||
| input_list [BatPervasives] |
Returns the list of lines read from an input channel.
| ||
| input_of_descr [BatUnix] |
Create an
input reading from the given descriptor.
| ||
| input_string [BatInnerIO] |
Create an input that will read from a string.
| ||
| input_value [BatPervasives] |
Read the representation of a structured value, as produced
by
BatPervasives.output_value , and return the corresponding value.
| ||
| insert [BatVect] | insert n r u returns a copy of the u vect where r has been
inserted between the elements with index n and n + 1 in the
original vect.
| ||
| insert [BatText] | insert n r u returns a copy of the u rope where r has been
inserted between the characters with index n and n + 1 in the
original rope.
| ||
| insert [BatHeap.H] |
See
BatHeap.add .
| ||
| insert [BatHeap] |
Insert an element into the heap.
| ||
| insert [BatDynArray] | insert darr idx v inserts v into darr at index idx .
| ||
| insert [BatArray] | insert xs x i returns a copy of xs except the value x is
inserted in position i (and all later indices are shifted to the
right).
| ||
| int [BatRandom.Incubator.Private_state_enums.State] | |||
| int [BatRandom.State] | |||
| int [BatRandom] | Random.int bound returns a random integer between 0 (inclusive)
and bound (exclusive).
| ||
| int [BatBigarray] |
See
Bigarray.char .
| ||
| int16_signed [BatBigarray] |
See
Bigarray.char .
| ||
| int16_unsigned [BatBigarray] |
See
Bigarray.char .
| ||
| int32 [BatRandom.Incubator.Private_state_enums.State] | |||
| int32 [BatRandom.State] | |||
| int32 [BatRandom] | Random.int32 bound returns a random integer between 0 (inclusive)
and bound (exclusive).
| ||
| int32 [BatBigarray] |
See
Bigarray.char .
| ||
| int32_of_big_int [BatBig_int] |
Convert a big integer to a 32-bit integer.
| ||
| int64 [BatRandom.Incubator.Private_state_enums.State] | |||
| int64 [BatRandom.State] | |||
| int64 [BatRandom] | Random.int64 bound returns a random integer between 0 (inclusive)
and bound (exclusive).
| ||
| int64 [BatBigarray] |
See
Bigarray.char .
| ||
| int64_of_big_int [BatBig_int] |
Convert a big integer to a 64-bit integer.
| ||
| int8_signed [BatBigarray] |
See
Bigarray.char .
| ||
| int8_unsigned [BatBigarray] |
See
Bigarray.char .
| ||
| int_callback [BatOptParse.StdOpt] | int_callback ?metavar f returns an option which takes a single
integer argument and calls f with that argument when encountered
on the command line.
| ||
| int_dynarray [BatteriesPrint] | |||
| int_enum [BatteriesPrint] | |||
| int_int_pmap [BatteriesPrint] | |||
| int_of [BatUChar] |
Alias of
code
| ||
| int_of_big_int [BatBig_int] |
Convert a big integer to a small integer (type
int ).
| ||
| int_of_num [BatNum] | |||
| int_option [BatOptParse.StdOpt] | int_option ?default ?metavar () returns an option which takes
a single integer argument.
| ||
| int_pset [BatteriesPrint] | |||
| int_set [BatteriesPrint] | |||
| int_str_pmap [BatteriesPrint] | |||
| integer [BatGenlex.Languages.Make] |
Parse an integer.
| ||
| integer_num [BatNum] | |||
| inter [BatSet.S] |
Set intersection.
| ||
| inter [BatISet] |
Compute the intersection of two sets.
| ||
| inter [BatBitSet] | inter s t returns the intersection of sets s and t .
| ||
| interactive [BatSys] |
This reference is initially set to
false in standalone
programs and to true if the code is being executed under
the interactive toplevel system ocaml .
| ||
| interleave [BatList] | interleave ~first ~last sep [a0;a1;a2;...;an] returns
first; a0; sep; a1; sep; a2; sep; ...; sep; an; last
| ||
| interleave [BatEnum] | interleave enums creates a new enumeration from an array of enumerations.
| ||
| intersect [BatSet.PSet] | intersect s t returns a new set of those elements that are in
both s and t .
| ||
| intersect [BatSet] | intersect s t returns a new set of those elements that are in
both s and t .
| ||
| intersect [BatMap.PMap] | intersect merge_f m1 m2 returns a map with bindings only for
keys bound in both m1 and m2 , and with k bound to merge_f
v1 v2 , where v1 and v2 are k 's bindings in m1 and m2 .
| ||
| intersect [BatMap] | intersect merge_f m1 m2 returns a map with bindings only for
keys bound in both m1 and m2 , and with k bound to merge_f
v1 v2 , where v1 and v2 are k 's bindings in m1 and m2 .
| ||
| intersect [BatBitSet] | intersect s t sets s to the intersection of the sets s and t .
| ||
| inv [BatComplex] |
Multiplicative inverse (
1/z ).
| ||
| invpi [BatFloat] | 1. /. pi
| ||
| invpi2 [BatFloat] | 2. /. pi
| ||
| invsqrt2 [BatFloat] | 1. /. sqrt 2.
| ||
| is_absolute [BatPathGen.PathType] | |||
| is_ascii [BatUChar] | true if the char is a regular ascii char, i.e.
| ||
| is_bad [BatResult] | is_bad (Bad _) is true , otherwise false
| ||
| is_digit [BatChar] |
Determine if a character represents a digit.
| ||
| is_directory [BatUnix] | is_directory filename returns true if filename refers to a directory (or symlink of a directory)
| ||
| is_directory [BatSys] |
Returns
true if the given name refers to a directory,
false if it refers to another kind of file.
| ||
| is_empty [BatVect] |
Returns whether the vect is empty or not.
| ||
| is_empty [BatText] |
Returns whether the rope is empty or not.
| ||
| is_empty [BatSubstring] | isEmpty (s, i, n) true if the substring is empty (that is,
n = 0 ).
| ||
| is_empty [BatString.Cap] | |||
| is_empty [BatString] | is_empty s returns true if s is the empty string, false
otherwise.
| ||
| is_empty [BatStream] | is_empty stream tests whether stream is empty.
| ||
| is_empty [BatStack] |
Return
true if the given stack is empty, false otherwise.
| ||
| is_empty [BatSet.PSet] |
Test whether a set is empty or not.
| ||
| is_empty [BatSet.S] |
Test whether a set is empty or not.
| ||
| is_empty [BatSet] |
Test whether a set is empty or not.
| ||
| is_empty [BatSeq] | is_empty e returns true if e does not contains any
element.
| ||
| is_empty [BatRefList] |
Return
true if a ref list is empty
| ||
| is_empty [BatQueue] |
Return
true if the given queue is empty, false otherwise.
| ||
| is_empty [BatMultiPMap] |
returns true if the map is empty.
| ||
| is_empty [BatMultiMap] |
returns true if the map is empty.
| ||
| is_empty [BatMap.PMap] |
returns true if the map is empty.
| ||
| is_empty [BatMap.S] |
Test whether a map is empty or not.
| ||
| is_empty [BatMap] |
returns true if the map is empty.
| ||
| is_empty [BatList] | is_empty e returns true if e does not contains any element.
| ||
| is_empty [BatLazyList] |
Returns
true if the list is empty, false otherwise.
| ||
| is_empty [BatISet] |
Test whether a set is empty, returns
true if the set is empty.
| ||
| is_empty [BatIMap] |
Test whether a map is empty (i.e.
| ||
| is_empty [BatHashtbl.Cap] | |||
| is_empty [BatHashtbl.S] | |||
| is_empty [BatHashtbl] | Hashtbl.is_empty tbl returns true if there are no bindings
in tbl , false otherwise.
| ||
| is_empty [BatFingerTree.S] | is_empty t returns true when the sequence has no elements.
| ||
| is_empty [BatEnum] | is_empty e returns true if e does not contains any element.
| ||
| is_empty [BatDeque] | is_empty dq returns false iff dq has no elements.
| ||
| is_empty [BatAvlTree] | |||
| is_exn [BatResult] | is_exn e1 r is true iff r is Bad e2 with e1=e2
| ||
| is_finite [BatFloat] | is_finite f returns true if f is not nan or +/- infinity ,
false otherwise.
| ||
| is_int_big_int [BatBig_int] |
Test whether the given big integer is small enough to
be representable as a small integer (type
int )
without loss of precision.
| ||
| is_integer [BatNum] | is_integer x returns true if x represents an integer value,
false otherwise
| ||
| is_integer_num [BatNum] | |||
| is_latin1 [BatChar] |
Determine if a character is a Latin 1 letter.
| ||
| is_letter [BatChar] |
Determine if a character represents a ASCII letter.
| ||
| is_lowercase [BatChar] |
Determine if a character is lowercase ASCII.
| ||
| is_lowercase_latin1 [BatChar] |
Determine if a character is lowercase Latin 1.
| ||
| is_nan [BatFloat.Safe_float] | is_nan f returns true if f is nan , false otherwise.
| ||
| is_nan [BatFloat] | is_nan f returns true if f is nan , false otherwise.
| ||
| is_newline [BatChar] |
Determine if a character is a newline.
| ||
| is_none [BatOption] | is_none None returns true otherwise it returns false .
| ||
| is_ok [BatResult] | is_ok (Ok _) is true , otherwise false .
| ||
| is_prefix [BatSubstring] | is_prefix s1 s2 is true if s1 is a prefix of s2 .
| ||
| is_raise [BatPrintexc.Slot] | is_raise slot is true when slot refers to a raising
point in the code, and false when it comes from a simple
function call.
| ||
| is_relative [BatPathGen.PathType] | |||
| is_set [BatOptParse.Opt] |
Find out if the option has a value (either by default or
from the command line).
| ||
| is_some [BatOption] | is_some (Some x) returns true otherwise it returns false .
| ||
| is_sorted_by [BatArray] | |||
| is_special [BatFloat] | is_special f returns true if f is nan or +/- infinity ,
false otherwise.
| ||
| is_symbol [BatChar] |
Determine if a character represents a (OCaml-style)
symbol.
| ||
| is_uppercase [BatChar] |
Determine if a character is uppercase ASCII.
| ||
| is_uppercase_latin1 [BatChar] |
Determine if a character is uppercase Latin 1.
| ||
| is_whitespace [BatChar] |
Determine if a character is a whitespace.
| ||
| isatty [BatUnix] |
Return
true if the given file descriptor refers to a terminal or
console window, false otherwise.
| ||
| isdef [BatGlobal] |
Return
true if the global value has been set.
| ||
| ising [BatEnum] | |||
| iter [BatVect] | iter f r applies f to all the elements in the r vect,
in order.
| ||
| iter [BatUTF8] | iter f s
applies f to all Unicode characters in s .
| ||
| iter [BatText] | iter f r applies f to all the characters in the r rope,
in order.
| ||
| iter [BatSubstring] | iter f sus applies f to all characters of sus , from left to
right.
| ||
| iter [BatString.Cap] | |||
| iter [BatString] | String.iter f s applies function f in turn to all
the characters of s .
| ||
| iter [BatStream.StreamLabels] | |||
| iter [BatStream] | Stream.iter f s scans the whole stream s, applying function f
in turn to each stream element encountered.
| ||
| iter [BatStack] | iter f s applies f in turn to all elements of s ,
from the element at the top of the stack to the element at the
bottom of the stack.
| ||
| iter [BatSet.PSet] | iter f s applies f in turn to all elements of s .
| ||
| iter [BatSet.S.Labels] | |||
| iter [BatSet.S] | iter f s applies f in turn to all elements of s .
| ||
| iter [BatSet] | iter f s applies f in turn to all elements of s .
| ||
| iter [BatSeq] | iter f s applies f to all the elements of the sequence.
| ||
| iter [BatRefList] |
Apply the given function to all elements of the
ref list, in respect with the order of the list
| ||
| iter [BatQueue] | iter f q applies f in turn to all elements of q ,
from the least recently entered to the most recently entered.
| ||
| iter [BatPervasives] |
Imperative loop on an enumeration.
| ||
| iter [BatPathGen.StringType] | |||
| iter [BatMultiPMap] | iter f m applies f to all bindings in map m .
| ||
| iter [BatMultiMap] | iter f m applies f to all bindings in map m .
| ||
| iter [BatMap.PMap] | iter f m applies f to all bindings in map m .
| ||
| iter [BatMap.S.Labels] | |||
| iter [BatMap.S] | iter f m applies f to all bindings in map m .
| ||
| iter [BatMap] | iter f m applies f to all bindings in map m .
| ||
| iter [BatList.Labels] | |||
| iter [BatList] | List.iter f [a0; a1; ...; an] applies function f in turn to
a0; a1; ...; an .
| ||
| iter [BatLazyList.Labels] | |||
| iter [BatLazyList] |
Eager iteration
| ||
| iter [BatInnerWeaktbl] | Weaktbl.iter f tbl applies f to all bindings in table tbl .
| ||
| iter [BatISet] | iter f t calls f once for each element of t
| ||
| iter [BatIMap] | iter f t calls f on every binding
| ||
| iter [BatHashtbl.Cap.Labels] | |||
| iter [BatHashtbl.Cap] | |||
| iter [BatHashtbl.S.Labels] | |||
| iter [BatHashtbl.S] | |||
| iter [BatHashtbl.Labels] | |||
| iter [BatHashtbl] | Hashtbl.iter f tbl applies f to all bindings in table tbl .
| ||
| iter [BatHashcons.Table] | iter f tab applies f to every live hashed object in the
table tab .
| ||
| iter [BatFingerTree.S] | iter is equivalent to List.iter .
| ||
| iter [BatEnum.Labels] | |||
| iter [BatEnum] | iter f e calls the function f with each elements of e in turn.
| ||
| iter [BatDynArray] | iter f darr calls the function f on every element of darr .
| ||
| iter [BatDllist] | iter f n Apply f to every element in the list, starting at n .
| ||
| iter [BatDeque] | iter f dq calls f x on each element x of dq .
| ||
| iter [BatBytes] | iter f s applies function f in turn to all the bytes of s .
| ||
| iter [BatBigarray.Genarray] | iter f a applies function f in turn to all
the elements of a .
| ||
| iter [BatAvlTree] | |||
| iter [BatArray.Cap.Labels] | |||
| iter [BatArray.Cap] | |||
| iter [BatArray.Labels] | |||
| iter [BatArray] | Array.iter f a applies function f in turn to all
the elements of a .
| ||
| iter2 [BatSeq] | iter2 f s1 s2 iterates on elements of s1 and s2 pairwise, and
stops when it meets the end of s1 or s2
| ||
| iter2 [BatList.Labels] | |||
| iter2 [BatList] | List.iter2 f [a0; a1; ...; an] [b0; b1; ...; bn] calls in turn
f a0 b0; f a1 b1; ...; f an bn .
| ||
| iter2 [BatLazyList.Labels] | |||
| iter2 [BatLazyList] | iter2 f [^ a0; ...; an ^] [^ b0; ...; bn ^] calls in turn
f a0 b0; ...; f an bn .
| ||
| iter2 [BatEnum.Labels] | |||
| iter2 [BatEnum] | iter2 f e1 e2 calls the function f with the next elements of e1 and
e2 repeatedly until one of the two enumerations ends.
| ||
| iter2 [BatArray.Cap.Labels] | |||
| iter2 [BatArray.Cap] | |||
| iter2 [BatArray.Labels] | |||
| iter2 [BatArray] | Array.iter2 f [|a0; a1; ...; an|] [|b0; b1; ...; bn|]
performs calls f a0 b0; f a1 b1; ...; f an bn in that order.
| ||
| iter2i [BatEnum.Labels] | |||
| iter2i [BatEnum] | |||
| iter2i [BatArray.Cap.Labels] | |||
| iter2i [BatArray.Cap] | |||
| iter2i [BatArray.Labels] | |||
| iter2i [BatArray] | Array.iter2i f [|a0; a1; ...; an|] [|b0; b1; ...; bn|]
performs calls f 0 a0 b0; f 1 a1 b1; ...; f n an bn in that
order.
| ||
| iter_range [BatISet] | iter_range f t calls f once for each contiguous range of t .
| ||
| iter_range [BatIMap] | iter_range f t calls f on every contiguous range.
| ||
| iter_right [BatFingerTree.S] | iter_right is equivalent to List.iter o List.rev .
| ||
| iteri [BatVect] |
Operates like iter, but also passes the index of the character
to the given function.
| ||
| iteri [BatText] |
Operates like
iter , but also passes the index of the character
to the given function.
| ||
| iteri [BatSubstring] |
Same as
BatSubstring.iter , but the
function is applied to the index of the element as first argument
(counting from 0), and the character itself as second argument.
| ||
| iteri [BatString] |
Same as
String.iter , but the
function is applied to the index of the element as first argument
(counting from 0), and the character itself as second argument.
| ||
| iteri [BatSeq] | iteri f s is the same as iter f s , but f is given the index
of each element (starting at 0).
| ||
| iteri [BatPathGen.StringType] | |||
| iteri [BatList.Labels] | |||
| iteri [BatList] | iteri f l will call (f 0 a0); (f 1 a1) ... (f n an) where
a0..an are the elements of the list l .
| ||
| iteri [BatLazyList.Labels] | |||
| iteri [BatLazyList] |
Eager iteration, with indices
| ||
| iteri [BatEnum.Labels] | |||
| iteri [BatEnum] | |||
| iteri [BatDynArray] | iter f darr calls the function f on every element of darr .
| ||
| iteri [BatDeque] | iteri f dq calls f n x on each element x of dq .
| ||
| iteri [BatBytes] |
Same as
Bytes.iter , but the function is applied to the index of
the byte as first argument and the byte itself as second
argument.
| ||
| iteri [BatBigarray.Genarray] |
Same as
BatBigarray.Genarray.iter , but the function is applied to the index of
the element as the first argument, and the element itself as
the second argument.
| ||
| iteri [BatArray.Cap.Labels] | |||
| iteri [BatArray.Cap] | |||
| iteri [BatArray.Labels] | |||
| iteri [BatArray] |
Same as
Array.iter , but the
function is applied to the index of the element as first argument,
and the element itself as second argument.
| ||
J | |||
| join [BatText] |
Same as
BatText.concat
| ||
| join [BatString.Cap] | |||
| join [BatString] |
Same as
BatString.concat
| ||
| join [BatPathGen.PathType] |
Create a path from given components.
| ||
| junk [BatStream] |
Remove the first element of the stream, possibly unfreezing
it before.
| ||
| junk [BatPervasives] | junk e removes the first element from the enumeration, if any.
| ||
| junk [BatEnum] | junk e removes the first element from the enumeration, if any.
| ||
K | |||
| kahan_sum [BatList] | kahan_sum l returns a numerically-accurate sum of the floats of
l .
| ||
| kahan_sum [BatEnum] | kahan_sum l returns a numerically-accurate sum of the floats of
l .
| ||
| kahan_sum [BatArray] | kahan_sum l returns a numerically-accurate
sum of the floats of l .
| ||
| kbprintf [BatPrintf] |
Same as
bprintf , but instead of returning immediately,
passes the buffer to its first argument at the end of printing.
| ||
| kbprintf2 [BatPrintf] |
Same as
bprintf2 , but instead of returning immediately,
passes the buffer to its first argument at the end of printing.
| ||
| keep [BatDynArray] | keep p darr removes in place all the element x of darr
such that p x = false
| ||
| keys [BatMap.PMap] |
Return an enumeration of all the keys of a map.
| ||
| keys [BatMap.S] |
Return an enumeration of all the keys of a map.
| ||
| keys [BatMap] |
Return an enumeration of all the keys of a map.
| ||
| keys [BatHashtbl.Cap] | |||
| keys [BatHashtbl.S] | |||
| keys [BatHashtbl] |
Return an enumeration of all the keys of a hashtable.
| ||
| keyword [BatGenlex.Languages.Make] | |||
| kfprintf [BatPrintf] |
Same as
fprintf , but instead of returning immediately, passes the output to its first
argument at the end of printing.
| ||
| kfprintf [BatFormat] |
Same as
fprintf above, but instead of returning immediately,
passes the formatter to its first argument at the end of printing.
| ||
| kill [BatUnix] | kill pid sig sends signal number sig to the process
with id pid .
| ||
| kind [BatBigarray.Array3] |
Return the kind of the given big array.
| ||
| kind [BatBigarray.Array2] |
Return the kind of the given big array.
| ||
| kind [BatBigarray.Array1] |
Return the kind of the given big array.
| ||
| kind [BatBigarray.Genarray] |
Return the kind of the given big array.
| ||
| kind_size_in_bytes [BatBigarray] | kind_size_in_bytes k is the number of bytes used to store
an element of type k .
| ||
| kprintf [BatPrintf] | |||
| kprintf [BatFormat] |
A deprecated synonym for
ksprintf .
| ||
| kscanf [BatScanf] |
Same as
Scanf.bscanf , but takes an additional function argument
ef that is called in case of error: if the scanning process or
some conversion fails, the scanning function aborts and calls the
error handling function ef with the scanning buffer and the
exception that aborted the scanning process.
| ||
| ksprintf [BatPrintf] |
Same as
sprintf above, but instead of returning the string,
passes it to the first argument.
| ||
| ksprintf [BatFormat] |
Same as
sprintf above, but instead of returning the string,
passes it to the first argument.
| ||
| ksprintf2 [BatPrintf] |
Same as
sprintf2 above, but instead of returning the string,
passes it to the first argument.
| ||
| kwd [BatGenlex.Languages.Make] |
Accepts any identifier.
| ||
L | |||
| label [BatReturn] | label f creates a new label x and invokes
f x .
| ||
| label [BatParserCo] |
Give a name to a parser, for debugging purposes.
| ||
| lapp [BatEnum] | |||
| last [BatVect] |
These return the first and last values in the vector
| ||
| last [BatUTF8] |
The position of the head of the last Unicode character.
| ||
| last [BatSeq.Exceptionless] | |||
| last [BatSeq] |
Returns the last element of the sequence, or raise
Invalid_argument if
the sequence is empty.
| ||
| last [BatRefList] |
Returns the last element - O(n) or
raises
Empty_list if the ref list is empty
| ||
| last [BatList.Exceptionless] | last l returns either Some x where x is the last element of the list, or None if
the list is empty.
| ||
| last [BatList] |
Returns the last element of the list, or
| ||
| last [BatLazyList] |
Returns the last element of the list.
| ||
| last [BatFingerTree.S] | last t returns None if t is empty,
or Some hd otherwise, where hd is the last element
of the sequence.
| ||
| last [BatDynArray] | last darr returns the last element of darr .
| ||
| last_exn [BatFingerTree.S] | last_exn t returns the last element of the sequence.
| ||
| latin1 [BatCharParser] |
Recognizes one lower- or upper-case Latin1 character, including
accentuated characters.
| ||
| layout [BatBigarray.Array3] |
Return the layout of the given big array.
| ||
| layout [BatBigarray.Array2] |
Return the layout of the given big array.
| ||
| layout [BatBigarray.Array1] |
Return the layout of the given big array.
| ||
| layout [BatBigarray.Genarray] |
Return the layout of the given big array.
| ||
| lazy_fold_right [BatLazyList] |
Lazy fold_right
lazy_fold_right f (Cons (a0, Cons (a1, Cons (a2, nil)))) b is
lazy (f a0 (lazy (f a1 (lazy (f a2 b))))) .
| ||
| lchop [BatText] |
Returns the same rope but without the first character.
| ||
| lchop [BatString.Cap] | |||
| lchop [BatString] |
Returns the same string but without the first
n characters.
| ||
| lcons [BatEnum] | |||
| ldexp [BatFloat.Safe_float] | ldexp x n returns x *. 2 ** n .
| ||
| ldexp [BatFloat] | ldexp x n returns x *. 2 ** n .
| ||
| le_big_int [BatBig_int] | |||
| le_num [BatNum] | |||
| left [BatText] | left r len returns the rope containing the len first characters of r
| ||
| left [BatString.Cap] | |||
| left [BatString] | left r len returns the string containing the len first
characters of r .
| ||
| left [BatArray] | left r len returns the array containing the len first
characters of r .
| ||
| left_branch [BatAvlTree] | |||
| length [BatVect] |
Returns the length of the vect (
O(1) ).
| ||
| length [BatUTF8] | length s returns the number of Unicode characters contained in s
| ||
| length [BatText] |
Returns the length of the rope (
O(1) ).
| ||
| length [BatSubstring] |
Equivalent to
BatSubstring.size .
| ||
| length [BatString.Cap] | |||
| length [BatString] |
Return the length (number of characters) of the given string.
| ||
| length [BatStack] |
Return the number of elements in a stack.
| ||
| length [BatSeq] |
Return the number of elements of the given sequence.
| ||
| length [BatRefList] |
Returns the number of elements - O(n)
| ||
| length [BatQueue] |
Return the number of elements in a queue.
| ||
| length [BatPathGen.StringType] |
Length - number of indexing units
| ||
| length [BatList] |
Return the length (number of elements) of the given list.
| ||
| length [BatLazyList] |
Return the length (number of elements) of the given list.
| ||
| length [BatInnerWeaktbl] | Weaktbl.length tbl returns the number of bindings in tbl .
| ||
| length [BatHashtbl.Cap] | |||
| length [BatHashtbl.S] | |||
| length [BatHashtbl] | Hashtbl.length tbl returns the number of bindings in tbl .
| ||
| length [BatDynArray] |
Return the number of elements in the array.
| ||
| length [BatDllist] |
Returns the length of the list.
| ||
| length [BatBytes] |
Return the length (number of t) of the argument.
| ||
| length [BatBuffer] |
Return the number of characters currently contained in the buffer.
| ||
| length [BatArray.Cap] | |||
| length [BatArray] |
Return the length (number of elements) of the given array.
| ||
| letter [BatPathGen.StringType.Parse] | |||
| letter [BatCharParser] |
Recognizes one lower- or upper-case ASCII character, including
accentuated characters.
| ||
| level [BatLog.Make_lev] | |||
| level [BatLog.Easy] |
Set this ref to the lowest level of log you want logged.
| ||
| level_of_name [BatLogger] | level_of_name str returns the level associated with str .
| ||
| lexeme [BatLexing] | Lexing.lexeme lexbuf returns the string matched by
the regular expression.
| ||
| lexeme_char [BatLexing] | Lexing.lexeme_char lexbuf i returns character number i in
the matched string.
| ||
| lexeme_end [BatLexing] | Lexing.lexeme_end lexbuf returns the offset in the input stream
of the character following the last character of the matched
string.
| ||
| lexeme_end_p [BatLexing] |
Like
lexeme_end , but return a complete position instead
of an offset.
| ||
| lexeme_start [BatLexing] | Lexing.lexeme_start lexbuf returns the offset in the
input stream of the first character of the matched string.
| ||
| lexeme_start_p [BatLexing] |
Like
lexeme_start , but return a complete position instead
of an offset.
| ||
| lift [BatPathGen.StringType] |
Convert from UTF-8 string of primitive
string type.
| ||
| lift_char [BatPathGen.StringType] |
Convert Latin-1 character to
tchar .
| ||
| line_comment [BatGenlex.Languages.Make] | |||
| line_comment_start [BatGenlex.Languages.Definition] | |||
| lines_of [BatText] |
offer the lines of a UTF-8 encoded input as an enumeration
| ||
| lines_of [BatFile] | line_of name reads the contents of file name as an enumeration of lines.
| ||
| link [BatUnix] | link source dest creates a hard link named dest to the file
named source .
| ||
| listen [BatUnix] |
Set up a socket for receiving connection requests.
| ||
| ln10 [BatFloat] | log 10
| ||
| ln2 [BatFloat] | log 2
| ||
| localtime [BatUnix] |
Convert a time in seconds, as returned by
Unix.time , into a date and
a time.
| ||
| location [BatPrintexc.Slot] | location slot returns the location information of the slot,
if available, and None otherwise.
| ||
| lock [BatUnix] |
A lock used to synchronize internal operations.
| ||
| lock [BatRMutex] |
Lock the given mutex.
| ||
| lock [BatPervasives] |
A lock used to synchronize internal operations.
| ||
| lock [BatInnerPervasives] | |||
| lock [BatInnerIO] |
A reference to a set of locking operations.
| ||
| lock [BatConcurrent.BaseLock] | |||
| lock [BatConcurrent.Lock] | |||
| lockf [BatUnix] | lockf fd cmd size puts a lock on a region of the file opened
as fd .
| ||
| log [BatLogger] | log logger level event_fun raises a log event if if the
specified level is currently enabled for the logger.
| ||
| log [BatLog.Make_lev] | |||
| log [BatLog.Easy] | log lev msg logs the message msg if the current logging
level is lev or lower.
| ||
| log [BatLog.Make] | print s logs the message s, returning unit.
| ||
| log [BatLog] | log s logs the message s, returning unit.
| ||
| log [BatFloat.Safe_float] |
Natural logarithm.
| ||
| log [BatFloat] |
Natural logarithm.
| ||
| log [BatComplex] |
Natural logarithm (in base
e ).
| ||
| log10 [BatFloat.Safe_float] |
Base 10 logarithm.
| ||
| log10 [BatFloat] |
Base 10 logarithm.
| ||
| log10e [BatFloat] | log10 e
| ||
| log2e [BatFloat] | Math.log2 e
| ||
| log_enable [BatLogger] | log_enable logger level enables a log level for a logger.
| ||
| log_enabled [BatLogger] | log_enabled logger level returns true if the specified level is
currently enabled for the logger.
| ||
| log_level [BatLogger] | log_level logger returns the currently enabled level for a logger.
| ||
| log_name [BatLogger] | log_name logger returns the name of the logger.
| ||
| logand [BatNativeint] |
Bitwise logical and.
| ||
| logand [BatInt64] |
Bitwise logical and.
| ||
| logand [BatInt32] |
Bitwise logical and.
| ||
| logf [BatLog.Make_lev] | |||
| logf [BatLog.Easy] |
As
log , but instead of a string message, a printf format is
allowed with whatever arguments are appropriate.
| ||
| logf [BatLog.Make] |
As
Printf.printf , only the message is printed to the logging
output and prefixed with status information per the current flags and
the currently set prefix.
| ||
| logf [BatLog] |
As
Printf.printf , only the message is printed to the logging
output and prefixed with status information per the current flags and
the currently set prefix.
| ||
| lognot [BatNativeint] |
Bitwise logical negation
| ||
| lognot [BatInt64] |
Bitwise logical negation
| ||
| lognot [BatInt32] |
Bitwise logical negation
| ||
| logor [BatNativeint] |
Bitwise logical or.
| ||
| logor [BatInt64] |
Bitwise logical or.
| ||
| logor [BatInt32] |
Bitwise logical or.
| ||
| logxor [BatNativeint] |
Bitwise logical exclusive or.
| ||
| logxor [BatInt64] |
Bitwise logical exclusive or.
| ||
| logxor [BatInt32] |
Bitwise logical exclusive or.
| ||
| look [BatUTF8] | look s i
returns the Unicode character of the location i in the string s .
| ||
| lookahead [BatParserCo] | lookahead p behaves as maybe p but without consuming anything
| ||
| lookup [BatFingerTree.Generic] | lookup p t , when p is monotonic, returns the first element
of the sequence for which the measure of its predecessors in the
sequence (itself included) satisfies p .
| ||
| lowercase [BatString.Cap] | |||
| lowercase [BatString] |
Return a copy of the argument, with all uppercase letters
translated to lowercase, including accented letters of the ISO
Latin-1 (8859-1) character set.
| ||
| lowercase [BatCharParser] |
Recognizes one lower-case ASCII character, including
accentuated characters.
| ||
| lowercase [BatChar] |
Convert the given character to its equivalent lowercase character.
| ||
| lowercase [BatBytes] |
Return a copy of the argument, with all uppercase letters
translated to lowercase, including accented letters of the ISO
Latin-1 (8859-1) character set.
| ||
| lowercase_ascii [BatString] |
Return a copy of the argument, with all uppercase letters
translated to lowercase, using the US-ASCII character set.
| ||
| lowercase_ascii [BatChar] |
Convert the given character to its equivalent lowercase character,
using the US-ASCII character set.
| ||
| lowercase_ascii [BatBytes] |
Return a copy of the argument, with all uppercase letters
translated to lowercase, using the US-ASCII character set.
| ||
| lowercase_latin1 [BatCharParser] |
Recognizes one lower-case Latin-1 character, including
accentuated characters.
| ||
| lru_cache [BatCache] | |||
| lseek [BatUnix.LargeFile] | |||
| lseek [BatUnix] |
Set the current position for a file descriptor
| ||
| lsing [BatEnum] | |||
| lstat [BatUnix.LargeFile] | |||
| lstat [BatUnix] |
Same as
Unix.stat , but in case the file is a symbolic link,
return the information for the link itself.
| ||
| lt_big_int [BatBig_int] | |||
| lt_num [BatNum] | |||
M | |||
| major [BatGc] |
Do a minor collection and finish the current major collection cycle.
| ||
| major_slice [BatGc] |
Do a minor collection and a slice of major collection.
| ||
| make [BatVect] | make i c returns a vect of length i whose elements are all equal to
c ; it is similar to Array.make
| ||
| make [BatTuple.Tuple5] | |||
| make [BatTuple.Tuple4] | |||
| make [BatTuple.Tuple3] | |||
| make [BatTuple.Tuple2] | |||
| make [BatText] | make i c returns a rope of length i consisting of c chars;
it is similar to String.make
| ||
| make [BatSubstring] | |||
| make [BatString.Cap] | |||
| make [BatString] | String.make n c returns a fresh string of length n ,
filled with the character c .
| ||
| make [BatSeq] | make n e returns the sequence of length n where all elements
are e
| ||
| make [BatRandom.Incubator.Private_state_enums.State] |
Create a new state and initialize it with the given seed.
| ||
| make [BatRandom.State] |
Create a new state and initialize it with the given seed.
| ||
| make [BatRMutex] |
Create a new abstract lock based on Reentrant Mutexes.
| ||
| make [BatOptParse.OptParser] |
Creates a new option parser with the given options.
| ||
| make [BatMutex] |
Create a new abstract lock based on Mutexes.
| ||
| make [BatList] |
Similar to
String.make , make n x returns a
list containing n elements x .
| ||
| make [BatLazyList] |
Similar to
String.make , make n x returns a
list containing n elements x .
| ||
| make [BatEnum] |
This function creates a fully defined enumeration.
| ||
| make [BatDynArray] | make count returns an array with some memory already allocated so
up to count elements can be stored into it without resizing.
| ||
| make [BatConcurrent.Lock] | |||
| make [BatBytes] | make n c returns a new byte sequence of length n , filled with
the byte c .
| ||
| make [BatBounded.S] | |||
| make [BatArray.Cap.Labels] | |||
| make [BatArray.Cap] | |||
| make [BatArray] | Array.make n x returns a fresh array of length n ,
initialized with x .
| ||
| make_dbg_formatter [BatLogger] | make_dbg_formatter oc constructs a debug formatter from an
output channel.
| ||
| make_decoding_table [BatBase64] |
Create a valid decoding table from an encoding one.
| ||
| make_enum [BatIO] | |||
| make_float [BatArray.Cap] | Array.make_float n returns a fresh float array of length n ,
with uninitialized data.
| ||
| make_float [BatArray] | |||
| make_formatter [BatFormat] | make_formatter out flush returns a new formatter that writes according
to the output function out , and the flushing function flush .
| ||
| make_ht [BatCache] |
Make a manual cache backed by a hashtable.
| ||
| make_lexer [BatGenlex] |
Construct the lexer function.
| ||
| make_log [BatLogger] | make_log name returns a new logger.
| ||
| make_logger [BatLog] | |||
| make_map [BatCache] |
Make a manual cache for function
~gen backed by a Set.t.
| ||
| make_matrix [BatArray.Cap.Labels] | |||
| make_matrix [BatArray.Cap] | |||
| make_matrix [BatArray.Labels] | |||
| make_matrix [BatArray] | Array.make_matrix dimx dimy e returns a two-dimensional array
(an array of arrays) with first dimension dimx and
second dimension dimy .
| ||
| make_self_init [BatRandom.Incubator.Private_state_enums.State] |
Create a new state and initialize it with a system-dependent
low-entropy seed.
| ||
| make_self_init [BatRandom.State] |
Create a new state and initialize it with a system-dependent
low-entropy seed.
| ||
| make_std_formatter [BatLogger] | make_std_formatter oc constructs a formatter from an output
channel.
| ||
| make_tree [BatAvlTree] | |||
| map [BatVect] | map f v returns a vect isomorphic to v where each element of index
i equals f (get v i) .
| ||
| map [BatTuple.Tuple5] | |||
| map [BatTuple.Tuple4] | |||
| map [BatTuple.Tuple3] | |||
| map [BatTuple.Tuple2] |
Equivalent to
BatPervasives.
.
| ||
| map [BatText] | map f s returns a rope where all characters c in s have been
replaced by f c .
| ||
| map [BatString.Cap] | |||
| map [BatString] | String.map f s applies function f in turn to all
the characters of s and stores the results in a new string that
is returned.
| ||
| map [BatStream.StreamLabels] | |||
| map [BatStream] | map f stream applies f in turn to elements from stream and return the
results as a stream in the same order.
| ||
| map [BatSet.PSet] | map f x creates a new set with elements f a0 ,
f a1 ...
| ||
| map [BatSet.S.Labels] | |||
| map [BatSet.S] | map f x creates a new set with elements f a0 ,
f a1 ...
| ||
| map [BatSet] | map f x creates a new set with elements f a0 ,
f a1 ...
| ||
| map [BatSeq] | map f s returns the sequence where elements are elements of
s mapped with f .
| ||
| map [BatRefList] |
Apply a function to all elements
and return the ref list constructed with
the function returned values
| ||
| map [BatQueue] | map f q applies function f to each element of the queue
and returns a new queue q' with the results returned by f .
| ||
| map [BatPervasives] |
Transformation loop on an enumeration, used to build an enumeration
from another enumeration.
| ||
| map [BatPathGen.PathType] |
Map a path through a function that operates on separate components.
| ||
| map [BatOption.Labels] | |||
| map [BatOption] | map f (Some x) returns Some (f x) and map f None returns None .
| ||
| map [BatMultiPMap] | map f m returns a map with same domain as m , where the
associated value a of all bindings of m has been
replaced by the result of the application of f to a .
| ||
| map [BatMultiMap] | map f m returns a map with same domain as m , where the
associated value a of all bindings of m has been
replaced by the result of the application of f to a .
| ||
| map [BatMap.PMap] | map f m returns a map with same domain as m , where the
associated value a of all bindings of m has been
replaced by the result of the application of f to a .
| ||
| map [BatMap.S.Labels] | |||
| map [BatMap.S] | map f m returns a map with same domain as m , where the
associated value a of all bindings of m has been
replaced by the result of the application of f to a .
| ||
| map [BatMap] | map f m returns a map with same domain as m , where the
associated value a of all bindings of m has been
replaced by the result of the application of f to a .
| ||
| map [BatList.Labels] | |||
| map [BatList] | map f [a0; a1; ...; an] applies function f to a0, a1, ..., an ,
and builds the list [f a0; f a1; ...; f an]
with the results returned by f .
| ||
| map [BatLazyList.Labels] | |||
| map [BatLazyList] |
Lazy map
| ||
| map [BatInterfaces.Mappable] | map f e applies f to every element of e and returns the corresponding data structure
| ||
| map [BatIMap] |
Create a new map by modifying each
y by the given function.
| ||
| map [BatHashtbl.Cap.Labels] | |||
| map [BatHashtbl.Cap] | |||
| map [BatHashtbl.S.Labels] | |||
| map [BatHashtbl.S] | |||
| map [BatHashtbl.Labels] | |||
| map [BatHashtbl] | map f x creates a new hashtable with the same
keys as x , but with the function f applied to
all the values
| ||
| map [BatFingerTree.S] | map is equivalent to List.map .
| ||
| map [BatEnum.Labels] | |||
| map [BatEnum] | map f e returns an enumeration over (f a0, f a1, ...) where
a0,a1... are the elements of e .
| ||
| map [BatDynArray] | map f darr applies the function f to every element of darr
and creates a dynamic array from the results - similar to List.map or
Array.map .
| ||
| map [BatDllist] |
Allocate a new list, with entirely new nodes, whose values are
the transforms of the values of the original list.
| ||
| map [BatDeque] | map f dq returns a deque where every element x of dq has
been replaces with f x .
| ||
| map [BatBytes] | map f s applies function f in turn to all the bytes of s
(in increasing index order) and stores the resulting bytes in
a new sequence that is returned as the result.
| ||
| map [BatBounded.S] | map f x applies f to x .
| ||
| map [BatBigarray.Array3] | Array3.map f a applies function f to all the elements of a ,
and builds a Bigarray.Array3.t with the results returned by f .
| ||
| map [BatBigarray.Array2] | Array2.map f a applies function f to all the elements of a ,
and builds a Bigarray.Array2.t with the results returned by f .
| ||
| map [BatBigarray.Array1] | Array1.map f a applies function f to all the elements of a ,
and builds a Bigarray.Array1.t with the results returned by f .
| ||
| map [BatBigarray.Genarray] | map f kind a applies function f to all the elements of a ,
and builds a Bigarray.t of kind kind with the results
returned by f .
| ||
| map [BatArray.Cap.Labels] | |||
| map [BatArray.Cap] | |||
| map [BatArray.Labels] | |||
| map [BatArray] | Array.map f a applies function f to all the elements of a ,
and builds an array with the results returned by f :
[| f a.(0); f a.(1); ...; f a.(Array.length a - 1) |] .
| ||
| map1 [BatTuple.Tuple5] | |||
| map1 [BatTuple.Tuple4] | |||
| map1 [BatTuple.Tuple3] | |||
| map1 [BatTuple.Tuple2] | map1 f (x,y) returns (f x,y)
| ||
| map2 [BatTuple.Tuple5] | |||
| map2 [BatTuple.Tuple4] | |||
| map2 [BatTuple.Tuple3] | |||
| map2 [BatTuple.Tuple2] | map2 f (x,y) returns (x,f y)
| ||
| map2 [BatStream.StreamLabels] | |||
| map2 [BatStream] | map2 f streama streamb applies f in turn to elements of corresponding
positions from streama and streamb .
| ||
| map2 [BatSeq] | map2 f s1 s2 returns a sequence of elements, resulting from combininig
elements of s1 and s2 at the same index using f .
| ||
| map2 [BatList.Labels] | |||
| map2 [BatList] | List.map2 f [a0; a1; ...; an] [b0; b1; ...; bn] is
[f a0 b0; f a1 b1; ...; f an bn] .
| ||
| map2 [BatLazyList.Labels] | |||
| map2 [BatLazyList] | map2 f [^ a0; a1; ...^] [^ b0; b1; ... ^] is [^ f a0 b0; f a1
b1; ... ^] .
| ||
| map2 [BatBounded.S] | map f x y applies f to x and y .
| ||
| map2 [BatArray] |
As
Array.map but on two arrays.
| ||
| map2_exn [BatBounded.S] | map f x y applies f to x and y .
| ||
| map3 [BatTuple.Tuple5] | |||
| map3 [BatTuple.Tuple4] | |||
| map3 [BatTuple.Tuple3] | |||
| map4 [BatTuple.Tuple5] | |||
| map4 [BatTuple.Tuple4] | |||
| map5 [BatTuple.Tuple5] | |||
| map_comp [BatOrd] | |||
| map_default [BatResult] | map_default d f r evaluates to d if r is Bad else f x
when r is Ok x
| ||
| map_default [BatOption.Labels] | |||
| map_default [BatOption] | map_default f x (Some v) returns f v and map_default f x None
returns x .
| ||
| map_default_delayed [BatOption] |
Like
BatOption.map_default , but the default value is passed as a thunk that
is only computed if needed.
| ||
| map_eq [BatOrd] | |||
| map_exn [BatBounded.S] | map_exn f x applies f to x .
| ||
| map_ext [BatPathGen.PathType] | map_ext fu path returns path but with the name with extension given by fu ( BatPathGen.PathType.ext path) .
| ||
| map_file [BatBigarray.Array3] |
Memory mapping of a file as a three-dimensional big array.
| ||
| map_file [BatBigarray.Array2] |
Memory mapping of a file as a two-dimensional big array.
| ||
| map_file [BatBigarray.Array1] |
Memory mapping of a file as a one-dimensional big array.
| ||
| map_file [BatBigarray.Genarray] |
Memory mapping of a file as a big array.
| ||
| map_inplace [BatHashtbl.Cap.Labels] | |||
| map_inplace [BatHashtbl.Cap] | |||
| map_inplace [BatHashtbl.S.Labels] | |||
| map_inplace [BatHashtbl.S] | |||
| map_inplace [BatHashtbl.Labels] | |||
| map_inplace [BatHashtbl] | map_inplace f x replace all values currently bound in x
by f applied to each value.
| ||
| map_list [BatRefList] |
Apply a function to all elements
and return the list constructed with
the function returned values
| ||
| map_name [BatPathGen.PathType] | |||
| map_ord [BatOrd] |
These functions extend an existing equality/comparison/ordering to
a new domain through a mapping function.
| ||
| map_range [BatIMap] |
Create a new map by modifying each
y using the given function.
| ||
| map_right [BatFingerTree.S] | map_right is equivalent to List.rev o List.map o List.rev .
| ||
| map_to_set [BatIMap] | map_to_set p t returns the set of keys of t where p
evaluates as true
| ||
| mapi [BatVect] |
Same as
BatVect.map , but the
function is applied to the index of the element as first argument,
and the element itself as second argument.
| ||
| mapi [BatString.Cap] | |||
| mapi [BatString] | String.mapi f s calls f with each character of s and its
index (in increasing index order) and stores the results in a new
string that is returned.
| ||
| mapi [BatSeq] | mapi f s lazily maps elements of s into a new sequence,
using f .
| ||
| mapi [BatMultiPMap] |
Same as
map , but the function receives as arguments both the
key and the associated value for each binding of the map.
| ||
| mapi [BatMultiMap] |
Same as
map , but the function receives as arguments both the
key and the associated value for each binding of the map.
| ||
| mapi [BatMap.PMap] |
Same as
map , but the function receives as arguments both the
key and the associated value for each binding of the map.
| ||
| mapi [BatMap.S.Labels] | |||
| mapi [BatMap.S] |
Same as
Map.S.map , but the function receives as arguments both the
key and the associated value for each binding of the map.
| ||
| mapi [BatMap] |
Same as
map , but the function receives as arguments both the
key and the associated value for each binding of the map.
| ||
| mapi [BatList.Labels] | |||
| mapi [BatList] | mapi f l will build the list containing
(f 0 a0); (f 1 a1) ... (f n an) where a0..an are the elements of
the list l .
| ||
| mapi [BatLazyList.Labels] | |||
| mapi [BatLazyList] |
Lazy map, with indices
| ||
| mapi [BatIMap] |
Create a new map by computing new values based on key and value
of the existing bindings.
| ||
| mapi [BatEnum.Labels] | |||
| mapi [BatEnum] | mapi is similar to map except that f is passed one extra argument
which is the index of the element in the enumeration, starting from 0 :
mapi f e returns an enumeration over (f 0 a0, f 1 a1, ...) where
a0,a1... are the elements of e .
| ||
| mapi [BatDynArray] | mapi f darr applies the function f to every element of darr
and creates a dynamic array from the results - similar to List.mapi or
Array.mapi .
| ||
| mapi [BatDeque] | map f dq returns a deque where every element x of dq has
been replaces with f n x , where n is the position of x
from the front of dq .
| ||
| mapi [BatBytes] | mapi f s calls f with each character of s and its
index (in increasing index order) and stores the resulting bytes
in a new sequence that is returned as the result.
| ||
| mapi [BatBigarray.Array1] |
Same as
Bigarray.Array1.map , but the
function is applied to the index of the element as the first argument,
and the element itself as the second argument.
| ||
| mapi [BatBigarray.Genarray] |
Same as
BatBigarray.Genarray.map , but the function is applied to the index of the
coordinates as the first argument, and the element itself as the
second argument.
| ||
| mapi [BatArray.Cap.Labels] | |||
| mapi [BatArray.Cap] | |||
| mapi [BatArray.Labels] | |||
| mapi [BatArray] |
Same as
Array.map , but the
function is applied to the index of the element as first argument,
and the element itself as second argument.
| ||
| mapij [BatBigarray.Array2] |
Same as
Bigarray.Array2.map , but the
function is applied to the index of the element as the first two
arguments, and the element itself as the third argument.
| ||
| mapijk [BatBigarray.Array3] |
Same as
Bigarray.Array3.map , but the
function is applied to the index of the element as the first three
arguments, and the element itself as the fourth argument.
| ||
| mapn [BatTuple.Tuple5] |
Like
BatTuple.Tuple5.map but specialized for tuples with elements of the
same type.
| ||
| mapn [BatTuple.Tuple4] |
Like
BatTuple.Tuple4.map but specialized for tuples with elements of the
same type.
| ||
| mapn [BatTuple.Tuple3] |
Like
BatTuple.Tuple3.map but specialized for tuples with elements of the
same type.
| ||
| mapn [BatTuple.Tuple2] |
Like
BatTuple.Tuple2.map but specialized for tuples with elements of the
same type.
| ||
| max [BatSeq.Exceptionless] | |||
| max [BatSeq] | max s returns the largest value in s as judged by
Pervasives.compare
| ||
| max [BatOrd] | max ord will choose the biggest element according to ord .
| ||
| max [BatList] | max l returns the largest value in l as judged by
Pervasives.compare
| ||
| max [BatInt] |
The maximum of two integers.
| ||
| max [BatFloat] | |||
| max [BatArray] | max a returns the largest value in a as judged by
Pervasives.compare
| ||
| max_array_length [BatteriesConfig] | |||
| max_array_length [BatSys] |
Maximum length of a normal array.
| ||
| max_big_int [BatBig_int] |
Return the greater of its two arguments.
| ||
| max_binding [BatMap.PMap] |
returns the binding with the largest key
| ||
| max_binding [BatMap.S] |
return the
(key,value) pair with the largest key
| ||
| max_binding [BatMap] |
returns the binding with the largest key
| ||
| max_comp [BatOrd] | |||
| max_elt [BatSet.PSet] |
returns the largest element of the set.
| ||
| max_elt [BatSet.S.Exceptionless] | |||
| max_elt [BatSet.S] |
Same as
Set.S.min_elt , but returns the largest element of the
given set.
| ||
| max_elt [BatSet] |
returns the largest element of the set.
| ||
| max_elt [BatISet] |
Returns the maximum element in the set
| ||
| max_int [BatNativeint] |
The greatest representable native integer,
either 231 - 1 on a 32-bit platform,
or 263 - 1 on a 64-bit platform.
| ||
| max_int [BatInt64] |
The greatest representable 64-bit integer, 263 - 1.
| ||
| max_int [BatInt32] |
The greatest representable 32-bit integer, 231 - 1.
| ||
| max_length [BatVect] |
Maximum length of the vect.
| ||
| max_length [BatText] |
Maximum length of the rope (number of UTF-8 characters).
| ||
| max_num [BatNumber.Bounded] | |||
| max_num [BatNum] | |||
| max_num [BatNativeint] | |||
| max_num [BatInt32] | |||
| max_num [BatInt.Safe_int] |
The greatest representable integer, which is either 230-1 or 262-1.
| ||
| max_num [BatInt] |
The greatest representable integer, which is either 230-1 or 262-1.
| ||
| max_num [BatFloat.Safe_float] | |||
| max_num [BatFloat] | |||
| max_num [BatBool] | |||
| max_ord [BatOrd] | |||
| max_string_length [BatteriesConfig] | |||
| max_string_length [BatSys] |
Maximum length of a string.
| ||
| may [BatOption.Labels] | |||
| may [BatOption] | may f (Some x) calls f x and may f None does nothing.
| ||
| maybe [BatParserCo] |
Accept an optional argument.
| ||
| measure [BatFingerTree.Generic] | measure m gives the measure of the whole tree, whose meaning
depends on the measure chosen.
| ||
| mem [BatVect] | mem m a is true if and only if m is equal to an element of a .
| ||
| mem [BatSet.PSet] | mem x s tests whether x belongs to the set s .
| ||
| mem [BatSet.S] | mem x s tests whether x belongs to the set s .
| ||
| mem [BatSet] | mem x s tests whether x belongs to the set s .
| ||
| mem [BatSeq] | mem a l is true if and only if a is equal to an element of
l .
| ||
| mem [BatMultiPMap] | mem x m returns true if m contains at least a binding for x ,
and false otherwise.
| ||
| mem [BatMultiMap] | mem x m returns true if m contains at least a binding for x ,
and false otherwise.
| ||
| mem [BatMap.PMap] | mem x m returns true if m contains a binding for x ,
and false otherwise.
| ||
| mem [BatMap.S] | mem x m returns true if m contains a binding for x ,
and false otherwise.
| ||
| mem [BatMap] | mem x m returns true if m contains a binding for x ,
and false otherwise.
| ||
| mem [BatList] | mem a l is true if and only if a is equal
to an element of l .
| ||
| mem [BatLazyList] | mem x l determines if x is part of l .
| ||
| mem [BatInnerWeaktbl] | Weaktbl.mem tbl x checks if x is bound in tbl .
| ||
| mem [BatISet] |
test whether a given int is a member of the set
| ||
| mem [BatIMap] |
Test whether there is a binding from the given int
| ||
| mem [BatHashtbl.Cap] | |||
| mem [BatHashtbl.S] | |||
| mem [BatHashtbl] | Hashtbl.mem tbl x checks if x is bound in tbl .
| ||
| mem [BatBitSet] | mem s n returns true if nth-bit in the bitset s is set,
or false otherwise.
| ||
| mem [BatArray.Cap] | |||
| mem [BatArray] | mem m a is true if and only if m is equal to an element of a .
| ||
| mem_assoc [BatList] |
Same as
List.assoc , but simply return true if a binding exists,
and false if no bindings exist for the given key.
| ||
| mem_assoc [BatLazyList] | |||
| mem_assq [BatList] |
Same as
List.mem_assoc , but uses physical equality instead of
structural equality to compare keys.
| ||
| mem_assq [BatLazyList] |
As
BatLazyList.mem_assoc but with physical equality.
| ||
| mem_cmp [BatList] |
Same as
List.mem , but the comparator function is explicitely
provided.
| ||
| memq [BatVect] |
Same as
Vect.mem but uses physical equality instead of
structural equality to compare vect elements.
| ||
| memq [BatList] |
Same as
List.mem , but uses physical equality instead of structural
equality to compare list elements.
| ||
| memq [BatLazyList] |
As
mem , but with physical equality
| ||
| memq [BatArray.Cap] | |||
| memq [BatArray] |
Same as
Array.mem but uses physical equality instead of
structural equality to compare array elements.
| ||
| merge [BatStream.StreamLabels] | |||
| merge [BatStream] | merge test (streama, streamb) merge the elements from streama and
streamb into a single stream.
| ||
| merge [BatMap.PMap] | merge f m1 m2 computes a map whose keys is a subset of keys of m1
and of m2 .
| ||
| merge [BatMap.S] | merge f m1 m2 computes a map whose keys is a subset of keys of m1
and of m2 .
| ||
| merge [BatMap] | merge f m1 m2 computes a map whose keys is a subset of keys of m1
and of m2 .
| ||
| merge [BatList.Labels] | |||
| merge [BatList] |
Merge two lists:
Assuming that
l1 and l2 are sorted according to the
comparison function cmp , merge cmp l1 l2 will return a
sorted list containting all the elements of l1 and l2 .
| ||
| merge [BatIMap] | |||
| merge [BatHeap.H] |
See
BatHeap.merge .
| ||
| merge [BatHeap] |
Merge two heaps.
| ||
| merge [BatEnum] | merge test a b merge the elements from a and b into a single
enumeration.
| ||
| merge_unsafe [BatMap.PMap] |
Same as merge, but assumes the comparison function of both maps
are equal.
| ||
| mid [BatInt] |
Midpoint function;
mid a b returns floor((a+b)/2) , but done
correctly to compensate for numeric overflows.
| ||
| min [BatSeq.Exceptionless] | |||
| min [BatSeq] | min s returns the smallest value in s as judged by
Pervasives.compare
| ||
| min [BatOrd] | min ord will choose the smallest element, according to ord .
| ||
| min [BatList] | min l returns the smallest value in l as judged by
Pervasives.compare
| ||
| min [BatInt] |
The minimum of two integers.
| ||
| min [BatFloat] | |||
| min [BatArray] | min a returns the smallest value in a as judged by
Pervasives.compare
| ||
| min_big_int [BatBig_int] |
Return the smaller of its two arguments.
| ||
| min_binding [BatMap.PMap] |
returns the binding with the smallest key
| ||
| min_binding [BatMap.S] |
return the (
key,value ) pair with the smallest key
| ||
| min_binding [BatMap] |
returns the binding with the smallest key
| ||
| min_comp [BatOrd] | |||
| min_elt [BatSet.PSet] |
returns the smallest element of the set.
| ||
| min_elt [BatSet.S.Exceptionless] | |||
| min_elt [BatSet.S] |
Return the smallest element of the given set
(with respect to the
Ord.compare ordering).
| ||
| min_elt [BatSet] |
returns the smallest element of the set.
| ||
| min_elt [BatISet] |
Returns the minimum element in the set
| ||
| min_int [BatNativeint] |
The greatest representable native integer,
either -231 on a 32-bit platform,
or -263 on a 64-bit platform.
| ||
| min_int [BatInt64] |
The smallest representable 64-bit integer, -263.
| ||
| min_int [BatInt32] |
The smallest representable 32-bit integer, -231.
| ||
| min_max [BatList] | min_max l returns the pair (smallest, largest) from l as judged by
Pervasives.compare (by default).
| ||
| min_num [BatNumber.Bounded] | |||
| min_num [BatNum] | |||
| min_num [BatNativeint] | |||
| min_num [BatInt32] | |||
| min_num [BatInt.Safe_int] |
The smallest representable integer, -230 or 262.
| ||
| min_num [BatInt] |
The smallest representable integer, -230 or -262.
| ||
| min_num [BatFloat.Safe_float] | |||
| min_num [BatFloat] | |||
| min_num [BatBool] | |||
| min_ord [BatOrd] | |||
| minor [BatGc] |
Trigger a minor collection.
| ||
| minus_big_int [BatBig_int] |
Unary negation.
| ||
| minus_num [BatNum] | |||
| minus_one [BatNativeint] |
The native integer -1.
| ||
| minus_one [BatInt64] |
The 64-bit integer -1.
| ||
| minus_one [BatInt32] |
The 32-bit integer -1.
| ||
| minus_one [BatInt.Safe_int] |
The integer
-1 .
| ||
| minus_one [BatInt] |
The integer
-1 .
| ||
| mkdir [BatUnix] |
Create a directory with the given permissions.
| ||
| mkfifo [BatUnix] |
Create a named pipe with the given permissions.
| ||
| mktime [BatUnix] |
Convert a date and time, specified by the
tm argument, into
a time in seconds, as returned by Unix.time .
| ||
| mod_big_int [BatBig_int] |
Euclidean modulus of two big integers.
| ||
| mod_num [BatNum] | |||
| modf [BatFloat.Safe_float] | modf f returns the pair of the fractional and integral
part of f .
| ||
| modf [BatFloat] | modf f returns the pair of the fractional and integral
part of f .
| ||
| modify [BatVect] | modify v n f is equivalent to set v n (f (get v n)) , but
more efficient.
| ||
| modify [BatMultiPMap] | modify x f m replaces the binding for x with f applied to
these values.
| ||
| modify [BatMultiMap] | modify x f m replaces the binding for x with f applied to
these values.
| ||
| modify [BatMap.PMap] | modify k f m replaces the previous binding for k with f
applied to that value.
| ||
| modify [BatMap.S] | modify k f m replaces the previous binding for k with f applied to
that value.
| ||
| modify [BatMap] | modify k f m replaces the previous binding for k with f
applied to that value.
| ||
| modify [BatList] | modify a f l returns the same list as l but with value associated
to key a replaced with f a .
| ||
| modify [BatIMap] | modify x f t replaces the y that is bound to x in t by f y .
| ||
| modify [BatHashtbl.Cap.Exceptionless] | |||
| modify [BatHashtbl.S.Labels] | |||
| modify [BatHashtbl.S.Exceptionless] | |||
| modify [BatHashtbl.S] | |||
| modify [BatHashtbl.Labels] | |||
| modify [BatHashtbl.Exceptionless] | |||
| modify [BatHashtbl] | Hashtbl.modify k f tbl replaces the first binding for k in tbl
with f applied to that value.
| ||
| modify [BatBigarray.Array3] | modify f a changes each element x in a to f x
in-place.
| ||
| modify [BatBigarray.Array2] | modify f a changes each element x in a to f x
in-place.
| ||
| modify [BatBigarray.Array1] | modify f a changes each element x in a to f x
in-place.
| ||
| modify [BatBigarray.Genarray] | modify f a changes each element x in a to f x
in-place.
| ||
| modify [BatArray.Cap.Labels] | |||
| modify [BatArray.Cap] | |||
| modify [BatArray.Labels] | |||
| modify [BatArray] | modify f a replaces every element x of a with f x .
| ||
| modify_at [BatList] | modify_at n f l returns the same list as l
but with nth-value a replaced with f a .
| ||
| modify_def [BatMultiPMap] | modify_def dfl x f m performs as modify x f m but it adds
f dfl in m instead of raising Not_found if x was unbound.
| ||
| modify_def [BatMultiMap] | modify_def dfl x f m performs as modify x f m but it adds
f dfl in m instead of raising Not_found if x was unbound.
| ||
| modify_def [BatMap.PMap] | modify_def v0 k f m replaces the previous binding for k
with f applied to that value.
| ||
| modify_def [BatMap.S] | modify_def v0 k f m replaces the previous binding for k
with f applied to that value.
| ||
| modify_def [BatMap] | modify_def v0 k f m replaces the previous binding for k
with f applied to that value.
| ||
| modify_def [BatList] | modify_def dfl a f l performs as modify a f l except that it
add an association from a to f dfl instead of raising Not_found .
| ||
| modify_def [BatIMap] | modify_def dft x f t does the same as modify x f t but binds
x to f dft if x was not bound.
| ||
| modify_def [BatHashtbl.S.Labels] | |||
| modify_def [BatHashtbl.S] | |||
| modify_def [BatHashtbl.Labels] | |||
| modify_def [BatHashtbl] | Hashtbl.modify_def v k f tbl does the same as Hashtbl.modify k f tbl
but f v is inserted in tbl if k was unbound.
| ||
| modify_opt [BatMultiPMap] | modify_opt x f m allows to modify the bindings for k in m
or absence thereof.
| ||
| modify_opt [BatMultiMap] | modify_opt x f m allows to modify the bindings for k in m
or absence thereof.
| ||
| modify_opt [BatMap.PMap] | modify_opt k f m allow to modify the binding for k in m
or absence thereof.
| ||
| modify_opt [BatMap.S] | modify_opt k f m allows to modify the binding for k in m
or absence thereof.
| ||
| modify_opt [BatMap] | modify_opt k f m allow to modify the binding for k in m
or absence thereof.
| ||
| modify_opt [BatList] | modify_opt a f l allows to modify the binding for a in l
or absence thereof.
| ||
| modify_opt [BatIMap] | modify_opt x f t allows to modify the binding for x in t
or absence thereof.
| ||
| modify_opt [BatHashtbl.S.Labels] | |||
| modify_opt [BatHashtbl.S] | |||
| modify_opt [BatHashtbl.Labels] | |||
| modify_opt [BatHashtbl] | Hashtbl.modify_opt k f tbl allows to remove, modify or add a binding for
k in tbl .
| ||
| modify_opt_at [BatList] | modify_at_opt n f l returns the same list as l but with
nth-value a removed if f a is None , and replaced by v if
it is Some v .
| ||
| modifyi [BatBigarray.Array1] |
Same as
Bigarray.Array1.modify , but the function is applied
to the index of the element as the first argument, and the
element itself as the second argument.
| ||
| modifyi [BatBigarray.Genarray] |
Same as
BatBigarray.Genarray.modify , but the function is applied to the index of
the coordinates as the first argument, and the element itself
as the second argument.
| ||
| modifyi [BatArray.Cap.Labels] | |||
| modifyi [BatArray.Cap] | |||
| modifyi [BatArray.Labels] | |||
| modifyi [BatArray] |
Same as
BatArray.modify , but the function is applied to the index of
the element as the first argument, and the element itself as
the second argument.
| ||
| modifyij [BatBigarray.Array2] |
Same as
Bigarray.Array2.modify , but the function is applied
to the index of the element as the first two arguments, and the
element itself as the third argument.
| ||
| modifyijk [BatBigarray.Array3] |
Same as
Bigarray.Array3.modify , but the function is applied
to the index of the coordinates as the first three arguments, and the
element itself as the fourth argument.
| ||
| modulo [BatNumber.NUMERIC_BASE] | |||
| modulo [BatNumber.Numeric] | |||
| modulo [BatNum] | |||
| modulo [BatNativeint] | |||
| modulo [BatInt32] | |||
| modulo [BatInt.Safe_int] | modulo a b computes the remainder of the integer
division of a by b .
| ||
| modulo [BatInt] | modulo a b computes the remainder of the integer
division of a by b .
| ||
| modulo [BatFloat.Safe_float] | |||
| modulo [BatFloat] | |||
| modulo [BatComplex] | |||
| modulo [BatBool] | |||
| modulo [BatBig_int] | |||
| move [BatUTF8] | move s i n
returns n -th Unicode character after i if n >= 0,
n -th Unicode character before i if n < 0.
| ||
| mul [BatNumber.NUMERIC_BASE] | |||
| mul [BatNumber.Numeric] | |||
| mul [BatNum] | |||
| mul [BatNativeint] |
Multiplication.
| ||
| mul [BatInt64] |
Multiplication.
| ||
| mul [BatInt32] |
Multiplication.
| ||
| mul [BatInt.Safe_int] |
Multiplication.
| ||
| mul [BatInt] |
Multiplication.
| ||
| mul [BatFloat.Safe_float] | |||
| mul [BatFloat] | |||
| mul [BatComplex] |
Multiplication
| ||
| mul [BatBool] | |||
| mul [BatBig_int] | |||
| mult_big_int [BatBig_int] |
Multiplication of two big integers.
| ||
| mult_int_big_int [BatBig_int] |
Multiplication of a big integer by a small integer
| ||
| mult_num [BatNum] | |||
| multi_choice [BatRandom] | multi_choice n e returns an enumeration of n
randomly-chosen elements of e .
| ||
| multiline_comment [BatGenlex.Languages.Make] | |||
| must [BatParserCo] |
Prevent backtracking.
| ||
N | |||
| n_cartesian_product [BatList] |
Given n lists, return the n-way cartesian product of
these lists.
| ||
| name [BatPathGen.PathType] |
Returns name of the object the pathname points to, i.e.
| ||
| name [BatGlobal] |
Retrieve the name of a global.
| ||
| name_core [BatPathGen.PathType] |
Returns part of the name to the left of rightmost dot.
| ||
| name_of_input [BatScanf.Scanning] | Scanning.file_name_of_input ib returns the name of the character source
for the scanning buffer ib .
| ||
| name_of_level [BatLogger] | name_of_level level returns the name of the specified level .
| ||
| nan [BatFloat.Safe_float] |
A special floating-point value denoting the result of an
undefined operation such as
0.0 /. 0.0 .
| ||
| nan [BatFloat] |
A special floating-point value denoting the result of an
undefined operation such as
0.0 /. 0.0 .
| ||
| nat_of_num [BatNum] |
Coercions between numerical types
| ||
| nativeint [BatRandom.Incubator.Private_state_enums.State] | |||
| nativeint [BatRandom.State] | |||
| nativeint [BatRandom] | Random.nativeint bound returns a random integer between 0 (inclusive)
and bound (exclusive).
| ||
| nativeint [BatBigarray] |
See
Bigarray.char .
| ||
| nativeint_of_big_int [BatBig_int] |
Convert a big integer to a native integer.
| ||
| neg [BatPervasives] | neg p returns a new predicate that is the negation of the given
predicate.
| ||
| neg [BatNumber.NUMERIC_BASE] |
Arithmetic operations
| ||
| neg [BatNumber.Numeric] | |||
| neg [BatNum] | |||
| neg [BatNativeint] |
Unary negation.
| ||
| neg [BatInt64] |
Unary negation.
| ||
| neg [BatInt32] |
Unary negation.
| ||
| neg [BatInt.Safe_int] |
Unary negation.
| ||
| neg [BatInt] |
Unary negation.
| ||
| neg [BatInnerPervasives] | |||
| neg [BatFloat.Safe_float] | |||
| neg [BatFloat] |
Returns the negation of the input, i.e.
| ||
| neg [BatComplex] |
Unary negation.
| ||
| neg [BatBool] | |||
| neg [BatBig_int] | |||
| neg2 [BatPervasives] |
as
neg but for predicates with two arguments
| ||
| neg2 [BatInnerPervasives] | |||
| neg_infinity [BatFloat.Safe_float] |
Negative infinity.
| ||
| neg_infinity [BatFloat] |
Negative infinity.
| ||
| nested_comments [BatGenlex.Languages.Definition] | |||
| new_line [BatLexing] |
Update the
lex_curr_p field of the lexbuf to reflect the start
of a new line.
| ||
| new_method [BatOo] |
As
Internal.public_method_label
| ||
| newline [BatCharParser] |
Recognizes a newline
| ||
| next [BatUTF8] | next s i
returns the position of the head of the Unicode character
located immediately after i .
| ||
| next [BatStream] |
Return the first element of the stream and remove it from the
stream.
| ||
| next [BatLazyList] |
Compute and return the next value of the list
| ||
| next [BatDllist] |
Given a node, get the next element in the list after the node.
| ||
| next_set_bit [BatBitSet] | next_set_bit s n returns Some m when m is the next set
element with index greater than or equal n , or None if no such
element exists (i.e.
| ||
| nice [BatUnix] |
Change the process priority.
| ||
| nil [BatSeq] | nil = fun () -> Nil
| ||
| nil [BatLazyList] |
The empty list.
| ||
| nolock [BatConcurrent] |
A lock which does nothing.
| ||
| none_of [BatParserCo] |
Accept any value not in a list
Faster and more convenient than combining
satisfy and either .
| ||
| none_of [BatCharParser] |
Accept any value not in a list
As
ParserCo.none_of , just with improved error message.
| ||
| noop [BatInnerIO] | |||
| norm [BatComplex] |
Norm: given
x + i.y , returns sqrt(x^2 + y^2) .
| ||
| norm2 [BatComplex] |
Norm squared: given
x + i.y , returns x^2 + y^2 .
| ||
| normalize [BatPathGen.PathType] |
Deprecated name for
normalize_in_tree
| ||
| normalize_filepath [BatPathGen.PathType] |
Consumes single dots where possible, e.g.:
| ||
| normalize_in_graph [BatPathGen.PathType] |
Another name for
normalize_filepath .
| ||
| normalize_in_tree [BatPathGen.PathType] |
Consumes single dots and applies double dots where possible, e.g.:
| ||
| not [BatBool] |
The boolean negation.
| ||
| not_char [BatCharParser] |
Accept any value not a given char
As
none_of .
| ||
| npeek [BatStream] | npeek n returns the list of the n first elements of
the stream, or all its remaining elements if less than n
elements are available.
| ||
| npop [BatRefList] |
Removes and returns the n first elements or
raises
Empty_list if the ref list does not
contain enough elements
| ||
| nread [BatInnerIO] | nread i n reads a string of size up to n from an input.
| ||
| nread [BatIO] | nread i n reads a string of size up to n from an input.
| ||
| nreplace [BatString.Cap] | |||
| nreplace [BatString] | nreplace ~str ~sub ~by returns a string obtained by iteratively
replacing each occurrence of sub by by in str , from right to left.
| ||
| nsplit [BatText] | nsplit s sep splits the rope s into a list of ropes
which are separated by sep .
| ||
| nsplit [BatString.Cap] | |||
| nsplit [BatString] | nsplit s sep splits the string s into a list of strings
which are separated by sep (excluded).
| ||
| nsplit [BatList] | nsplit , applied to a predicate p and a list xs , returns a
list of lists.
| ||
| ntake [BatList] | ntake n l cuts l into lists of size at most n .
| ||
| nth [BatUTF8] | nth s n returns the position of the n -th Unicode character.
| ||
| nth [BatList] |
Obsolete.
| ||
| nth [BatLazyList] |
Obsolete.
| ||
| nth [BatBuffer] |
get the n-th character of the buffer.
| ||
| nth_dim [BatBigarray.Genarray] | Genarray.nth_dim a n returns the n -th dimension of the
big array a .
| ||
| null_formatter [BatLogger] | null_formatter is a formatter that does not output any
events, but simply discards them.
| ||
| num_digits_big_int [BatBig_int] |
Return the number of machine words used to store the
given big integer.
| ||
| num_dims [BatBigarray.Genarray] |
Return the number of dimensions of the given big array.
| ||
| num_of_big_int [BatNum] | |||
| num_of_int [BatNum] | |||
| num_of_nat [BatNum] | |||
| num_of_ratio [BatNum] | |||
| num_of_string [BatNum] | |||
| number [BatGenlex.Languages.Make] |
Parse either an integer or a floating-point number.
| ||
| numeric_compare [BatString] |
Compare two strings, sorting "abc32def" before "abc210abc".
| ||
| nwrite [BatInnerIO] |
Write a string to an output.
| ||
| nwrite [BatIO] |
Write a string to an output.
| ||
O | |||
| ocaml_version [BatSys] | ocaml_version is the version of OCaml.
| ||
| of_array [BatVect] | of_array s returns a vect corresponding to the array s .
| ||
| of_array [BatSet.PSet] |
builds a set from the given array and comparison function
| ||
| of_array [BatSet.S] |
builds a set from the given array.
| ||
| of_array [BatSet] |
builds a set from the given array, using the default comparison
function
| ||
| of_array [BatLazyList] |
Eager conversion from array
| ||
| of_array [BatDynArray] | of_array arr returns an array with the elements of arr in it
in order.
| ||
| of_array [BatBigarray.Array3] |
Build a three-dimensional big array initialized from the
given array of arrays of arrays.
| ||
| of_array [BatBigarray.Array2] |
Build a two-dimensional big array initialized from the
given array of arrays.
| ||
| of_array [BatBigarray.Array1] |
Build a one-dimensional big array initialized from the
given array.
| ||
| of_array [BatArray.Cap] |
Adopt a regular array as a capability array, allowing
to decrease capabilities if necessary.
| ||
| of_backwards [BatVect] |
Build a vector from an enumeration, from last to first.
| ||
| of_backwards [BatString.Cap] | |||
| of_backwards [BatString] |
Build a string from an enumeration, starting with last character, ending with first.
| ||
| of_backwards [BatRefList] |
Creates a ref list from an enumeration, going from last to first
| ||
| of_backwards [BatList] |
Build a list from an enumeration.
| ||
| of_backwards [BatFingerTree.S] | of_backward e is equivalent to reverse (of_enum e) .
| ||
| of_backwards [BatArray.Cap] | |||
| of_backwards [BatArray] |
Build an array from an enumeration, with the first element of
the enumeration as the last element of the array and vice
versa.
| ||
| of_byte [BatInt32] | |||
| of_bytes [BatStream] |
Return the stream of the characters of the bytes parameter.
| ||
| of_channel [BatStream] |
Return the stream of the characters read from the input channel.
| ||
| of_char [BatUChar] | of_char c returns the Unicode character of the Latin-1 character c
| ||
| of_char [BatText] | of_char c returns a rope containing exactly Latin-1 character c .
| ||
| of_char [BatString.Cap] | |||
| of_char [BatString] |
Returns a string containing one given character.
| ||
| of_digit [BatChar] |
Return the character representing a given digit.
| ||
| of_enum [BatVect] |
Build a vector from an enumeration.
| ||
| of_enum [BatTuple.Tuple5] | |||
| of_enum [BatTuple.Tuple4] | |||
| of_enum [BatTuple.Tuple3] | |||
| of_enum [BatTuple.Tuple2] | |||
| of_enum [BatText] |
converts the enumeration into a rope
| ||
| of_enum [BatString.Cap] | |||
| of_enum [BatString] |
Creates a string from a character enumeration.
| ||
| of_enum [BatStream] |
Convert an enumeration to a stream.
| ||
| of_enum [BatStack] | of_enum e returns a new stack containing all the elements of
e .
| ||
| of_enum [BatSet.PSet] | |||
| of_enum [BatSet.S] | |||
| of_enum [BatSet] | |||
| of_enum [BatRefList] |
Creates a ref list from an enumeration
| ||
| of_enum [BatQueue] | of_enum e returns a new queue containing all the elements of e .
| ||
| of_enum [BatParserCo.Source] | |||
| of_enum [BatOption] | of_enum e consumes the first element of e , if it exists, and
returns Some e .
| ||
| of_enum [BatMultiPMap] |
creates a map from an enumeration, using the specified function
for key comparison or
compare by default.
| ||
| of_enum [BatMultiMap] |
creates a map from an enumeration, using the specified function
for key comparison or
compare by default.
| ||
| of_enum [BatMap.PMap] |
creates a map from an enumeration, using the specified function
for key comparison or
compare by default.
| ||
| of_enum [BatMap.S] |
Create a map from a (key, value) enumeration.
| ||
| of_enum [BatMap] |
Creates a map from an enumeration
| ||
| of_enum [BatList] |
Build a list from an enumeration.
| ||
| of_enum [BatLazyList] |
Lazy conversion from enum.
| ||
| of_enum [BatISet] | |||
| of_enum [BatIMap] | of_enum e returns the set of given ranges
| ||
| of_enum [BatHeap.H] |
See
BatHeap.of_enum .
| ||
| of_enum [BatHeap] |
Build a heap from an enumeration.
| ||
| of_enum [BatHashtbl.Cap] | |||
| of_enum [BatHashtbl.S] | |||
| of_enum [BatHashtbl] |
Create a hashtable from a (key,value) enumeration.
| ||
| of_enum [BatFingerTree.S] | of_enum e build the sequence containing the elements of e
in the same order.
| ||
| of_enum [BatEnum.Enumerable] |
Build a data structure from an enumeration
| ||
| of_enum [BatEnum] |
identity : added for consistency with the other data structures
| ||
| of_enum [BatDynArray] | of_enum e returns an array that holds, in order, the elements of e .
| ||
| of_enum [BatDllist] |
Create a dllist from an enum.
| ||
| of_enum [BatDeque] | of_enum e is a deque representation of the elements of e .
| ||
| of_enum [BatBuffer] |
Creates a buffer from a character enumeration.
| ||
| of_enum [BatBitSet] | of_enum ~cap e builds a bitset of capacity cap an enumeration
of ints e .
| ||
| of_enum [BatBigarray.Array1] | Array1.of_enum kind layout enum returns a new one-dimensional
big array of kind kind and layout layout , with elements taken
from the enumeration enum in order.
| ||
| of_enum [BatArray.Cap] | |||
| of_enum [BatArray] |
Build an array from an enumeration.
| ||
| of_enum_cmp [BatSet.PSet] | |||
| of_float [BatString.Cap] | |||
| of_float [BatString] |
Returns the string representation of an float.
| ||
| of_float [BatNumber.NUMERIC_BASE] | |||
| of_float [BatNumber.Numeric] | |||
| of_float [BatNum] | |||
| of_float [BatNativeint] |
Convert the given floating-point number to a native integer,
discarding the fractional part (truncate towards 0).
| ||
| of_float [BatInt64] |
Convert the given floating-point number to a 64-bit integer,
discarding the fractional part (truncate towards 0).
| ||
| of_float [BatInt32] |
Convert the given floating-point number to a 32-bit integer,
discarding the fractional part (truncate towards 0).
| ||
| of_float [BatInt.Safe_int] |
Convert the given floating-point number to integer,
discarding the fractional part (truncate towards 0).
| ||
| of_float [BatInt] |
Convert the given floating-point number to integer integer,
discarding the fractional part (truncate towards 0).
| ||
| of_float [BatFloat.Safe_float] | |||
| of_float [BatFloat] | |||
| of_float [BatComplex] | Complex.of_float x returns the complex number x+0i
| ||
| of_float [BatBool] | 0. , nan +infinity and -infiity are false .
| ||
| of_float [BatBig_int] |
rounds to the nearest integer
| ||
| of_float_string [BatNum] |
Convert a simple floating point literal to a num.
| ||
| of_fun [BatStream] | Stream.of_fun f returns a stream built from the function f .
| ||
| of_input [BatSubstring] | |||
| of_input [BatStream] |
Convert an
input to a stream.
| ||
| of_int [BatUChar] |
Alias of
chr
| ||
| of_int [BatString.Cap] | |||
| of_int [BatString] |
Returns the string representation of an int.
| ||
| of_int [BatNumber.NUMERIC_BASE] |
Conversions
| ||
| of_int [BatNumber.Numeric] | |||
| of_int [BatNum] | |||
| of_int [BatNativeint] |
Convert the given integer (type
int ) to a native integer
(type nativeint ).
| ||
| of_int [BatInt64] |
Convert the given integer (type
int ) to a 64-bit integer
(type int64 ).
| ||
| of_int [BatInt32] |
Convert the given integer (type
int ) to a 32-bit integer
(type int32 ).
| ||
| of_int [BatInt.Safe_int] | |||
| of_int [BatInt] | |||
| of_int [BatFloat.Safe_float] | |||
| of_int [BatFloat] | |||
| of_int [BatComplex] | |||
| of_int [BatBool] |
anything but
0 is true
| ||
| of_int [BatBig_int] | |||
| of_int32 [BatNativeint] |
Convert the given 32-bit integer (type
int32 )
to a native integer.
| ||
| of_int32 [BatInt64] |
Convert the given 32-bit integer (type
int32 )
to a 64-bit integer (type int64 ).
| ||
| of_int64 [BatNativeint] |
Convert the given 64-bit integer (type
int64 )
to a native integer.
| ||
| of_int64 [BatInt32] |
Convert the given 64-bit integer (type
int64 ) to a
32-bit integer (type int32 ).
| ||
| of_latin1 [BatText] |
Constructs a unicode rope from a latin-1 string.
| ||
| of_list [BatVect] | |||
| of_list [BatString.Cap] | |||
| of_list [BatString] |
Converts a list of characters to a string.
| ||
| of_list [BatStream] |
Return the stream holding the elements of the list in the same
order.
| ||
| of_list [BatSplay.Map] | |||
| of_list [BatSet.PSet] |
builds a set from the given list, using the default comparison
function
| ||
| of_list [BatSet.S] |
builds a set from the given list.
| ||
| of_list [BatSet] |
builds a set from the given list, using the default comparison
function
| ||
| of_list [BatSeq] |
Convenience function to build a seq from a list.
| ||
| of_list [BatRefList] |
Creates a ref list from a list - O(1)
| ||
| of_list [BatLazyList] |
Lazy conversion from lists
| ||
| of_list [BatISet] |
Build a ISet.t out of a list or enum of ranges
| ||
| of_list [BatHeap.H] |
See
BatHeap.of_list .
| ||
| of_list [BatHeap] |
Build a heap from a given list.
| ||
| of_list [BatGenlex] |
Create a lexer from a list of keywords
| ||
| of_list [BatFingerTree.S] | of_list l is equivalent to of_enum (BatList.enum l) .
| ||
| of_list [BatDynArray] | of_list lst returns a dynamic array with the elements of lst in
it in order.
| ||
| of_list [BatDllist] |
Converts from a normal list to a Dllist and returns the first node.
| ||
| of_list [BatDeque] | of_list l is a deque representation of the elements of l .
| ||
| of_list [BatBitSet] |
As
of_enum , but from a list
| ||
| of_list [BatArray.Cap] | |||
| of_list [BatArray] | Array.of_list l returns a fresh array containing the elements
of l .
| ||
| of_list_backwards [BatFingerTree.S] | of_list_backwards l is equivalent to
of_enum_backwards (BatList.enum l) .
| ||
| of_nativeint [BatInt64] |
Convert the given native integer (type
nativeint )
to a 64-bit integer (type int64 ).
| ||
| of_nativeint [BatInt32] |
Convert the given native integer (type
nativeint )
to a 32-bit integer (type int32 ).
| ||
| of_object [BatEnum] | of_object e returns a representation of an object as an enumeration
| ||
| of_option [BatResult] |
Convert an
option to a result
| ||
| of_stream [BatLazyList] |
Lazy conversion from stream.
| ||
| of_string [BatUnit] |
Convert the given string to a unit.
| ||
| of_string [BatText] | of_string s returns a rope corresponding to the UTF-8 encoded string s .
| ||
| of_string [BatSubstring] | |||
| of_string [BatString.Cap] |
Adopt a regular string.
| ||
| of_string [BatStream] |
Return the stream of the characters of the string parameter.
| ||
| of_string [BatPathGen.PathType] |
Parse path in a given string.
| ||
| of_string [BatNumber.NUMERIC_BASE] |
Convert the representation of a number to the corresponding
number.
| ||
| of_string [BatNumber.Numeric] | |||
| of_string [BatNum] | |||
| of_string [BatNativeint] |
Convert the given string to a native integer.
| ||
| of_string [BatInt64] |
Convert the given string to a 64-bit integer.
| ||
| of_string [BatInt32] |
Convert the given string to a 32-bit integer.
| ||
| of_string [BatInt.Safe_int] |
Convert the given string to an integer
The string is read in decimal (by default) or in hexadecimal,
octal or binary if the string begins with
0x , 0o or 0b
respectively.
| ||
| of_string [BatInt] |
Convert the given string to an integer
The string is read in decimal (by default) or in hexadecimal,
octal or binary if the string begins with
0x , 0o or 0b
respectively.
| ||
| of_string [BatFloat.Safe_float] | |||
| of_string [BatFloat] | |||
| of_string [BatComplex] | of_string s accepts strings with the following formats:
| ||
| of_string [BatBytes] |
Return a new byte sequence that contains the same bytes as the
given string.
| ||
| of_string [BatBool] |
Convert the given string to a boolean.
| ||
| of_string [BatBig_int] | |||
| of_table [BatHashtbl.Cap] |
Adopt a regular hashtable as a capability hashtble, allowing
to decrease capabilities if necessary.
| ||
| of_uchar [BatText] | of_uchar c returns a rope containing exactly character c .
| ||
| oget_exn [BatRef] |
Get a value from an option ref;
| ||
| ok [BatPervasives] | f x |> ok unwraps the Ok result of f x and returns it, or
throws the exception contained if Bad is returned.
| ||
| ok [BatInnerPervasives] | |||
| on_close_out [BatInnerIO] |
Register a function to be triggered just before an output is closed.
| ||
| on_output [BatStream] |
Convert an
output to a stream.
| ||
| one [BatNumber.NUMERIC_BASE] | |||
| one [BatNumber.Numeric] | |||
| one [BatNum] | |||
| one [BatNativeint] |
The native integer 1.
| ||
| one [BatInt64] |
The 64-bit integer 1.
| ||
| one [BatInt32] |
The 32-bit integer 1.
| ||
| one [BatInt.Safe_int] |
The integer
1 .
| ||
| one [BatInt] |
The integer
1 .
| ||
| one [BatFloat.Safe_float] |
Floating number one.
| ||
| one [BatFloat] |
Floating number one.
| ||
| one [BatComplex] |
The complex number
1 .
| ||
| one [BatBool] | |||
| one [BatBig_int] | |||
| one_of [BatParserCo] |
Accept one of several values.
| ||
| one_plus [BatParserCo] |
Accept a (non-empty) list of expressions
| ||
| op_letter [BatGenlex.Languages.Definition] | |||
| op_map [BatSet.Incubator] |
Order Preserving map; as
map , but f must be order preserving;
i.e.
| ||
| op_start [BatGenlex.Languages.Definition] | |||
| opaque_identity [BatSys] |
For the purposes of optimization,
opaque_identity behaves like an
unknown (and thus possibly side-effecting) function.
| ||
| open_box [BatFormat] | open_box d opens a new pretty-printing box
with offset d .
| ||
| open_connection [BatUnix] |
Connect to a server at the given address.
| ||
| open_hbox [BatFormat] | open_hbox () opens a new pretty-printing box.
| ||
| open_hovbox [BatFormat] | open_hovbox d opens a new pretty-printing box
with offset d .
| ||
| open_hvbox [BatFormat] | open_hvbox d opens a new pretty-printing box
with offset d .
| ||
| open_in [BatPervasives] |
Open the named file for reading.
| ||
| open_in [BatFile] | open_in file_name opens the file named file_name for reading.
| ||
| open_in_bin [BatPervasives] |
Same as
Pervasives.open_in , but the file is opened in binary mode,
so that no translation takes place during reads.
| ||
| open_in_gen [BatPervasives] | open_in mode perm filename opens the named file for reading,
as described above.
| ||
| open_out [BatPervasives] |
Open the named file for writing, and return a new output channel
on that file.
| ||
| open_out [BatFile] | open_out file_name opens the file named file_name for writing.
| ||
| open_out_bin [BatPervasives] |
Same as
BatPervasives.open_out , but the file is opened in binary mode, so
that no translation takes place during writes.
| ||
| open_out_gen [BatPervasives] | open_out_gen mode perm filename opens the named file for writing,
as described above.
| ||
| open_process [BatUnix] |
Same as
Unix.open_process_out , but redirects both the
standard input and standard output of the command to pipes
connected to the two returned input /output .
| ||
| open_process_full [BatUnix] |
Similar to
Unix.open_process , but the second argument
specifies the environment passed to the command.
| ||
| open_process_in [BatUnix] |
High-level pipe and process management.
| ||
| open_process_out [BatUnix] |
Same as
Unix.open_process_in , but redirect the standard input of
the command to a pipe.
| ||
| open_tag [BatFormat] | open_tag t opens the tag named t ; the print_open_tag
function of the formatter is called with t as argument;
the tag marker mark_open_tag t will be flushed into the output
device of the formatter.
| ||
| open_tbox [BatFormat] |
Opens a tabulation box.
| ||
| open_temporary_out [BatFile] | open_temporary_out () opens a new temporary file for writing.
| ||
| open_vbox [BatFormat] | open_vbox d opens a new pretty-printing box
with offset d .
| ||
| opendir [BatUnix] |
Open a descriptor on a directory
| ||
| openfile [BatUnix] |
Open the named file with the given flags.
| ||
| operations [BatNumber.Numeric] | |||
| operations [BatNum] | |||
| operations [BatNativeint] | |||
| operations [BatInt.Safe_int] | |||
| operations [BatInt] | |||
| operations [BatFloat.Safe_float] | |||
| operations [BatFloat] | |||
| operations [BatComplex] | |||
| operations [BatBool] | |||
| operations [BatBig_int] | |||
| opt [BatOptParse.Opt] |
Get the value of an option as an optional value.
| ||
| opt_of_ord [BatBounded] | opt_of_ord ~bounds:(low, high) ord will returning a bounding function
using ord for value comparison and None for values which fall outside
of the requested range.
| ||
| or_big_int [BatBig_int] |
Bitwise logical ``or''.
| ||
| ord [BatVect] | |||
| ord [BatUnit] |
Always returns
BatOrd.Eq
| ||
| ord [BatTuple.Tuple5] | |||
| ord [BatTuple.Tuple4] | |||
| ord [BatTuple.Tuple3] | |||
| ord [BatTuple.Tuple2] | |||
| ord [BatString] |
Ordering function for strings, see
BatOrd
| ||
| ord [BatRef] | |||
| ord [BatOrd] |
Returns a variant ordering from a legacy comparison
| ||
| ord [BatOption] |
Comparison between optional values
| ||
| ord [BatNumber.Numeric] | |||
| ord [BatNum] | |||
| ord [BatNativeint] | |||
| ord [BatList] | |||
| ord [BatInt64] | |||
| ord [BatInt32] | |||
| ord [BatInt.Safe_int] | |||
| ord [BatInt] | |||
| ord [BatISet] |
Same as
compare but returns BatOrd.Lt | BatOrd.Eq | BatOrd.Gt
instead of an int.
| ||
| ord [BatFloat] | |||
| ord [BatEnum] |
Same as
compare but returning a BatOrd.order instead of an interger.
| ||
| ord [BatComplex] | |||
| ord [BatOrd.Ord] | |||
| ord [BatChar] | |||
| ord [BatBool] | |||
| ord [BatBitSet] | ord s1 s2 returns BatOrd.Lt , BatOrd.Eq or BatOrd.Gt if compare s1 s2
is, respectively, < 0 , 0 or > 0 .
| ||
| ord [BatBig_int] | |||
| ord [BatArray.Incubator.Ord] | |||
| ord [BatArray.Cap] | |||
| ord [BatArray] |
Hoist an element comparison function to compare arrays of those
elements, with shorter arrays less than longer ones, and
lexicographically for arrays of the same size.
| ||
| ord0 [BatOrd] | |||
| ord_by [BatOrd.Incubator] |
Build a
eq , cmp or ord function from a projection function.
| ||
| os_type [BatSys] |
Operating system currently executing the OCaml program.
| ||
| oset [BatRef] |
Set the given option ref to
Some x
| ||
| other_exec [BatFile] |
Give the permission to execute the file to the rest
of the world.
| ||
| other_read [BatFile] |
Give the permission to read the file to the rest
of the world.
| ||
| other_write [BatFile] |
Give the permission to modify the file to the rest
of the world.
| ||
| out [BatLog.Config] | |||
| out_channel_of_descr [BatUnix] |
Create an output channel writing on the given descriptor.
| ||
| out_of_range [BatUTF8] | out_of_range s i
tests whether i is a position inside of s .
| ||
| output [BatPervasives] | output oc buf pos len writes len characters from string buf ,
starting at offset pos , to the given output channel oc .
| ||
| output [BatMarshal] | output out v writes the representation of v on chan .
| ||
| output [BatLog.Make_lev] | |||
| output [BatLog.Easy] | |||
| output [BatLog] |
This ref holds the output channel for simple logging.
| ||
| output [BatInnerIO] | output o s p l writes up to l characters from string s , starting at
offset p .
| ||
| output [BatIO] | output o s p l writes up to l characters from string s , starting at
offset p .
| ||
| output [BatDigest] |
Write a digest on the given output.
| ||
| output_binary_float [BatPervasives] |
Write one float in binary format (8 bytes, IEEE 754 double format)
on the given output channel.
| ||
| output_binary_int [BatPervasives] |
Write one integer in binary format (4 bytes, big-endian)
on the given output channel.
| ||
| output_buffer [BatBuffer] | output_buffer b creates an output channel that writes to that
buffer, and when closed, returns the contents of the buffer.
| ||
| output_byte [BatPervasives] |
Write one 8-bit integer (as the single character with that code)
on the given output channel.
| ||
| output_channel [BatInnerIO] |
Create an output that will write into a channel.
| ||
| output_char [BatPervasives] |
Write the character on the given output channel.
| ||
| output_file [BatPervasives] |
creates a filename, write text into it and close it.
| ||
| output_of_descr [BatUnix] |
Create an
output writing on the given descriptor.
| ||
| output_string [BatPervasives] |
Write the string on the given output channel.
| ||
| output_string [BatInnerIO] |
Create an output that will write into a string in an efficient way.
| ||
| output_text [BatText] |
Write the text on the given output channel.
| ||
| output_value [BatPervasives] |
Write the representation of a structured value of any type
to a channel.
| ||
| over_max_boxes [BatFormat] |
Tests if the maximum number of boxes allowed have already been opened.
| ||
P | |||
| p [BatPathGen.PathType] | |||
| pack [BatInt32] | pack str off i writes the little endian bit representation
of i into string str at offset off
| ||
| pack_big [BatInt32] | pack_big str off i writes the big endian bit
representation of i into string str at offset off
| ||
| parent [BatPathGen.PathType] |
Returns parent path, i.e.
| ||
| parse [BatOptParse.OptParser] |
Parse arguments as if the arguments
args.(first) ,
args.(first+1) , ..., args.(last) had been given on the
command line.
| ||
| parse [BatCharParser] |
Apply a parser to a string.
| ||
| parse_argv [BatOptParse.OptParser] |
Parse all the arguments in
Sys.argv .
| ||
| partition [BatVect] | partition p v returns a pair of vects (v1, v2) , where
v1 is the vect of all the elements of v that
satisfy the predicate p , and v2 is the vect of all the
elements of v that do not satisfy p .
| ||
| partition [BatSet.PSet] |
returns two disjoint subsets, those that satisfy the given
predicate and those that don't
| ||
| partition [BatSet.S.Labels] | |||
| partition [BatSet.S] | partition p s returns a pair of sets (s1, s2) , where
s1 is the set of all the elements of s that satisfy the
predicate p , and s2 is the set of all the elements of
s that do not satisfy p .
| ||
| partition [BatSet] |
returns two disjoint subsets, those that satisfy the given
predicate and those that don't
| ||
| partition [BatMap.PMap] | partition p m returns a pair of maps (m1, m2) , where m1
contains all the bindings of s that satisfy the predicate
p , and m2 is the map with all the bindings of s that do
not satisfy p .
| ||
| partition [BatMap.S] | partition p m returns a pair of maps (m1, m2) , where
m1 contains all the bindings of s that satisfy the
predicate p , and m2 is the map with all the bindings of
s that do not satisfy p .
| ||
| partition [BatMap] | partition p m returns a pair of maps (m1, m2) , where m1
contains all the bindings of s that satisfy the predicate
p , and m2 is the map with all the bindings of s that do
not satisfy p .
| ||
| partition [BatList.Labels] | |||
| partition [BatList] | partition p l returns a pair of lists (l1, l2) , where
l1 is the list of all the elements of l that
satisfy the predicate p , and l2 is the list of all the
elements of l that do not satisfy p .
| ||
| partition [BatISet] |
partitions the input set into two sets with elements that satisfy
the predicate and those that don't
| ||
| partition [BatEnum] |
as
switch
| ||
| partition [BatArray.Cap] | |||
| partition [BatArray] | partition p a returns a pair of arrays (a1, a2) , where
a1 is the array of all the elements of a that
satisfy the predicate p , and a2 is the array of all the
elements of a that do not satisfy p .
| ||
| pass [BatPrintexc] | Printexc.pass fn x applies fn to x and returns the result.
| ||
| pause [BatUnix] |
Wait until a non-ignored, non-blocked signal is delivered.
| ||
| peek [BatStream] |
Return
Some of "the first element" of the stream, or None if
the stream is empty.
| ||
| peek [BatQueue.Exceptionless] | |||
| peek [BatQueue] | peek q returns the first element in queue q , without removing
it from the queue, or raises Empty if the queue is empty.
| ||
| peek [BatPervasives] | peek e returns None if e is empty or Some x where x is
the next element of e .
| ||
| peek [BatLazyList] | peek l returns the first element of l , if it exists.
| ||
| peek [BatEnum] | peek e returns None if e is empty or Some x where x is
the next element of e .
| ||
| perm [BatFile] |
Join permissions
| ||
| perturb [BatRandom.Incubator.Private_state_enums.State] | perturb s returns a new state based on the given state
that is, in a sense, the hash of the input state.
| ||
| pi [BatFloat.Safe_float] |
The constant pi (3.14159...)
| ||
| pi [BatFloat] |
The constant pi (3.14159...)
| ||
| pi2 [BatFloat] | pi /. 2.
| ||
| pi4 [BatFloat] | pi /. 4.
| ||
| pipe [BatUnix] |
Create a pipe.
| ||
| pipe [BatInnerIO] |
Create a pipe between an input and an ouput.
| ||
| polar [BatComplex] | polar norm arg returns the complex having norm norm
and argument arg .
| ||
| poly [BatOrd] |
Polymorphic comparison functions, based on the
Pervasives.compare function from inria's stdlib, have
polymorphic types: they claim to be able to compare values of any
type.
| ||
| poly_comp [BatOrd] | |||
| poly_ord [BatOrd] | |||
| pop [BatVect] |
Return the last element of a vector and its first
n-1 elements.
| ||
| pop [BatStack.Exceptionless] | |||
| pop [BatStack] | pop s removes and returns the topmost element in stack s ,
or
| ||
| pop [BatSet.PSet] |
returns one element of the set and the set without that element.
| ||
| pop [BatSet.S] |
returns one element of the set and the set without that element.
| ||
| pop [BatSet] |
returns one element of the set and the set without that element.
| ||
| pop [BatRefList] |
Removes and returns the first element or
raises
Empty_list if the ref list is empty
| ||
| pop [BatQueue] | pop is a synonym for take .
| ||
| pop [BatMap.PMap] | pop m returns a binding from m and m without that
binding.
| ||
| pop [BatMap.S] | pop m returns a binding from m and m without that
binding.
| ||
| pop [BatMap] | pop m returns a binding from m and m without that
binding.
| ||
| pop_max [BatSet.PSet] |
Returns the biggest element of the given set
along with the rest of the set.
| ||
| pop_max [BatSet.S] |
Returns the biggest element of the given set
along with the rest of the set.
| ||
| pop_max [BatSet] |
Returns the biggest element of the given set
along with the rest of the set.
| ||
| pop_max_binding [BatMap.PMap] |
return the binding with the largest key along with the rest of the map
| ||
| pop_max_binding [BatMap.S] |
return the (
key,value ) pair with the largest key
along with the rest of the map
| ||
| pop_max_binding [BatMap] |
returns the binding with the largest key along with the rest of the map
| ||
| pop_min [BatSet.PSet] |
Returns the smallest element of the given set
along with the rest of the set.
| ||
| pop_min [BatSet.S] |
Returns the smallest element of the given set
along with the rest of the set.
| ||
| pop_min [BatSet] |
Returns the smallest element of the given set
along with the rest of the set.
| ||
| pop_min_binding [BatMap.PMap] |
return the binding with the smallest key along with the rest of the map
| ||
| pop_min_binding [BatMap.S] |
return the (
key,value ) pair with the smallest key
along with the rest of the map
| ||
| pop_min_binding [BatMap] |
returns the binding with the smallest key along with the rest of the map
| ||
| popcount [BatInt] |
Returns the number of 1 bits set in the binary representation of
the number.
| ||
| post [BatRef] |
Perform an operation on a reference and return the
previous value of that reference.
| ||
| post_decr [BatRef] |
Decrement an integer, return the old value.
| ||
| post_incr [BatRef] |
Increment an integer, return the old value.
| ||
| post_map [BatParserCo] |
Pass the (successful) result of some parser through a map.
| ||
| pow [BatNumber.NUMERIC_BASE] | |||
| pow [BatNumber.Numeric] | |||
| pow [BatNum] | |||
| pow [BatNativeint] | |||
| pow [BatInt32] | |||
| pow [BatInt.Safe_int] | pow a b computes ab.
| ||
| pow [BatInt] | pow a b computes ab.
| ||
| pow [BatFloat.Safe_float] | |||
| pow [BatFloat] | |||
| pow [BatComplex] |
Power function.
| ||
| pow [BatBool] | |||
| pow [BatBig_int] | |||
| power_big_int_positive_big_int [BatBig_int] |
Exponentiation functions.
| ||
| power_big_int_positive_int [BatBig_int] | |||
| power_int_positive_big_int [BatBig_int] | |||
| power_int_positive_int [BatBig_int] | |||
| power_num [BatNum] | |||
| pp [BatIO.Incubator.List] |
Print the contents of a list, with
first preceeding the first item
(default: "[" ), last following the last item (default: "]" )
and sep separating items (default: "; " ).
| ||
| pp [BatIO.Incubator.Enum] |
Print the contents of an enum, with
first preceeding the first item
(default: "" ), last following the last item (default: "" )
and sep separating items (default: " " ).
| ||
| pp [BatIO.Incubator.Array] |
Print the contents of an array, with
first preceeding the first item
(default: "[|" ), last following the last item (default: "|]" )
and sep separating items (default: "; " ).
| ||
| pp_close_box [BatFormat] | |||
| pp_close_tag [BatFormat] | |||
| pp_close_tbox [BatFormat] | |||
| pp_force_newline [BatFormat] | |||
| pp_get_all_formatter_output_functions [BatFormat] | |||
| pp_get_ellipsis_text [BatFormat] | |||
| pp_get_formatter_output_functions [BatFormat] | |||
| pp_get_formatter_tag_functions [BatFormat] |
These functions are the basic ones: usual functions
operating on the standard formatter are defined via partial
evaluation of these primitives.
| ||
| pp_get_margin [BatFormat] | |||
| pp_get_mark_tags [BatFormat] | |||
| pp_get_max_boxes [BatFormat] | |||
| pp_get_max_indent [BatFormat] | |||
| pp_get_print_tags [BatFormat] | |||
| pp_open_box [BatFormat] | |||
| pp_open_hbox [BatFormat] | |||
| pp_open_hovbox [BatFormat] | |||
| pp_open_hvbox [BatFormat] | |||
| pp_open_tag [BatFormat] | |||
| pp_open_tbox [BatFormat] | |||
| pp_open_vbox [BatFormat] | |||
| pp_over_max_boxes [BatFormat] | |||
| pp_print_as [BatFormat] | |||
| pp_print_bool [BatFormat] | |||
| pp_print_break [BatFormat] | |||
| pp_print_char [BatFormat] | |||
| pp_print_cut [BatFormat] | |||
| pp_print_float [BatFormat] | |||
| pp_print_flush [BatFormat] | |||
| pp_print_if_newline [BatFormat] | |||
| pp_print_int [BatFormat] | |||
| pp_print_list [BatFormat] | pp_print_list ?pp_sep pp_v ppf l prints the list l .
| ||
| pp_print_newline [BatFormat] | |||
| pp_print_space [BatFormat] | |||
| pp_print_string [BatFormat] | |||
| pp_print_tab [BatFormat] | |||
| pp_print_tbreak [BatFormat] | |||
| pp_print_text [BatFormat] | pp_print_text ppf s prints s with spaces and newlines
respectively printed with BatFormat.pp_print_space and
BatFormat.pp_force_newline .
| ||
| pp_set_all_formatter_output_functions [BatFormat] | |||
| pp_set_ellipsis_text [BatFormat] | |||
| pp_set_formatter_out_channel [BatFormat] | |||
| pp_set_formatter_output [BatFormat] | |||
| pp_set_formatter_output_functions [BatFormat] | |||
| pp_set_formatter_tag_functions [BatFormat] | |||
| pp_set_margin [BatFormat] | |||
| pp_set_mark_tags [BatFormat] | |||
| pp_set_max_boxes [BatFormat] | |||
| pp_set_max_indent [BatFormat] | |||
| pp_set_print_tags [BatFormat] | |||
| pp_set_tab [BatFormat] | |||
| pp_set_tags [BatFormat] | |||
| pre [BatRef] |
Perform an operation on a reference and return the
new value of that reference.
| ||
| pre_decr [BatRef] |
Increment an integer, return the new value.
| ||
| pre_incr [BatRef] |
Increment an integer, return the new value.
| ||
| pred [BatNumber.NUMERIC_BASE] | |||
| pred [BatNumber.Discrete] | |||
| pred [BatNumber.Numeric] | |||
| pred [BatNum] | |||
| pred [BatNativeint] |
Predecessor.
| ||
| pred [BatInt64] |
Predecessor.
| ||
| pred [BatInt32] |
Predecessor.
| ||
| pred [BatInt.Safe_int] |
Predecessor.
| ||
| pred [BatInt] |
Predecessor.
| ||
| pred [BatFloat.Safe_float] |
Substract
1. from a floating number.
| ||
| pred [BatFloat] |
Substract
1. from a floating number.
| ||
| pred [BatComplex] |
Remove
BatComplex.one from this number.
| ||
| pred [BatBool] | |||
| pred [BatBig_int] | |||
| pred_big_int [BatBig_int] |
Predecessor (subtract 1).
| ||
| pred_num [BatNum] | |||
| prefix [BatLog.Config] | |||
| prefix [BatLog] |
This ref holds the text printed before each log message.
| ||
| prefix_action [BatEnum] | prefix_action f e will behave as e but guarantees that f ()
will be invoked exactly once before the current first element of e
is read.
| ||
| prepend [BatVect] | prepend c r returns a new vect with the c character at the
beginning in amortized O(1) time.
| ||
| prepend [BatDllist] | prepend n a Creates a new node containing data a and inserts it into
the list before node n .
| ||
| prepend_char [BatText] | prepend_char c r returns a new rope with the c character at the
beginning in amortized O(1) time.
| ||
| prepend_list [BatDeque] | prepent_list l dq is equivalent to append (of_list l) dq ,
but more efficient.
| ||
| prerr_all [BatPervasives] |
Print the contents of an input to the error output.
| ||
| prerr_bool [BatPervasives] |
Print a boolean to stderr.
| ||
| prerr_guess [BatPervasives] |
Attempt to print the representation of a runtime value on the
error output.
| ||
| prev [BatUTF8] | prev s i
returns the position of the head of the Unicode character
located immediately before i .
| ||
| prev [BatDllist] |
Given a node, get the previous element in the list before the node.
| ||
| print [BatVect] | |||
| print [BatUref] |
Print the uref.
| ||
| print [BatUnit] |
Printing
| ||
| print [BatTuple.Tuple5] | |||
| print [BatTuple.Tuple4] | |||
| print [BatTuple.Tuple3] | |||
| print [BatTuple.Tuple2] | |||
| print [BatText] |
Prints a rope to the given out_channel
| ||
| print [BatSubstring] | print oc ss prints ss to the output channel oc
| ||
| print [BatString.Cap] | |||
| print [BatString] |
Print a string.
| ||
| print [BatStack] | |||
| print [BatSet.PSet] | |||
| print [BatSet.S] | |||
| print [BatSet] | |||
| print [BatSeq] |
Print the contents of a sequence
| ||
| print [BatResult] |
Print a result as Ok(x) or Bad(exn)
| ||
| print [BatRef] | |||
| print [BatQueue] | |||
| print [BatPrintexc] |
Print an exception.
| ||
| print [BatPervasives] |
Print and consume the contents of an enumeration.
| ||
| print [BatOption] | |||
| print [BatNum] |
Printing
| ||
| print [BatNativeint] | |||
| print [BatMultiPMap] | |||
| print [BatMultiMap] | |||
| print [BatMap.PMap] | |||
| print [BatMap.S] | |||
| print [BatMap] | |||
| print [BatList] |
Print the contents of a list
| ||
| print [BatLazyList] | |||
| print [BatInt.Safe_int] | |||
| print [BatInt] |
prints as decimal string
| ||
| print [BatISet] | |||
| print [BatHeap.H] |
See
BatHeap.print .
| ||
| print [BatHeap] |
Print the contents of the heap in heap order.
| ||
| print [BatHashtbl.Cap] | |||
| print [BatHashtbl.S] | |||
| print [BatHashtbl] | |||
| print [BatFloat.Safe_float] |
Printing
| ||
| print [BatFloat] |
Printing
| ||
| print [BatFingerTree.S] | |||
| print [BatEnum] |
Print and consume the contents of an enumeration.
| ||
| print [BatDynArray] | |||
| print [BatDllist] | |||
| print [BatDigest] |
Write a digest on the given output in hexadecimal.
| ||
| print [BatDeque] |
Print the contents of the deque.
| ||
| print [BatComplex] |
Printing
| ||
| print [BatChar] | |||
| print [BatBuffer] | |||
| print [BatBool] |
Printing
| ||
| print [BatBitSet] | |||
| print [BatBig_int] | |||
| print [BatArray.Cap] | |||
| print [BatArray] |
Print the contents of an array, with
~first preceeding the first
item (default: "[|"), ~last following the last item (default:
"|]") and ~sep separating items (default: "; ").
| ||
| print_all [BatPervasives] |
Print the contents of an input to the standard output.
| ||
| print_any [BatPervasives] |
Attempt to print a value to an output.
| ||
| print_as [BatFormat] | print_as len str prints str in the
current box.
| ||
| print_as_list [BatSplay.Map] | |||
| print_at_most [BatEnum] | print_at_most pp limit out enum consumes enum to print its elements
into out (using pp to print individual elements).
| ||
| print_backtrace [BatPrintexc] | print_backtrace oc Prints the an exception backtrace on the
output channel oc .
| ||
| print_bool [BatPervasives] |
Print a boolean on standard output.
| ||
| print_bool [BatFormat] |
Prints a boolean in the current box.
| ||
| print_break [BatFormat] |
Inserts a break hint in a pretty-printing box.
| ||
| print_char [BatFormat] |
Prints a character in the current box.
| ||
| print_cut [BatFormat] | print_cut () is used to mark a good break position.
| ||
| print_float [BatFormat] |
Prints a floating point number in the current box.
| ||
| print_flush [BatFormat] |
Flushes the pretty printer: all opened boxes are closed,
and all pending text is displayed.
| ||
| print_guess [BatPervasives] |
Attempt to print the representation of a runtime value on the
standard output.
| ||
| print_hex [BatInt] |
prints as hex string
| ||
| print_if_newline [BatFormat] |
Executes the next formatting command if the preceding line
has just been split.
| ||
| print_int [BatFormat] |
Prints an integer in the current box.
| ||
| print_newline [BatFormat] |
Equivalent to
print_flush followed by a new line.
| ||
| print_quoted [BatString.Cap] | |||
| print_quoted [BatString] |
Print a string, with quotes as added by the
quote function.
| ||
| print_raw_backtrace [BatPrintexc] |
Print a raw backtrace in the same format
Printexc.print_backtrace uses.
| ||
| print_rope [BatteriesPrint] | |||
| print_space [BatFormat] | print_space () is used to separate items (typically to print
a space between two words).
| ||
| print_stat [BatGc] |
Print the current values of the memory management counters (in
human-readable form) into the channel argument.
| ||
| print_string [BatFormat] | print_string str prints str in the current box.
| ||
| print_string_cap_ro [BatteriesPrint] | |||
| print_string_cap_rw [BatteriesPrint] | |||
| print_tab [BatFormat] | print_tab () is equivalent to print_tbreak 0 0 .
| ||
| print_tbreak [BatFormat] |
Break hint in a tabulation box.
| ||
| print_uchar [BatteriesPrint] | |||
| print_ustring [BatteriesPrint] | |||
| printf [BatPrintf] |
The usual