A  | |
| Access_control [Hashtbl] | |
| Access_control [Array] | |
| Action [Deprecated_command.Flag] | 
Deprecated  This is the old deprecated interface to Flag
 
 | 
| Add [Fold_map] | 
A fold for adding.
 
 | 
| Alternating_primary_backup_assignment [Std] | |
| Alternating_primary_backup_assignment | 
role assignment for systems with a primary and backup instances that
    switch roles daily for ease of deploying new versions.
 
 | 
| Annotated_field [Deprecated_command] | 
This module is intended to help in using pa_fields to easily generate
   Command.t's when you have a record type each field of which you would
   like specified as a command line argument.
 
 | 
| Anons [Deprecated_fcommand] | |
| Array [Std] | |
| Atomic_edit [Std] | |
| Atomic_edit | 
Atomically edit a file without long-term locking
 
 | 
| Autocomplete [Deprecated_command] | |
B  | |
| Bash_action [Deprecated_command.Autocomplete] | |
| Bin_io_utils [Std] | |
| Bin_io_utils | |
| Bitarray [Std] | |
| Bitarray | 
This module implements efficient and compact arrays of boolean values.
 
 | 
| Bool [Packed_array] | 
These primitive packed arrays are represented by their respective Bigarray types.
 
 | 
C  | |
| Cache [Std] | |
| Cache | 
Generic caching library
 
 | 
| Cbuffer [Std] | |
| Cbuffer | 
Circular buffers.
 
 | 
| Char [Packed_array] | |
| Color_print [Std] | |
| Color_print | |
| Command_result [Process] | |
| Comprehension [Sexp] | |
| Cons [Fold_map] | |
| Cpu_use [Sys_utils] | 
A module for getting a process's CPU use.
 
 | 
| Crit_bit | |
| Csv_writer [Std] | |
| Csv_writer | 
* Compliant simple CSV writter.
 
 | 
D  | |
| Date [Std] | |
| Date_selector [Selector.Stable] | |
| Date_selector [Selector] | |
| Delta [Stats_reporting] | |
| Deprecated_bench [Std] | |
| Deprecated_bench | 
DEPRECATED: use the base/bench library instead
 
 | 
| Deprecated_command [Std] | |
| Deprecated_command | 
DEPRECATED: use Core.Std.Command instead
 
 | 
| Deprecated_fcommand [Std] | |
| Deprecated_fcommand | 
DEPRECATED: use Core.Std.Command instead
 
 | 
| Deprecated_service_command [Std] | |
| Deprecated_service_command | command ~lock_file ~name main creates a command group for starting,
    stopping, restarting, and checking the status of a daemon (the code
    for which lives in the argument main).
 | 
| Dev [Procfs.Net] | |
| Diff [Sexp] | 
Various
 
 | 
| Direct [Sys_utils.Lsb_release.Fields] | |
| Direct [Procfs.Mount.Fields] | |
| Direct [Procfs.Net.Tcp.Fields] | |
| Direct [Procfs.Net.Route.Fields] | |
| Direct [Procfs.Net.Dev.Fields] | |
| Direct [Procfs.Loadavg.Fields] | |
| Direct [Procfs.Kstat.Fields_of_cpu_t] | |
| Direct [Procfs.Meminfo.Fields] | |
| Direct [Procfs.Process.Fields] | |
| Direct [Procfs.Process.Fd.Fields] | |
| Direct [Procfs.Process.Status.Fields] | |
| Direct [Procfs.Process.Statm.Fields] | |
| Direct [Procfs.Process.Stat.Fields] | |
| Direct [Procfs.Process.Limits.Fields] | |
| Direct [Procfs.Process.Limits.Rlimit.Fields] | |
| Documented_match_statement [Std] | |
| Documented_match_statement | 
A  
t represents a match statement where every case is documented.
 | 
E  | |
| English [Std] | |
| English | 
Translating English into useful data structures
 
 | 
