A  | |
| Alarm [Timing_wheel_intf.S] | |
| Arg_type [Command.Spec] | |
| Array_permute | |
| Avltree | |
B  | |
| Backtrace [Std] | |
| Backtrace | 
Dealing with stack backtraces.
 
 | 
| Bag | |
| Bigbuffer [Std] | |
| Bigbuffer | add_channel b ic n reads exactly n character from the
   input channel ic and stores them at the end of buffer b.
 | 
| Bigbuffer_internal | |
| Bigstring [Std] | |
| Bigstring | 
String type based on  
Bigarray, for use in I/O and C-bindings
 | 
| Bigstring_marshal [Std] | |
| Bigstring_marshal | 
Utility functions for marshalling to and from bigstring
 
 | 
| Bigsubstring | |
| Binable | |
| Binable0 | |
| Binary_packing | |
| Blang | |
| Bool | |
| Bounded_int_table | |
| Bucket | |
| Byte_units | |
C  | |
| C [Time0.Stable.V1] | |
| Calibrator [Time_stamp_counter] | 
A calibrator contains a snapshot of machine-specific information that is used to
    convert between TSC values and clock time.
 
 | 
| Caml [Std] | |
| Caml | |
| Check_std | |
| Cidr [Unix] | 
A representation of CIDR netmasks (e.g.
 
 | 
| Clock [Linux_ext.Timerfd] | 
Clock used to mark the progress of a timer.
 
 | 
| Clock [Linux_ext] | |
| Command [Std] | |
| Command | 
purely functional command line parsing
 
 | 
| Common | |
| Commutative_group | |
| Comparable | |
| Comparable_intf | |
| Comparator | |
| Condition [Std] | |
| Condition [Caml] | |
| Config [Timing_wheel_intf.S] | |
| Constrained_float | |
| Consume [Iobuf.Unsafe] | |
| Consume [Iobuf] | Consume.string t ~len reads len characters (all, by default) from t into a new
    string and advances the lower bound of the window accordingly.
 | 
| Container | |
| Core_arg | |
| Core_array | |
| Core_bin_prot | |
| Core_char | |
| Condition | timedwait cond mtx timeout waits on condition variable cond
    with mutex mtx until either the condition is signalled, or until
    timeout expires.
 | 
| Core_field | |
| Filename | 
Warning! this library assumes we are in a POSIX compliant OS.
 
 | 
| Gc | Core_kernel.Gc, plus finalizers.
 | 
| Core_hashtbl | |
| Core_hashtbl_intf | |
| Core_int | |
| Core_int32 | |
| Core_int63 | |
| Core_int64 | |
| Core_lazy | |
| Core_list | |
| Core_map | |
| Core_map_intf | |
| Core_map_unit_tests | |
| Mutex | lock mtx locks mtx, possibly waiting for it to be released
    first by another thread.
 | 
| Core_nativeint | |
| Core_printexc | |
| Core_printf | |
| Core_queue | |
| Core_random | |
| Core_set | |
| Core_set_intf | |
| Core_set_unit_tests | |
| Core_sexp | |
| Core_stack | |
| Core_string | |
| Sys | 
System interface.
 
 | 
| Thread | 
Lightweight threads.
 
 | 
| Unix | 
File descriptor.
 
 | 
| Core_weak | |
| Crc [Std] | |
| Crc | 
Crc functions
 
 | 
D  | |
| Daemon [Std] | |
| Daemon | 
This module provides support for daemonizing a process.
 
 | 
| Date [Time0] | |
| Date [Std] | |
| Date [Stable] | |
| Date | 
This formats a date using the format patterns available in  
strftime
 | 
| Date0 | 
converts a string to a date, in formats:
 * m/d/y
 * y-m-d (* valid iso8601_extended *)
  * DD MMM YYYY
  * DDMMMYYYY
  * YYYYMMDD
 
 | 
| Day_of_week | |
| Debug [Timing_wheel_intf.Timing_wheel] | |
| Deprecated [Command] | Deprecated should be used only by Core_extended.Deprecated_command.
 | 
| Dequeue | |
| Direct [Unix.Resource_usage.Fields] | |
| Doubly_linked | |
E  | |
| Elt [Timing_wheel_intf.S.Priority_queue] | |
| Epoch_cache [Time0.Stable.V1] | |
| Epoll [Linux_ext] | 
epoll() - a linux I/O multiplexer of the same family as select() or poll().
 
 | 
| Equal | |
| Error | |
| Error [Unix] | |
| Exit [Unix] | 
The termination status of a process.
 
 | 
| Exit_or_signal [Unix] | |
| Exit_or_signal_or_stop [Unix] | |
| Exn | |
| Exn [Backtrace] | Backtrace.Exn has functions for controlling and printing the backtrace of the most
    recently raised exception.
 | 
| Expert [Signal] | 
The  
Expert module contains functions that novice users should avoid, due to their
    complexity.
 | 
| Expert [Gc] | 
The  
Expert module contains functions that novice users should not use due to their
    complexity.
 | 
| Export [Date0] | |
F  | |
| Fd_redirection [Daemon] | |
| Fields [Unix.Resource_usage] | |
| File_descr [Unix] | 
File descriptor.
 
 | 
| Filename [Std] | |
| Fill [Iobuf.Unsafe] | |
| Fill [Iobuf] | Peek and Poke functions access a value at pos from the lower bound of the window
    and do not advance.
 | 
| Flags [Linux_ext.Epoll] | |
| Flags [Linux_ext.Timerfd] | |
| Flags | |
| Flags_intf | |
| Float [Piecewise_linear] | |
| Float [Interval.Stable.V1] | |
| Float [Interval] | |
| Float | |
| Float_intf | |
| Float_robust_compare | |
| Floatable | |
| Flock_command [Unix] | |
| Fn | |
| Force_once | |
| Fqueue | |
G  | |
| Gc [Std] | |
| Group [Unix] | 
Structure of entries in the  
groups database.
 | 
H  | |
| Hash_heap | |
| Hash_queue | |
| Hash_set | |
| Hash_set_intf | |
| Hashable | |
| Heap | |
| Heap_block | |
| Helpers [Time_internal] | |
| Hi_bound [Iobuf] | |
| Host [Unix] | |
| Host_and_port | |
I  | |
| IOVec [Unix] | 
I/O-vectors for scatter/gather-operations
 
 | 
| Identifiable | |
| In_channel | |
| Inet_addr [Unix] | |
| Info | |
| Int [Piecewise_linear] | |
| Int [Interval.Stable.V1] | |
| Int [Interval] | |
| Int_conversions | |
| Int_intf | |
| Int_math | |
| Int_replace_polymorphic_compare | |
| Int_set | |
| Intable | |
| Interfaces | |
| Interned_string | |
| Interval [Std] | |
| Interval [Stable] | |
| Interval | 
Module for simple closed intervals over arbitrary types that are ordered
    correctly using polymorphic compare.
 
 | 
| Interval_intf | 
Module for simple closed intervals over arbitrary types that are ordered correctly
      using polymorphic compare.
 
 | 
| Invariant | |
| Iobuf [Std] | |
| Iobuf | 
A non-moving (in the gc sense) contiguous range of bytes, useful for I/O operations.
 
 | 
| Iobuf_debug | |
| Iobuf_intf | no_seek and seek are defined and used in a similar manner to read_only and
    read_write.
 | 
| Iobuf_tests | 
Intentionally empty.
 
 | 
L  | |
| Level_bits [Timing_wheel_intf.S] | |
| Linux_ext [Std] | |
| Linux_ext | 
Interface to Linux-specific system calls
 
 | 
| Lo_bound [Iobuf] | |
| Lock_file [Std] | |
| Lock_file | 
Mutual exclusion between processes using flock and lockf.
 
 | 
| Low_level [Unix.Passwd] | |
M  | |
| Make [Piecewise_linear] | |
| Make [Iobuf_debug] | |
| Make [Interval] | |
| Make_invertible [Piecewise_linear] | |
| Make_substring | |
| Map [Time0.Stable.V1] | |
| Mcl_flags [Unix.Mman] | |
| Memo | |
| Mman [Unix] | |
| Monad | |
| Month | |
| Mutex [Std] | |
| Mutex [Caml] | |
| Mutex0 | create like Mutex.create, but creates an error-checking mutex.
 | 
N  | |
| Nano_mutex [Std] | |
| Nano_mutex | 
A nano-mutex is a lightweight mutex that can be used only within a single OCaml
    runtime.
 
 | 
| Native_file [Unix] | |
| Never_returns | |
| Nfs [Lock_file] | 
An implementation neutral NFS lock file scheme that relies on the atomicity of link
    over NFS (see NFS Illustrated, atomicity for more information).
 
 | 
| No_polymorphic_compare | |
| Nothing | |
| Nothing0 | |
O  | |
| Ofday [Time] | |
| Ofday [Stable] | |
| Ofday [Piecewise_linear] | |
| Ofday | 
A time of day along with a time zone.
 
 | 
| Ofday [Interval.Stable.V1] | |
| Ofday [Interval] | |
| Only_in_test | |
| Open_flags [Unix] | |
| Option | |
| Or_error | |
| Ordered_collection_common | |
| Ordering | |
| Out_channel | |
P  | |
| Parts [Time.Span] | |
| Parts [Span] | |
| Passwd [Unix] | 
Structure of entries in the  
passwd database
 | 
| Peek [Iobuf.Unsafe] | |
| Peek [Iobuf] | |
| Pid | |
| Piecewise_linear [Std] | |
| Piecewise_linear | 
Piece-wise linear interpolation from float-like types to float.
 
 | 
| Piecewise_linear_intf | create enforces that x (key) values are non-decreasing.
 | 
| Poke [Iobuf.Unsafe] | |
| Poke [Iobuf] | |
| Policy [Unix.Scheduler] | |
| Polymorphic_compare | |
| Polymorphic_compare_intf | |
| Pretty_printer | |
| Priority [Linux_ext] | |
| Priority [Unix] | |
| Priority_queue [Timing_wheel_intf.S] | 
Timing wheel is implemented as a priority queue in which the keys are
      non-negative integers corresponding to the intervals of time.
 
 | 
| Process_channels [Unix] | 
Similar to  
UnixLabels.open_process, but the second argument specifies
   the environment passed to the command.
 | 
| Process_env [Std] | |
| Process_env | 
Utility functions for dealing with the environment.
 
 | 
| Process_info [Unix] | |
| Protocol [Unix] | |
| Protocol_family [Unix] | |
Q  | |
| Quickcheck | |
R  | |
| RLimit [Unix] | 
Resource limits
 
 | 
| Ref | |
| Resource_usage [Unix] | 
Resource usage -- For details, "man getrusage"
 
 | 
| Result | |
| Robustly_comparable | |
S  | |
| Scheduler [Unix] | |
| Select_fds [Unix] | 
Wait until some input/output operations become possible on
   some channels.
 
 | 
| Service [Unix] | |
| Set [Time0.Stable.V1] | |
| Set [Interval_intf.S] | |
| Set [Interval_intf.S1] | |
| Set_once | |
| Sexpable | |
| Signal [Std] | |
| Signal | of_system_int and to_system_int return and take respectively a signal number
    corresponding to those in the system's /usr/include/bits/signum.h (or equivalent).
 | 
| Source_code_position | |
| Source_code_position0 | |
| Span [Time_stamp_counter] | Span indicates some integer number of cycles.
 | 
| Span [Time] | |
| Span [Stable] | |
| Span | 
Basic operations on spans
 
 | 
| Span [Piecewise_linear] | |
| Spec [Command.Deprecated] | |
| Spec [Command] | 
composable command-line specifications
 
 | 
| Squeue [Std] | |
| Squeue | 
Thread-safe queue module, using locks.
 
 | 
| Stable [Zone] | |
| Stable [Time0] | |
| Stable [User_and_group] | |
| Stable [Time] | |
| Stable | |
| Stable [Span] | |
| Stable [Ofday] | |
| Stable [Ofday.Zoned] | |
| Stable [Interval] | |
| Stable [Date0] | |
| Stable_containers | |
| Stable_internal | |
| Stable_unit_test | |
| Stable_unit_test_intf | |
| Staged | |
| Std | |
| Std_common | |
| Std_internal | |
| Std_kernel | |
| String_id | |
| Stringable | |
| Substring | |
| Substring_intf | |
| Sys [Std] | |
| Sysinfo [Linux_ext] | |
T  | |
| T [Time_internal] | |
| T | |
| Terminal_io [Unix] | |
| Thread [Std] | |
| Thread [Caml] | |
| Thread_safe_queue | |
| Time | 
A module for representing absolute points in time, independent of time zone.
 
 | 
| Time [Std] | |
| Time [Stable] | |
| Time [Piecewise_linear] | |
| Time [Interval.Stable.V1] | |
| Time [Interval] | |
| Time0 | 
Pause and don't allow events to interrupt.
 
 | 
| Time_internal | |
| Time_stamp_counter | 
High-performance timing.
 
 | 
| Time_stamp_counter [Std] | |
| Timerfd [Linux_ext] | |
| Timing_wheel | |
| Timing_wheel [Std] | |
| Timing_wheel_intf | 
A specialized priority queue for a set of time-based alarms.
 
 | 
| Timing_wheel_unit_tests | 
This interface is only here to remind us to add a unit test whenever the interface of
     
Timing_wheel changes.
 | 
| Tuple | |
| Type_equal | |
U  | |
| Union_find | |
| Unique_id | |
| Unique_id_intf | |
| Unit | |
| Univ | |
| Univ_map | |
| Unix [Time0] | |
| Unix [Std] | |
| Unix [Iobuf_intf] | |
| Unix [Caml] | |
| UnixLabels [Caml] | |
| Unpack_buffer | |
| Unsafe [Iobuf] | Unsafe has submodules that are like their corresponding module, except with no range
    checks.
 | 
| User_and_group | 
A pair of unix username and primary unix group.
 
 | 
| User_and_group [Std] | |
| User_and_group [Stable] | |
| Utsname [Unix] | |
| Uuid | 
Implements universally unique identifiers based on version 3 of the UUID
    specification.
 
 | 
| Uuid [Std] | |
V  | |
| V1 [Time0.Stable] | |
| V1 [Zone.Stable] | |
| V1 [User_and_group.Stable] | |
| V1 [Time.Stable] | |
| V1 [Span.Stable] | |
| V1 [Ofday.Stable] | |
| V1 [Ofday.Zoned.Stable] | |
| V1 [Interval.Stable] | |
| V1 [Date0.Stable] | |
| Validate | |
W  | |
| With_return | |
| Word_size | |
Z  | |
| Zone | 
Time-zone handling.
 
 | 
| Zone [Time] | |
| Zone [Stable] | |
| Zoned [Time.Ofday] | |
| Zoned [Ofday] |