B | |
| b_idx [BatUTF8.Byte] | |
| buf [BatUTF8.Buf] |
Buffers for UTF-8 strings.
|
C | |
| c_layout [BatBigarray] |
See
Bigarray.fortran_layout.
|
| category [BatUChar] | |
| char_idx [BatUTF8] |
Positions in the string as indexes by characters.
|
| closure [BatOo.Oo.Internal] |
Internal representation of a method.
|
| command [BatArg] |
The type describing both the name, documentation and behavior
associated with a keyword.
|
| complex32_elt [BatBigarray] | |
| complex64_elt [BatBigarray] | |
| components [BatPathGen.PathType] |
A
path can be represented by the following triple:
(Path.parent path, Path.name_core path, Path.ext path)
|
D | |
| decoding_table [BatBase64] |
A decoding table maps chars 0..255 to the corresponding 0..63 value
or -1 if the char is not accepted.
|
| directive [BatPrint] |
The underlying type of a directive.
|
E | |
| elt [BatSet.S] |
The type of the set elements.
|
| elt [BatISet] | |
| encoding [BatCharEncodings] |
The list if known encodings.
|
| encoding_table [BatBase64] |
An encoding table maps integers 0..63 to the corresponding char.
|
| enumerable [BatEnum.Enumerable] |
The data structure, e.g.
|
| event [BatLogger] |
A log
event consists of an event name and a list of key-value
parameters (an association list).
|
F | |
| float32_elt [BatBigarray] | |
| float64_elt [BatBigarray] | |
| formatter [BatLogger] |
the type of a log formatter is a function that takes the
logger, the level of the log statement (which will be the
currently enabled level or one of its successors), the event
record, and a unix timestamp indicating the time the event was
created.
|
| fortran_layout [BatBigarray] |
To facilitate interoperability with existing C and Fortran code,
this library supports two different memory layouts for big arrays,
one compatible with the C conventions,
the other compatible with the Fortran conventions.
|
| fpkind [BatFloat.Safe_float] |
Classes of floating point numbers
|
| fpkind [BatFloat] |
Classes of floating point numbers
|
G | |
| group [BatOptParse.OptParser] |
The type of an option group.
|
I | |
| impl [BatOo.Oo.Internal] | |
| in_bits [BatIO] | |
| index [BatUTF8] | |
| init_table [BatOo.Oo.Internal] | |
| input [BatInnerIO] | |
| input [BatIO] |
The abstract input type.
|
| int16_signed_elt [BatBigarray] | |
| int16_unsigned_elt [BatBigarray] | |
| int32_elt [BatBigarray] | |
| int64_elt [BatBigarray] | |
| int8_signed_elt [BatBigarray] | |
| int8_unsigned_elt [BatBigarray] | |
| int_elt [BatBigarray] | |
K | |
| key [BatMap.S] |
The type of the map keys.
|
| key [BatIMap] | |
| key [BatHashtbl.S] | |
| kind [BatBigarray] |
To each element kind is associated a Caml type, which is
the type of Caml values that can be stored in the big array
or read back from it.
|
L | |
| label [BatOo.Oo.Internal] | |
| layout [BatBigarray] |
The type
'a layout represents one of the two supported
memory layouts: C-style if 'a is Bigarray.c_layout, Fortran-style
if 'a is Bigarray.fortran_layout.
|
| level [BatLogger] | |
| lock [BatConcurrent] |
The light-weight type of a lock, i.e.
|
| log [BatLogger] | |
M | |
| m [BatOption.Monad] |
The type of values in this monad : option
|
| m [BatMonad.S] |
The type of a monad producing values of type
'a.
|
| m [BatEnum.Monad] |
The type of the BatEnum monad's elements, thus
BatEnum.t.
|
| m [BatEnum.WithMonad] |
Type of the monadic elements.
|
| mappable [BatInterfaces.Mappable] |
The data structure, e.g.
|
| meth [BatOo.Oo.Internal] | |
N | |
| nativeint_elt [BatBigarray] | |
| node [BatSeq] | |
| node_t [BatLazyList] | |
| node_t [BatDllist] | |
| num [BatNum] |
The type of numbers.
|
| numeric [BatNumber] |
The smallest set of operations supported by every set of numbers.
|
O | |
| obj [BatOo.Oo.Internal] |
Internal representation of an object.
|
| open_in_flag [BatFile] | |
| open_out_flag [BatFile] |
Flags governing file output; they correspond to the relevant
flags to the POSIX
open() call.
|
| open_temporary_out_flag [BatFile] | |
| out_bits [BatIO] | |
| output [BatInnerIO] | |
| output [BatIO] |
The abstract output type,
'a is the accumulator data, it is returned
when the close_out function is called.
|
P | |
| params [BatOo.Oo.Internal] |
currently disabled
|
| permission [BatFile] |
The list of operations which are permitted on a file.
|
| position [BatUCharParser] |
The position inside one file or one stream.
|
| position [BatCharParser] |
The position inside one file or one stream.
|
R | |
| report [BatParserCo] | |
| resizer_t [BatDynArray] |
The type of a resizer function.
|
| result [BatStd] | |
| result [BatPervasives] | |
S | |
| scanbuf [BatScanf.Scanning] |
The type of scanning buffers.
|
| scanner [BatScanf] |
The type of formatted input scanners:
('a, 'b, 'c, 'd) scanner is the
type of a formatted input function that reads from some scanning buffer
according to some format string; more precisely, if scan is some
formatted input function, then scan ib fmt f applies f to the arguments
specified by the format string fmt, when scan has read those arguments
from the scanning input buffer ib.
|
| script [BatUChar] | |
| state [BatParserCo] |
The current state of the parser.
|
| stats [BatOo.Oo.Internal] | |
T | |
| t [BatVect.RANDOMACCESS] | |
| t [BatVect.Make] |
The type of a polymorphic vect.
|
| t [BatVect] |
The type of a polymorphic vect.
|
| t [BatValue_printer] |
Type of a value-printer, the boolean argument indicates whether
composed expression must be parenthesized.
|
| t [BatUnit] |
The unit type, i.e.
|
| t [BatUTF8] |
UTF-8 encoded Unicode strings.
|
| t [BatSubstring] | Substring.t is the type of substrings of a basestring, an efficient
representation of a piece of a string.
|
| t [BatSet.S] |
The type of sets.
|
| t [BatSet] |
The type of sets.
|
| t [BatSeq] |
A sequence is a computation which returns a list-like node
|
| t [BatRope] |
The type of the ropes.
|
| t [BatReturn] |
A label which may be used to return values of type
'a
|
| t [BatResult] |
The type of a result
|
| t [BatRefList] |
The type of an empty ref list
|
| t [BatRef] |
The type of references.
|
| t [BatRandom.State] |
The type of PRNG states.
|
| t [BatRMutex] |
The type of mutexes.
|
| t [BatPrintf] |
The format to use for displaying the various arguments passed to the function.
|
| t [BatPathGen.StringType] |
Type for strings.
|
| t [BatPathGen.PathType] |
A type for storing paths.
|
| t [BatParserCo.Source] |
A source of elements of type
'a, with a user-defined state
of type 'b
|
| t [BatParserCo] |
A parser for elements of type
'a, producing
elements of type 'b, with user-defined states
of type 'c.
|
| t [BatPair] | |
| t [BatPSet] |
The type of sets.
|
| t [BatPMap] | |
| t [BatOption] | |
| t [BatOptParse.OptParser] |
The type of an option parser.
|
| t [BatOptParse.Formatter] | |
| t [BatOptParse.Opt] |
Option type.
|
| t [BatOo.Oo.Internal] | |
| t [BatNumber.Discrete] | |
| t [BatNumber.Bounded] | |
| t [BatNumber.Numeric] | |
| t [BatNum] | |
| t [BatNativeint] |
An alias for the type of native integers.
|
| t [BatMutex.Mutex] |
The type of mutexes.
|
| t [BatMultiPMap] | |
| t [BatMap.S] |
The type of maps from type
key to type 'a.
|
| t [BatMap] | |
| t [BatList] |
List operations.
|
| t [BatLazyList] |
The type of a lazy list.
|
| t [BatInterfaces.OrderedType] | |
| t [BatInt64] | |
| t [BatInt32] | |
| t [BatInt.Safe_int] |
An alias for the type of integers.
|
| t [BatInt] |
An alias for the type of integers.
|
| t [BatInnerWeaktbl] |
The type of hash tables from type
'a to type 'b.
|
| t [BatInnerIO.Printf] |
The format to use for displaying the various arguments passed to the function.
|
| t [BatInnerIO.Output] | |
| t [BatInnerIO.Input] | |
| t [BatISet] | |
| t [BatIMap] | |
| t [BatHashtbl.HashedType] |
The type of the hashtable keys.
|
| t [BatHashtbl.Cap] |
The type of a hashtable.
|
| t [BatHashtbl.S] | |
| t [BatHashtbl] |
A Hashtable wth keys of type 'a and values 'b
|
| t [BatGlobal] |
Abstract type of a global
|
| t [BatGenlex] |
A lexer
|
| t [BatFloat.Safe_float] |
The type of floating-point numbers.
|
| t [BatFloat] |
The type of floating-point numbers.
|
| t [BatEnum] | |
| t [BatDynArray] | |
| t [BatDllist] | |
| t [BatConcurrent.BaseLock] |
The type of a lock.
|
| t [BatConcurrent.Lock] |
The type of a lock.
|
| t [BatCharEncodings] |
The type of items of type
'a, encoded using encoding 'b.
|
| t [BatBool] |
The type of booleans.
|
| t [BatBitSet] | |
| t [BatBigarray.Array3] |
The type of three-dimensional big arrays whose elements have
Caml type
'a, representation kind 'b, and memory layout 'c.
|
| t [BatBigarray.Array2] |
The type of two-dimensional big arrays whose elements have
Caml type
'a, representation kind 'b, and memory layout 'c.
|
| t [BatBigarray.Array1] |
The type of one-dimensional big arrays whose elements have
Caml type
'a, representation kind 'b, and memory layout 'c.
|
| t [BatBigarray.Genarray] |
The type
Genarray.t is the type of big arrays with variable
numbers of dimensions.
|
| t [BatBig_int] | |
| t [BatArray] |
The type of arrays.
|
| table [BatOo.Oo.Internal] |
Internal representation of the vtable, i.e.
|
| tables [BatOo.Oo.Internal] | |
| tag [BatOo.Oo.Internal] | |
| tchar [BatPathGen.StringType] |
Character type used by
t.
|
| tree [BatAvlTree] | |
U | |
| uchar [BatPathGen.PathType] |
Type of characters.
|
| ustring [BatPathGen.PathType] |
Type of strings used.
|
V | |
| validator [BatPathGen.PathType] |
Validators should check if all characters of given string can be used in a name (path component).
|