| Environment [Std] | |
| Environment | |
| Error [Result] | |
| Exception_check [Std] | |
| Exception_check | 
Code to test the effect of exceptions happening in strategic
    places in daemons.
 
 | 
| Exn [Std] | |
| Exn [Result] | |
| Exn_string [Exn] | 
The point of this module is to be able to include an exn in a type that has to be
    sexpable or binable.
 
 | 
| Array | 
Extensions to  
Core.Core_array.
 | 
| Extended_common | 
Pervasive functions.
 
 | 
| Date [Time] | |
| Exn | 
Extensions to  
Core.Exn.
 | 
| Filename | 
Extensions to  
Core.Core_filename.
 | 
| Float | 
Extensions to  
Core.Float.
 | 
| Gc | 
Extensions to  
Core.Gc.
 | 
| Hashtbl | |
| Int | |
| Int32 | 
Extensions to  
Core.Core_int32
 | 
| Int63 | 
Extensions to  
Core.Core_int63
 | 
| Int64 | 
Extensions to  
Core.Core_int64
 | 
| Extended_linux | 
Splicing - zero-copies between kernel buffers
 
 | 
| List | 
Extensions to  
Core.Core_list.
 | 
| Extended_list__LCS | |
| Extended_list__multimerge | |
| Memo | 
Extensio to  
Core.Memo
 | 
| Extended_monad | |
| Nativeint | |
| Extended_option | |
| Extended_passwd [Unix] | |
| Result | 
Extension to the 
 
 | 
| Sexp | 
Extensions to  
Sexplib.Sexp.
 | 
| Extended_span [Time] | |
| String | 
Extensions to  
Core.Core_String.
 | 
| Sys | 
Utility functions concerning the OCaml-runtime
 
 | 
| Thread | 
Extensions to  
Core.Core_thread
 | 
| Time | 
Shortcut for calling Core_extended.Unix.strftime without having to
     create a Time.t and convert it to a Unix.tm.
 
 | 
| Unix | 
Extensions to  
Core.Unix.
 | 
| Extra_fields [Std] | |
| Extra_fields | |
F  | |
| Fd [Procfs.Process] | |
| Fd_leak_check [Std] | |
| Fd_leak_check | 
File descriptor leak check.
 
 | 
| Fields [Sys_utils.Lsb_release] | |
| Fields [Procfs.Mount] | |
| Fields [Procfs.Net.Tcp] | |
| Fields [Procfs.Net.Route] | |
| Fields [Procfs.Net.Dev] | |
| Fields [Procfs.Loadavg] | |
| Fields [Procfs.Meminfo] | |
| Fields [Procfs.Process] | |
| Fields [Procfs.Process.Fd] | |
| Fields [Procfs.Process.Status] | |
| Fields [Procfs.Process.Statm] | |
| Fields [Procfs.Process.Stat] | |
| Fields [Procfs.Process.Limits] | |
| Fields [Procfs.Process.Limits.Rlimit] | |
| Fields_of_cpu_t [Procfs.Kstat] | |
| Filename [Std] | |
| Filesize [Int64] | 
An int reprensting a file length
 
 | 
| Find [Std] | |
| Find | 
Unix like  
find.
 | 
| Flag [Deprecated_fcommand] | |
| Flag [Deprecated_command] | |
| Flags_ext [Deprecated_command] | |
| Flang [Std] | |
| Float [Std] | |
| Float [Packed_array] | |
| Float32 [Packed_array] | |
| Fold_map [Std] | |
| Fold_map | 
A map that folds in new values.
 
 | 
| Fraction [Float] | |
| Fraction_unsafe [Float] | |
G  | |
| Gc [Std] | |
| Generic | |
H  | |
| Hashtbl [Std] | |
| Helpers [Deprecated_command] | |
| History [Readline] | 
A mutable variable representing the history.
 
 | 
