A | |
| access_permission [BatUnix] |
Flags for the
Unix.access call.
|
| addr_info [BatUnix] |
Address information returned by
Unix.getaddrinfo.
|
| alarm [BatGc] |
An alarm is a piece of data that calls a user function at the end of
each major GC cycle.
|
| auto_cache [BatCache] |
Automatically managed caches
|
B | |
| backtrace_slot [BatPrintexc] |
The abstract type
backtrace_slot represents a single slot of
a backtrace.
|
| base_t [BatBounded.BoundedType] |
The base/raw type
|
| base_u [BatBounded.S] |
Raw unbounded type
|
| bat__compare_t [BatNumber.Compare] | |
| bat__infix_t [BatNumber.Infix] | |
| bat__refops_t [BatNumber.RefOps] | |
| big_int [BatBig_int] |
The type of big integers.
|
| bound_t [BatBounded] | `open or `closed or `unbounded bounds
|
| bounded [BatNumber.Bounded] | |
| bounding_f [BatBounded] |
The type of a bounding function with limits specified by
bounds
|
| buf [BatUTF8.Buf] |
Buffers for UTF-8 strings.
|
| bytes [Batteries] | |
C | |
| c_layout [BatBigarray] | |
| choice [BatOrd] |
choice functions, see
min and max.
|
| closure [BatOo.Internal] |
Internal representation of a method.
|
| comp [BatOrd] |
The legacy int-returning comparisons : compare a b < 0 means a < b, compare a b = 0 means a = b, compare a b > 0 means a > b
|
| 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)
|
| control [BatGc] |
The GC parameters are given as a
control record.
|
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.
|
| dir_handle [BatUnix] |
The type of descriptors over opened directories.
|
| discrete [BatNumber.Discrete] | |
| discrete [BatNumber.Numeric] | |
| dq [BatDeque] |
The type of double-ended queues
|
E | |
| easy_lev [BatLog] |
The different verbosity levels supported in the
Easy logger
|
| elem [BatHeap.H] |
Type of elements of the heap
|
| elt [BatSet.S] |
The type of the set elements.
|
| elt [BatISet] |
This kind of set only holds ints
|
| encoding_table [BatBase64] |
An encoding table maps integers 0..63 to the corresponding char.
|
| enumerable [BatQueue] | |
| enumerable [BatEnum.Enumerable] |
The data structure, e.g.
|
| eq [BatOrd] |
The type for equality function.
|
| error [BatUnix] |
The type of error codes.
|
| event [BatLogger] |
A log
event consists of an event name and a list of key-value
parameters (an association list).
|
| extern_flags [BatMarshal] |
The flags to the
Marshal.to_* functions below.
|
F | |
| f_printer [BatIO] | |
| fg [BatFingerTree.S] |
The type of finger trees containing elements of type
'a
measured by 'm.
|
| file_descr [BatUnix] |
The abstract type of file descriptors.
|
| file_kind [BatUnix] | |
| file_perm [BatUnix] |
The type of file access rights, e.g.
|
| flag [BatLog] | |
| float32_elt [BatBigarray] | |
| float64_elt [BatBigarray] | |
| flow_action [BatUnix] | |
| flush_queue [BatUnix] | |
| 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.
|
| formatter [BatFormat] |
Abstract data corresponding to a pretty-printer (also called a
formatter) and all its machinery.
|
| formatter_tag_functions [BatFormat] |
The tag handling functions specific to a formatter:
mark versions are the ``tag marking'' functions that associate a string
marker to a tag in order for the pretty-printing engine to flush
those markers as 0 length tokens in the output device of the formatter.
|
| fortran_layout [BatBigarray] | |
| fpkind [BatFloat.Safe_float] |
Classes of floating point numbers
|
| fpkind [BatFloat] |
Classes of floating point numbers
|
G | |
| getaddrinfo_option [BatUnix] |
Options to
Unix.getaddrinfo.
|
| getnameinfo_option [BatUnix] |
Options to
Unix.getnameinfo.
|
| group [BatOptParse.OptParser] |
The type of an option group.
|
| group_entry [BatUnix] |
Structure of entries in the
groups database.
|
H | |
| hobj [BatHashcons] |
The type
t hobj represents hashed objects of type t.
|
| host_entry [BatUnix] |
Structure of entries in the
hosts database.
|
I | |
| impl [BatOo.Internal] | |
| in_bits [BatIO] | |
| index [BatUTF8] |
Positions in the string represented by the number of bytes from the head.
|
| inet_addr [BatUnix] |
The abstract type of Internet addresses.
|
| init_table [BatOo.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] | |
| interval_timer [BatUnix] |
The three kinds of interval timers.
|
| interval_timer_status [BatUnix] |
The type describing the status of an interval timer
|
K | |
| key [BatMap.S] |
The type of the map keys.
|
| key [BatIMap] | |
| key [BatHashtbl.S] | |
| key [BatHashcons.Table] |
type of objects in the table
|
| kind [BatBigarray] | |
L | |
| label [BatOo.Internal] | |
| layout [BatBigarray] | |
| level [BatLogger] | |
| lexbuf [BatLexing] |
The type of lexer buffers.
|
| lexer_error [BatGenlex] | |
| location [BatPrintexc] |
The type of location information found in backtraces.
|
| lock [BatConcurrent] |
The light-weight type of a lock, i.e.
|
| lock_command [BatUnix] |
Commands for
Unix.lockf.
|
| log [BatLogger] | |
M | |
| m [BatOption.Monad] |
The type of values in this monad : option
|
| m [BatInterfaces.Monad] |
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.
|
| manual_cache [BatCache] | |
| mappable [BatInterfaces.Mappable] |
The data structure, e.g.
|
| meth [BatOo.Internal] | |
| monoid [BatFingerTree] |
The type of the element of a monoid.
|
| msg_flag [BatUnix] | |
N | |
| name_info [BatUnix] |
Name of service or port number
|
| 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.Internal] |
Internal representation of an object.
|
| open_flag [BatUnix] |
The flags to
Unix.openfile.
|
| 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] | |
| ord [BatOrd] |
The type of ordering functions returning an
order variant.
|
| order [BatOrd] | |
| 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.Internal] |
currently disabled
|
| passwd_entry [BatUnix] |
Structure of entries in the
passwd database.
|
| permission [BatFile] |
The list of operations which are permitted on a file.
|
| position [BatLexing] |
A value of type
position describes a point in a source file.
|
| position [BatCharParser] |
The position inside one file or one stream.
|
| printer [BatIO] |
The type of a printing function to print a
'a to an output that
produces 'b as result.
|
| process_status [BatUnix] |
The termination status of a process.
|
| process_times [BatUnix] |
The execution times (CPU times) of a process.
|
| protocol_entry [BatUnix] |
Structure of entries in the
protocols database.
|
R | |
| raw_backtrace [BatPrintexc] |
The abstract type
raw_backtrace stores a backtrace in
a low-level format, instead of directly exposing them as string as
the get_backtrace() function does.
|
| raw_backtrace_slot [BatPrintexc] |
This type allows direct access to raw backtrace slots, without any
conversion in an OCaml-usable data-structure.
|
| report [BatParserCo] | |
| resizer_t [BatDynArray] |
The type of a resizer function.
|
| result [BatPervasives] |
This type represents the outcome of a function which has the
possibility of failure.
|
| result [BatInnerPervasives] | |
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.
|
| seek_command [BatUnix] |
Positioning modes for
Unix.lseek.
|
| service_entry [BatUnix] |
Structure of entries in the
services database.
|
| setattr_when [BatUnix] | |
| shutdown_command [BatUnix] |
The type of commands for
shutdown.
|
| signal_behavior [BatSys] | |
| sigprocmask_command [BatUnix] | |
| sockaddr [BatUnix] | |
| socket_bool_option [BatUnix] |
The socket options that can be consulted with
Unix.getsockopt
and modified with Unix.setsockopt.
|
| socket_domain [BatUnix] |
The type of socket domains.
|
| socket_float_option [BatUnix] |
The socket options that can be consulted with
Unix.getsockopt_float
and modified with Unix.setsockopt_float.
|
| socket_int_option [BatUnix] |
The socket options that can be consulted with
Unix.getsockopt_int
and modified with Unix.setsockopt_int.
|
| socket_optint_option [BatUnix] |
The socket options that can be consulted with
Unix.getsockopt_optint
and modified with Unix.setsockopt_optint.
|
| socket_type [BatUnix] |
The type of socket kinds, specifying the semantics of
communications.
|
| stat [BatGc] |
The memory management counters are returned in a
stat record.
|
| state [BatParserCo] |
The current state of the parser.
|
| stats [BatUnix.LargeFile] | |
| stats [BatUnix] |
The information returned by the
Unix.stat calls.
|
| stats [BatOo.Internal] | |
T | |
| t [BatVect.RANDOMACCESS] | |
| t [BatVect.Make] |
The type of a polymorphic vect.
|
| t [BatVect] |
The type of a polymorphic vect.
|
| t [BatUref] |
A synonym for convenience
|
| t [BatUnit] |
The unit type, i.e.
|
| t [BatUTF8] |
UTF-8 encoded Unicode strings.
|
| t [BatUChar] | |
| t [BatTuple.Tuple5] | |
| t [BatTuple.Tuple4] | |
| t [BatTuple.Tuple3] | |
| t [BatTuple.Tuple2] | |
| t [BatText] |
The type of the rope.
|
| t [BatSubstring] | Substring.t is the type of substrings of a basestring, an efficient
representation of a piece of a string.
|
| t [BatString.Cap] |
The type of capability strings.
|
| t [BatString] |
An alias for the type of strings.
|
| t [BatStream] | |
| t [BatStack] |
The type of stacks containing elements of type
'a.
|
| t [BatSet.PSet] |
The type of sets.
|
| 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 [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.Incubator.Private_state_enums.State] |
same as BatRandom.State
|
| t [BatRandom.State] |
The type of PRNG states.
|
| t [BatRMutex] |
The type of mutexes.
|
| t [BatQueue] |
The type of queues containing elements of type
'a.
|
| t [BatPrintf] |
The format to use for displaying the various arguments passed to the function.
|
| t [BatPrintexc.Slot] | |
| 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 [BatOption] | |
| t [BatOptParse.OptParser] |
The type of an option parser.
|
| t [BatOptParse.Formatter] | |
| t [BatOptParse.Opt] |
Option type.
|
| t [BatOo.Internal] | |
| t [BatNumber.Numeric] | |
| t [BatNum] | |
| t [BatNativeint] |
An alias for the type of native integers.
|
| t [BatMultiPMap] | |
| t [BatMultiMap] | |
| t [BatMap.PMap] | |
| t [BatMap.S] |
The type of maps from type
key to type 'a.
|
| t [BatMap] | |
| t [BatLog.Level_sig] |
A type for level values, usually a polymorphic variant
|
| t [BatLog.Config] | |
| t [BatList] |
The type of lists
|
| 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.Output] | |
| t [BatInnerIO.Input] | |
| t [BatISet] |
the underlying representation is a balanced tree of ranges
|
| t [BatIMap] | |
| t [BatHeap.H] |
Type of the heap
|
| t [BatHeap] |
Heap of elements that are compared with
Pervasives.compare.
|
| 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 [BatHashcons.Table] |
type of the table
|
| t [BatHashcons] |
A synonym for convenience
|
| 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 [BatFingerTree] | |
| t [BatEnum] | |
| t [BatDynArray] | |
| t [BatDllist] | |
| t [BatDigest] |
The type of digests: 16-character strings.
|
| t [BatDeque] |
A synonym for convenience
|
| t [BatConcurrent.BaseLock] |
The type of a lock.
|
| t [BatConcurrent.Lock] |
The type of a lock.
|
| t [BatComplex] | |
| t [BatOrd.Eq] | |
| t [BatOrd.Ord] | |
| t [BatOrd.Comp] | |
| t [BatChar] |
An alias for the type of characters.
|
| t [BatBytes] |
An alias for the type of byte sequences.
|
| t [BatBuffer] |
The abstract type of buffers.
|
| t [BatBounded.BoundedType] |
The type that makes up the bounded range
|
| t [BatBounded.S] |
Private version of
BatBounded.S.u to avoid construction of BatBounded.S.t values without
using make below.
|
| t [BatBool] |
The type of booleans.
|
| t [BatBitSet] | |
| t [BatBigarray.Array3] |
The type of three-dimensional big arrays whose elements have
OCaml type
'a, representation kind 'b, and memory layout 'c.
|
| t [BatBigarray.Array2] |
The type of two-dimensional big arrays whose elements have
OCaml type
'a, representation kind 'b, and memory layout 'c.
|
| t [BatBigarray.Array1] |
The type of one-dimensional big arrays whose elements have
OCaml 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.Incubator.Ord] | |
| t [BatArray.Incubator.Eq] | |
| t [BatArray.Cap] |
The type of arrays with capabilities.
|
| t [BatArray] |
The type of arrays.
|
| table [BatOo.Internal] |
Internal representation of the vtable, i.e.
|
| tables [BatOo.Internal] | |
| tag [BatOo.Internal] | |
| tag [BatFormat] | |
| tchar [BatPathGen.StringType] |
Character type used by
t.
|
| terminal_io [BatUnix] | |
| tm [BatUnix] |
The type representing wallclock time and calendar date.
|
| token [BatGenlex] |
The type of tokens.
|
| tree [BatAvlTree] | |
U | |
| u [BatBounded.S] | BatBounded.S.base_u after bounding constraints have been applied
|
| uchar [BatUChar] |
Aliases of
type t
|
| uchar [BatPathGen.PathType] |
Type of characters.
|
| uref [BatUref] |
A
t uref is a reference to a cell that contains a
value of type t.
|
| 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).
|
W | |
| wait_flag [BatUnix] |
Flags for
Unix.waitpid.
|
| wrap [BatFingerTree.S] |
A type meant to avoid duplication of signatures.
|