A | |
| access_permission [BatUnix] | Flags for the |
| addr_info [BatUnix] | Address information returned by |
| alarm [BatGc] | An alarm is a piece of data that calls a user function at the end of each major GC cycle. |
| allocation [BatGc.Memprof] | The type of metadata associated with allocations. |
| auto_cache [BatCache] | Automatically managed caches |
B | |
| backend_type [BatSys] | Currently, the official distribution only supports |
| backtrace_slot [BatPrintexc] | The abstract type |
| 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] |
|
| bounded [BatNumber.Bounded] | |
| bounding_f [BatBounded] | The type of a bounding function with limits specified by |
| buf [BatUTF8.Buf] | Buffers for UTF-8 strings. |
| bytes [Batteries] | |
C | |
| c_layout [BatBigarray] | See |
| cell [BatConcreteQueue] | |
| choice [BatOrd] | choice functions, see |
| 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 |
| control [BatGc] | The GC parameters are given as a |
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 |
| 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 |
| extern_flags [BatMarshal] | The flags to the |
F | |
| f_printer [BatIO] | |
| fg [BatFingerTree.S] | The type of finger trees containing elements of type |
| 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] | |
| 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 | |
| getaddrinfo_option [BatUnix] | Options to |
| getnameinfo_option [BatUnix] | Options to |
| group [BatOptParse.OptParser] | The type of an option group. |
| group_entry [BatUnix] | Structure of entries in the |
H | |
| hobj [BatHashcons] | The type |
| host_entry [BatUnix] | Structure of entries in the |
I | |
| 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. |
| 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 [BatInnerWeaktbl.S] | |
| key [BatIMap] | |
| key [BatHashtbl.S] | |
| key [BatHashcons.Table] | type of objects in the table |
| kind [BatBigarray] | To each element kind is associated an OCaml type, which is the type of OCaml values that can be stored in the big array or read back from it. |
L | |
| layout [BatBigarray] | The type |
| 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 |
| 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 |
| m [BatEnum.Monad] | The type of the BatEnum monad's elements, thus |
| m [BatEnum.WithMonad] | Type of the monadic elements. |
| manual_cache [BatCache] | |
| mappable [BatInterfaces.Mappable] | The data structure, e.g. |
| monoid [BatFingerTree] | The type of the element of a monoid. |
| msg_flag [BatUnix] | |
N | |
| name_info [BatUnix] | Host and service information returned by |
| 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 | |
| open_flag [BatUnix] | |
| open_in_flag [BatFile] | |
| open_out_flag [BatFile] | Flags governing file output; they correspond to the relevant
flags to the POSIX |
| open_temporary_out_flag [BatFile] | |
| ord [BatOrd] | The type of ordering functions returning an |
| order [BatOrd] | |
| out_bits [BatIO] | |
| output [BatInnerIO] | |
| output [BatIO] | The abstract output type, |
P | |
| passwd_entry [BatUnix] | Structure of entries in the |
| permission [BatFile] | The list of operations which are permitted on a file. |
| position [BatLexing] | A value of type |
| position [BatCharParser] | The position inside one file or one stream. |
| printer [BatIO] | The type of a printing function to print a |
| 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 |
R | |
| raw_backtrace [BatPrintexc] | The abstract type |
| 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: |
| seek_command [BatUnix] | Positioning modes for |
| service_entry [BatUnix] | Structure of entries in the |
| setattr_when [BatUnix] | |
| shutdown_command [BatUnix] | The type of commands for |
| signal_behavior [BatSys] | |
| sigprocmask_command [BatUnix] | |
| sockaddr [BatUnix] | |
| socket_bool_option [BatUnix] | The socket options that can be consulted with |
| socket_domain [BatUnix] | The type of socket domains. |
| socket_float_option [BatUnix] | The socket options that can be consulted with |
| socket_int_option [BatUnix] | The socket options that can be consulted with |
| socket_optint_option [BatUnix] | The socket options that can be consulted with |
| socket_type [BatUnix] | The type of socket kinds, specifying the semantics of communications. |
| stat [BatGc] | The memory management counters are returned in a |
| state [BatParserCo] | The current state of the parser. |
| stats [BatUnix.LargeFile] | |
| stats [BatUnix] | The information returned by the |
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] |
|
| 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 |
| 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 |
| 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 |
| t [BatPrintf] | The format to use for displaying the various arguments passed to the function. |
| t [BatPrintexc.Slot] | |
| t [BatPrintexc] | The type of exception values. |
| t [BatPathGen.StringType] | Type for strings. |
| t [BatPathGen.PathType] | A type for storing paths. |
| t [BatParserCo.Source] | A source of elements of type |
| t [BatParserCo] | A parser for elements of type |
| t [BatOption] | |
| t [BatOptParse.OptParser] | The type of an option parser. |
| t [BatOptParse.Formatter] | |
| t [BatOptParse.Opt] | Option type. |
| 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 |
| t [BatMap] | |
| t [BatLog.Level_sig] | A type for level values, usually a polymorphic variant |
| t [BatLog.Config] | |
| t [BatList] | |
| 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.HashedType] | |
| t [BatInnerWeaktbl.S] | |
| t [BatInnerWeaktbl] | The type of hash tables from type |
| 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 |
| t [BatHashtbl.HashedType] | The type of the hashtable keys. |
| t [BatHashtbl.Cap] | The type of a hashtable. |
| t [BatHashtbl.S] | |
| t [BatHashtbl] | A Hashtable with 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 [BatEither] | |
| 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 [BatConcreteQueue] | |
| 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 |
| t [BatBool] | The type of booleans. |
| t [BatBitSet] | |
| t [BatBigarray.Array3] | The type of three-dimensional big arrays whose elements have
OCaml type |
| t [BatBigarray.Array2] | The type of two-dimensional big arrays whose elements have
OCaml type |
| t [BatBigarray.Array1] | The type of one-dimensional big arrays whose elements have
OCaml type |
| t [BatBigarray.Array0] | The type of zero-dimensional big arrays whose elements have
OCaml type |
| t [BatBigarray.Genarray] | The type |
| 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. |
| tag [BatFormat] | |
| tchar [BatPathGen.StringType] | Character type used by |
| terminal_io [BatUnix] | |
| tm [BatUnix] | The type representing wallclock time and calendar date. |
| token [BatGenlex] | The type of tokens. |
| tracker [BatGc.Memprof] | A |
| tree [BatAvlTree] | |
U | |
| u [BatBounded.S] |
|
| uchar [BatUChar] | Aliases of |
| uchar [BatPathGen.PathType] | Type of characters. |
| uref [BatUref] | A |
| 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 |
| wrap [BatFingerTree.S] | A type meant to avoid duplication of signatures. |