| Hunk [Patience_diff] | 
In diff terms, a hunk is a unit of consecutive ranges with some  
Same
    context before and after New, Old, and Replace ranges.
 | 
I  | |
| Ignore [Loggers] | 
Ignores logging messages
 
 | 
| Immutable [Hashtbl.Access_control] | |
| Immutable [Array.Access_control] | |
| Inet_port [Unix] | 
Simple int wrapper to be explicit about ports.
 
 | 
| Infix [Pp] | |
| Inode [Procfs.Process] | |
| Int [Std] | |
| Int [Packed_array] | |
| Int16 [Packed_array] | |
| Int16_unsigned [Packed_array] | |
| Int32 [Std] | |
| Int32 [Packed_array] | |
| Int63 [Std] | |
| Int64 [Std] | |
| Int64 [Packed_array] | |
| Int8 [Packed_array] | |
| Int8_unsigned [Packed_array] | |
| Invariant | |
| Invocation [Std] | |
| Invocation | |
| Iter [Std] | |
| Iter | 
Astract iterators.
 
 | 
| Iterator [Lazy_sequence] | |
| Iterator [Lazy_list] | |
K  | |
| Keep_all [Cache.Strategy] | 
Keep all the values
 
 | 
| Keep_all [Cache] | 
Full caching (never flushes out values automatically )
 
 | 
| Key [Trie.S] | |
| Kstat [Procfs] | |
L  | |
| Lazy_list [Std] | |
| Lazy_list | 
Lazy lists.
 
 | 
| Lazy_m [Std] | |
| Lazy_m | 
A non-threadsafe reimplementation of  
Lazy
 | 
| Lazy_sequence [Std] | |
| Lazy_sequence | |
| Limits [Procfs.Process] | |
| Linebuf [Std] | |
| Linebuf | 
Line-by-line reading of a file.
 
 | 
| Linux_ext [Std] | |
| List [Std] | |
| List [Extended_monad] | |
| List_zipper [Std] | |
| List_zipper | |
| Loadavg [Procfs] | |
| Logger [Std] | |
| Logger | 
Another logging library.
 
 | 
| Loggers [Std] | |
| Loggers | 
High-level logging capabilities
 
 | 
| Low_level_debug [Std] | |
| Low_level_debug | 
A canary thread starts two threads, one in caml and one in C.
 
 | 
| Lru [Cache.Strategy] | 
Least recently used.
 
 | 
| Lru [Cache] | 
Least recently used caching
 
 | 
| Lsb_release [Sys_utils] | |
M  | |
| Mac_address [Unix] | |
| Make [Trie] | |
| Make [Splay_tree] | |
| Make [Packed_map] | |
| Make [Packed_array] | |
| Make [Lazy_list.Of_container] | |
| Make [Fold_map] | 
Builds a  
fold_map
 | 
| Make [Extra_fields] | |
| Make [Extended_monad] | |
| Make [Cache] | |
| Make2 [Fold_map] | |
| Make2 [Extended_monad] | |
| Make2_sexpable [Fold_map] | |
| MakeChannel [Loggers] | 
Functor for creating channel loggers
 
 | 
| MakeLogger [Loggers] | 
Functor for creating loggers
 
 | 
| Make_bounded [Number.Verified_std] | 
Functor of creating bounded numbers
 
 | 
| Make_bounded_unsafe [Number.Verified_std] | |
| Make_explicit_sexp_option [Sexp] | |
| Make_sexpable [Fold_map] | |
| Make_verified [Number] | 
Functor for making constrained numbers from specifications.
 
 | 
| Make_verified_std [Number] | 
Functor for enriching standard numbers ( 
Int.t, Int32.t, Int63.t
    Int64.t, Nativeint.t, Float.t) with Pos.t, Pos0.t, Neg.t,
    and Neg0.t modules, and the Make_bounded and Make_bounded_unsafe
    functors.
 | 
| Make_verified_unsafe [Number] | 
Same as  
Number.Make_verified, but does not enforce invariants.
 | 
| Malloc | 
Malloc bindings
 
 | 
| Matching_block [Patience_diff] | 
Bram Cohen's comment from the original Python code (with syntax changed to OCaml):
 
 | 
| Meminfo [Procfs] | |
| Memo [Std] | |
| Mount [Procfs] | |
| Mount_entry [Unix] | |
| Multi_map [Std] | |
| Multi_map | 
Maps with mutliple bindings.
 
 | 
| Multiply [Fold_map] | |
N  | |
| Nativeint [Std] | |
| Neg [Number.Verified_std] | |
| Neg0 [Number.Verified_std] | |
| Neg0_unsafe [Number.Verified_std] | |
| Neg_unsafe [Number.Verified_std] | |
| Net [Procfs] | |
| Net_utils [Std] | |
| Net_utils | 
Networking utilities
 
 | 
| Number [Std] | |
| Number | 
Specification of general number properties
 
 | 
O  | |
| Of_binable [Packed_array] | 
The representation of a packed array type created using  
Of_binable is a Bin_prot
    buffer and a packed array of indices pointing to the beginning of each serialized
    element in the buffer.
 | 
| Of_container [Lazy_list] | |
| Of_packed_array [Packed_array] | Of_packed_array(P) creates a packed array of packed arrays.
 | 
| Ok [Result] | |
| Olang [Std] | |
| Options [Find] | |
P  | |
| Packed_array [Std] | |
| Packed_array [Packed_map.Value] | |
| Packed_array [Packed_map.Key] | |
| Packed_array | 
A packed array is a read-only array that has a fairly compact representation and will
    not be traversed by the GC.
 
 | 
| Packed_map [Std] | |
| Packed_map | 
A packed map is a map from keys to values, represented using a packed array of
    key-value tuples which is sorted by key.
 
 | 
| Part [Trie.Key] | |
| Part [Trie.S] | |
| Patience_diff | 
This is a port of Bram Cohen's patience diff algorithm, as found in the Bazaar 1.14.1
    source code, available at http://bazaar-vcs.org.
 
 | 
| Pos [Number.Verified_std] | 
Positive and negative numbers with and without zero.
 
 | 
| Pos0 [Number.Verified_std] | |
| Pos0_unsafe [Number.Verified_std] | |
| Pos_unsafe [Number.Verified_std] | |
| Posix_clock [Std] | |
| Posix_clock | |
| Pp [Std] | |
| Pp | 
Functional pretty printing.
 
 | 
| Printc [Std] | |
| Printc | 
alias for String.concat
 
 | 
| Process [Std] | |
| Process [Shell] | 
Process dispatching
 
 | 
| Process [Procfs] | |
| Process | 
Low-level process handling
 
 | 
| Procfs [Std] | |
| Procfs | 
Process and system stats
 
 | 
| Prod_or_test [Std] | |
| Prod_or_test | |
Q  | |
| Quota [Unix] | |
R  | |
| Random_selection [Std] | |
| Random_selection | 
reservoir sampling
 
 | 
| Range [Patience_diff] | 
For handling diffs abstractly.
 
 | 
| Read_only [Hashtbl.Access_control] | |
| Read_only [Array.Access_control] | |
| Read_write [Hashtbl.Access_control] | |
| Read_write [Array.Access_control] | |
| Readline [Std] | |
| Readline | 
Interactive line editing.
 
 | 
| Readline__input_char | |
| Readline__input_loop | |
| Records_table [Sexp] | |
| Regexp [Selector.Stable.String_selector] | |
| Regexp [Selector.String_selector] | |
| Result [Std] | |
| Result [Deprecated_bench] | |
| Rlimit [Procfs.Process.Limits] | |
| Route [Procfs.Net] | |
| Runtime_blockout_detector [Std] | |
| Runtime_blockout_detector | Runtime_blockout_detector is used detect bugs in C libraries that fail
    to release the OCaml runtime lock before making blocking calls.
 | 
| Rw_mutex [Std] | |
| Rw_mutex | 
Read/write mutexes
 
 | 
S  | |
| Sampler [Std] | |
| Sampler | 
a compiled finite discrete probability distribution that supports constant
    time sampling
 
 | 
| Search [Std] | |
| Search_foo | |
| Selector | |
| Semaphore [Std] | |
| Semaphore | 
Semaphores
 
 | 
| Sendmail [Std] | |
| Sendmail | |
| Service_command [Std] | |
| Service_command | acquire_lock_exn slot locks slot.
 | 
| Sexp [Std] | |
| Sexp_checked_edit [Sys_utils] | 
Edit files containing sexps.
 
 | 
| Shared_flags [Deprecated_command] | |
| Shell [Std] | |
| Shell | 
Shell scripting in OCaml.
 
 | 
| Shell__core | |
| Shell__line_buffer | 
String buffers that automatically get flushed at every line return.
 
 | 
| Sntp [Std] | |
| Sntp | 
Simple Network Time Protocol
 
 | 
| Splay_tree [Std] | |
| Splay_tree | |
| Splice [Extended_linux] | |
| Stable [Selector] | |
| Stat [Procfs.Process] | |
| Stat [Deprecated_bench.Result] | |
| Statfs [Extended_linux] | |
| Statm [Procfs.Process] | |
| Stats_reporting [Std] | |
| Stats_reporting | |
| Status [Procfs.Process] | |
| Status [Process] | |
| Std | |
| Stderr [Loggers] | 
Logs to  
stderr
 | 
| Store [Cache] | 
Predefined stores
 
 | 
| Stored_data [Stats_reporting] | |
| Strategy [Cache] | 
Predefined strategies
 
 | 
| String [Std] | |
| String [Packed_array] | |
| String_list_selector [Selector.Stable] | |
| String_list_selector [Selector] | |
| String_selector [Selector.Stable] | |
| String_selector [Selector] | |
| String_trie [Trie] | |
| String_zipper | |
| String_zipper [Std] | |
| Sys [Std] | |
| Sys_utils | 
Various system utility functions.
 
 | 
| Sys_utils [Std] | |
| Syslog | 
Syslog Interface
 
 | 
| Syslog [Std] | |
| Syslog [Loggers] | 
Logs to syslog daemon
 
 | 
T  | |
| Table [Cache.Store] | |
| Tcp | with_conn opens a connection to the TCP service on host port and
  if successful calls f with In_channel.t and Out_channel.t as arguments.
 | 
| Tcp [Std] | |
| Tcp [Procfs.Net] | 
/proc/net/tcp, or what netstat or lsof -i parses.
 
 | 
| Tcp_state [Procfs.Net] | |
| Test [Deprecated_bench] | |
| Text_block | 
two dimensional blocks of text
 
 | 
| Text_block [Std] | |
| Thread [Std] | |
| Time [Std] | |
| Time_stamp_counter [Posix_clock] | |
| Timed_function | 
Functions with timeouts
 
 | 
| Timed_function [Std] | |
| Trie | |
| Trie [Std] | |
| Tuple2 [Packed_array] | 
the representation of a packed array of tuples is a tuple of packed arrays.
 
 | 
U  | |
| Unix [Std] | |
| Unix_utils | 
Interface to Unix utility functions
 
 | 
| Unix_utils [Std] | |
| Update_queue | 
A  
'state t keeps track of updates of type 'state -> 'state queued to it and runs
    them sequentially.
 | 
| Update_queue [Std] | |
V  | |
| V1 [Selector.Stable.String_list_selector] | |
| V1 [Selector.Stable.String_selector] | |
| V1 [Selector.Stable.String_selector.Regexp] | |
| V1 [Selector.Stable.Date_selector] | |
| Version [Deprecated_command] |