| 
| ($) [Pp.Infix] | 
 | 
| ($) [Pp] | 
The infix operator x $ y concatenates two documents x and y into a
larger one.
 
 | 
| ($/) [Pp.Infix] | 
 | 
| ($/) [Pp] | 
Instead of writing x $ break $ y to insert a break it is convenient to
define an operator for this: x ^/ y joins x and y with a break.
 
 | 
| ($//) [Pp.Infix] | 
 | 
| ($//) [Pp] | 
Joins two documents with a break_null.
 
 | 
| (%:) [Deprecated_fcommand] | 
 | 
| (++) [Deprecated_fcommand] | 
spec1 ++ spec2 composes command-line specifications spec1 and
    spec2.
 
 | 
| (==>) [Lazy_sequence] | 
 | 
| (==>>) [Lazy_sequence] | 
 | 
| (>:) [Generic] | 
 | 
| (>>|) [Generic] | 
 | 
| (~%) [Printc] | 
alias for sprintf
 
 | 
| (~:) [Printc] | 
alias for String.concat
 
 | 
| __ [Generic] | 
 | 
| __bin_read_any__ [Array.Access_control] | 
 | 
| __bin_read_color__ [Color_print] | 
 | 
| __bin_read_elt__ [Packed_array.Basic] | 
 | 
| __bin_read_field__ [Stats_reporting] | 
 | 
| __bin_read_flag__ [Extended_linux.Splice] | 
 | 
| __bin_read_key__ [Packed_map.S] | 
 | 
| __bin_read_mallinfo__ [Malloc] | 
 | 
| __bin_read_name__ [Stats_reporting.Stored_data] | 
 | 
| __bin_read_opt__ [Malloc] | 
 | 
| __bin_read_statvfs__ [Unix] | 
 | 
| __bin_read_t__ [Stats_reporting.Stored_data] | 
 | 
| __bin_read_t__ [Selector.Stable.String_list_selector.V1] | 
 | 
| __bin_read_t__ [Selector.Stable.String_selector.V1] | 
 | 
| __bin_read_t__ [Selector.Stable.String_selector.Regexp.V1] | 
 | 
| __bin_read_t__ [Selector.Stable.Date_selector.V1] | 
 | 
| __bin_read_t__ [Selector.String_list_selector] | 
 | 
| __bin_read_t__ [Selector.String_selector.Regexp] | 
 | 
| __bin_read_t__ [Selector.String_selector] | 
 | 
| __bin_read_t__ [Selector.Date_selector] | 
 | 
| __bin_read_t__ [Prod_or_test] | 
 | 
| __bin_read_t__ [Packed_map.Value] | 
 | 
| __bin_read_t__ [Packed_map.Key] | 
 | 
| __bin_read_t__ [Packed_map.S] | 
 | 
| __bin_read_t__ [Unix.Mac_address] | 
 | 
| __bin_read_t__ [Int64.Filesize] | 
 | 
| __bin_read_type_desc__ [Stats_reporting.Stored_data] | 
 | 
| __bin_read_uids__ [Extended_linux] | 
 | 
| __bin_read_value__ [Packed_map.S] | 
 | 
| __color_of_sexp__ [Color_print] | 
 | 
| __t_of_sexp__ [Prod_or_test] | 
 | 
| __value_of_sexp__ [Procfs.Process.Limits.Rlimit] | 
 | 
 A | 
| acquire_lock_exn [Service_command] | 
acquire_lock_exn slot locks slot.
 
 | 
| active [Procfs.Meminfo.Fields] | 
 | 
| active [Procfs.Meminfo] | 
 | 
| add [Trie.S] | 
 | 
| add [Multi_map] | 
 | 
| add [Fold_map.S2] | 
 | 
| add [Fold_map.S] | 
add m ~key ~data adds the key to the value already bound to key in m.
 
 | 
| add [Hashtbl.Access_control] | 
 | 
| add [Environment] | 
 | 
| add [Crit_bit] | 
 | 
| add [Cbuffer] | 
 | 
| add [Cache.S] | 
 | 
| add [Cache.Keep_all] | 
 | 
| add [Cache.Lru] | 
 | 
| add_char [Shell__line_buffer] | 
 | 
| add_datum [Stats_reporting] | 
 | 
| add_datum_float [Stats_reporting] | 
 | 
| add_delta [Stats_reporting.Delta] | 
 | 
| add_delta_and_set [Stats_reporting.Delta] | 
 | 
| add_delta_and_set_float [Stats_reporting.Delta] | 
 | 
| add_delta_float [Stats_reporting.Delta] | 
 | 
| add_exn [Hashtbl.Access_control] | 
 | 
| add_multi [Hashtbl.Access_control] | 
 | 
| add_string [Shell__line_buffer] | 
 | 
| add_substring [Shell__line_buffer] | 
add_substring b s ofs len takes len characters from offset ofs in
   string s and appends them at the end of the buffer b.
 
 | 
| address_space [Procfs.Process.Limits.Fields] | 
 | 
| address_space [Procfs.Process.Limits] | 
 | 
| adjust_if_required [Stats_reporting] | 
 | 
| age [Sys_utils.Cpu_use] | 
 | 
| agrp [Pp] | 
The automatic group agrp is the most versatile.
 
 | 
| alert [Loggers.LOGGER] | 
 | 
| alist [Pp] | 
 | 
| all [Posix_clock] | 
 | 
| all_levs [Syslog] | 
all_levs array of all logging levels sorted in ascending order.
 
 | 
| all_same [Patience_diff.Hunk] | 
all_same hunk returns true if hunk contains only Same ranges.
 
 | 
| all_same [Patience_diff.Range] | 
 | 
| all_same [Patience_diff] | 
get_status hunks returns `Same if each hunk in hunks has only Same ranges.
 
 | 
| all_str_levs [Syslog] | 
all_str_levs array of all logging levels as strings sorted in
    ascending order.
 
 | 
| anon [Deprecated_fcommand] | 
 | 
| anon_pages [Procfs.Meminfo.Fields] | 
 | 
| anon_pages [Procfs.Meminfo] | 
 | 
| any_of_sexp [Array.Access_control] | 
 | 
| append [Lazy_sequence] | 
 | 
| append [Lazy_list] | 
 | 
| append [Array.Access_control] | 
 | 
| append_to_path [Environment] | 
 | 
| arg [Deprecated_command.Flag.Action] | 
an action for a flag that takes an additional string argument
 
 | 
| arg_mut [Deprecated_command.Flag] | 
 | 
| atom [Sexp] | 
 | 
| atomic_edit [Atomic_edit] | 
atomic_edit ~f filepath edit filepath by making a unique copy (peer)
    that can be openly changed without holding any locks on the original.
 
 | 
 B | 
| bash [Deprecated_command.Autocomplete] | 
create actions command_line gets the completion suggestions that
      bash's compgen would generate for the selected actions and the
      last word of the command_line.
 
 | 
| bench [Deprecated_bench] | 
 | 
| bench_raw [Deprecated_bench] | 
bench_raw returns a list documenting the runtimes rather than printing to
   stdout.
 
 | 
| bigint_of_sexp [Procfs] | 
 | 
| bin_any [Array.Access_control] | 
 | 
| bin_color [Color_print] | 
 | 
| bin_elt [Packed_array.Basic] | 
 | 
| bin_field [Stats_reporting] | 
 | 
| bin_flag [Extended_linux.Splice] | 
 | 
| bin_key [Packed_map.S] | 
 | 
| bin_mallinfo [Malloc] | 
 | 
| bin_name [Stats_reporting.Stored_data] | 
 | 
| bin_opt [Malloc] | 
Malloc options
 
 | 
| bin_read_any [Array.Access_control] | 
 | 
| bin_read_color [Color_print] | 
 | 
| bin_read_elt [Packed_array.Basic] | 
 | 
| bin_read_field [Stats_reporting] | 
 | 
| bin_read_flag [Extended_linux.Splice] | 
 | 
| bin_read_key [Packed_map.S] | 
 | 
| bin_read_mallinfo [Malloc] | 
 | 
| bin_read_name [Stats_reporting.Stored_data] | 
 | 
| bin_read_opt [Malloc] | 
 | 
| bin_read_statvfs [Unix] | 
 | 
| bin_read_t [Stats_reporting.Stored_data] | 
 | 
| bin_read_t [Selector.Stable.String_list_selector.V1] | 
 | 
| bin_read_t [Selector.Stable.String_selector.V1] | 
 | 
| bin_read_t [Selector.Stable.String_selector.Regexp.V1] | 
 | 
| bin_read_t [Selector.Stable.Date_selector.V1] | 
 | 
| bin_read_t [Selector.String_list_selector] | 
 | 
| bin_read_t [Selector.String_selector.Regexp] | 
 | 
| bin_read_t [Selector.String_selector] | 
 | 
| bin_read_t [Selector.Date_selector] | 
 | 
| bin_read_t [Prod_or_test] | 
 | 
| bin_read_t [Packed_map.Value] | 
 | 
| bin_read_t [Packed_map.Key] | 
 | 
| bin_read_t [Packed_map.S] | 
 | 
| bin_read_t [Unix.Mac_address] | 
 | 
| bin_read_t [Int64.Filesize] | 
 | 
| bin_read_type_desc [Stats_reporting.Stored_data] | 
 | 
| bin_read_uids [Extended_linux] | 
 | 
| bin_read_value [Packed_map.S] | 
 | 
| bin_reader_any [Array.Access_control] | 
 | 
| bin_reader_color [Color_print] | 
 | 
| bin_reader_elt [Packed_array.Basic] | 
 | 
| bin_reader_field [Stats_reporting] | 
 | 
| bin_reader_flag [Extended_linux.Splice] | 
 | 
| bin_reader_key [Packed_map.S] | 
 | 
| bin_reader_mallinfo [Malloc] | 
 | 
| bin_reader_name [Stats_reporting.Stored_data] | 
 | 
| bin_reader_opt [Malloc] | 
 | 
| bin_reader_statvfs [Unix] | 
 | 
| bin_reader_t [Stats_reporting.Stored_data] | 
 | 
| bin_reader_t [Selector.Stable.String_list_selector.V1] | 
 | 
| bin_reader_t [Selector.Stable.String_selector.V1] | 
 | 
| bin_reader_t [Selector.Stable.String_selector.Regexp.V1] | 
 | 
| bin_reader_t [Selector.Stable.Date_selector.V1] | 
 | 
| bin_reader_t [Selector.String_list_selector] | 
 | 
| bin_reader_t [Selector.String_selector.Regexp] | 
 | 
| bin_reader_t [Selector.String_selector] | 
 | 
| bin_reader_t [Selector.Date_selector] | 
 | 
| bin_reader_t [Prod_or_test] | 
 | 
| bin_reader_t [Packed_map.Value] | 
 | 
| bin_reader_t [Packed_map.Key] | 
 | 
| bin_reader_t [Packed_map.S] | 
 | 
| bin_reader_t [Unix.Mac_address] | 
 | 
| bin_reader_t [Int64.Filesize] | 
 | 
| bin_reader_type_desc [Stats_reporting.Stored_data] | 
 | 
| bin_reader_uids [Extended_linux] | 
 | 
| bin_reader_value [Packed_map.S] | 
 | 
| bin_size_any [Array.Access_control] | 
 | 
| bin_size_color [Color_print] | 
 | 
| bin_size_elt [Packed_array.Basic] | 
 | 
| bin_size_field [Stats_reporting] | 
 | 
| bin_size_flag [Extended_linux.Splice] | 
 | 
| bin_size_key [Packed_map.S] | 
 | 
| bin_size_mallinfo [Malloc] | 
 | 
| bin_size_name [Stats_reporting.Stored_data] | 
 | 
| bin_size_opt [Malloc] | 
 | 
| bin_size_statvfs [Unix] | 
 | 
| bin_size_t [Stats_reporting.Stored_data] | 
 | 
| bin_size_t [Selector.Stable.String_list_selector.V1] | 
 | 
| bin_size_t [Selector.Stable.String_selector.V1] | 
 | 
| bin_size_t [Selector.Stable.String_selector.Regexp.V1] | 
 | 
| bin_size_t [Selector.Stable.Date_selector.V1] | 
 | 
| bin_size_t [Selector.String_list_selector] | 
 | 
| bin_size_t [Selector.String_selector.Regexp] | 
 | 
| bin_size_t [Selector.String_selector] | 
 | 
| bin_size_t [Selector.Date_selector] | 
 | 
| bin_size_t [Prod_or_test] | 
 | 
| bin_size_t [Packed_map.Value] | 
 | 
| bin_size_t [Packed_map.Key] | 
 | 
| bin_size_t [Packed_map.S] | 
 | 
| bin_size_t [Unix.Mac_address] | 
 | 
| bin_size_t [Int64.Filesize] | 
 | 
| bin_size_type_desc [Stats_reporting.Stored_data] | 
 | 
| bin_size_uids [Extended_linux] | 
 | 
| bin_size_value [Packed_map.S] | 
 | 
| bin_statvfs [Unix] | 
 | 
| bin_t [Stats_reporting.Stored_data] | 
 | 
| bin_t [Selector.Stable.String_list_selector.V1] | 
 | 
| bin_t [Selector.Stable.String_selector.V1] | 
 | 
| bin_t [Selector.Stable.String_selector.Regexp.V1] | 
 | 
| bin_t [Selector.Stable.Date_selector.V1] | 
 | 
| bin_t [Selector.String_list_selector] | 
 | 
| bin_t [Selector.String_selector.Regexp] | 
 | 
| bin_t [Selector.String_selector] | 
 | 
| bin_t [Selector.Date_selector] | 
 | 
| bin_t [Prod_or_test] | 
 | 
| bin_t [Packed_map.Value] | 
 | 
| bin_t [Packed_map.Key] | 
 | 
| bin_t [Packed_map.S] | 
 | 
| bin_t [Unix.Mac_address] | 
 | 
| bin_t [Int64.Filesize] | 
 | 
| bin_type_desc [Stats_reporting.Stored_data] | 
 | 
| bin_uids [Extended_linux] | 
 | 
| bin_value [Packed_map.S] | 
 | 
| bin_write_any [Array.Access_control] | 
 | 
| bin_write_color [Color_print] | 
 | 
| bin_write_elt [Packed_array.Basic] | 
 | 
| bin_write_field [Stats_reporting] | 
 | 
| bin_write_flag [Extended_linux.Splice] | 
 | 
| bin_write_key [Packed_map.S] | 
 | 
| bin_write_mallinfo [Malloc] | 
 | 
| bin_write_name [Stats_reporting.Stored_data] | 
 | 
| bin_write_opt [Malloc] | 
 | 
| bin_write_statvfs [Unix] | 
 | 
| bin_write_t [Stats_reporting.Stored_data] | 
 | 
| bin_write_t [Selector.Stable.String_list_selector.V1] | 
 | 
| bin_write_t [Selector.Stable.String_selector.V1] | 
 | 
| bin_write_t [Selector.Stable.String_selector.Regexp.V1] | 
 | 
| bin_write_t [Selector.Stable.Date_selector.V1] | 
 | 
| bin_write_t [Selector.String_list_selector] | 
 | 
| bin_write_t [Selector.String_selector.Regexp] | 
 | 
| bin_write_t [Selector.String_selector] | 
 | 
| bin_write_t [Selector.Date_selector] | 
 | 
| bin_write_t [Prod_or_test] | 
 | 
| bin_write_t [Packed_map.Value] | 
 | 
| bin_write_t [Packed_map.Key] | 
 | 
| bin_write_t [Packed_map.S] | 
 | 
| bin_write_t [Unix.Mac_address] | 
 | 
| bin_write_t [Int64.Filesize] | 
 | 
| bin_write_type_desc [Stats_reporting.Stored_data] | 
 | 
| bin_write_uids [Extended_linux] | 
 | 
| bin_write_value [Packed_map.S] | 
 | 
| bin_writer_any [Array.Access_control] | 
 | 
| bin_writer_color [Color_print] | 
 | 
| bin_writer_elt [Packed_array.Basic] | 
 | 
| bin_writer_field [Stats_reporting] | 
 | 
| bin_writer_flag [Extended_linux.Splice] | 
 | 
| bin_writer_key [Packed_map.S] | 
 | 
| bin_writer_mallinfo [Malloc] | 
 | 
| bin_writer_name [Stats_reporting.Stored_data] | 
 | 
| bin_writer_opt [Malloc] | 
 | 
| bin_writer_statvfs [Unix] | 
 | 
| bin_writer_t [Stats_reporting.Stored_data] | 
 | 
| bin_writer_t [Selector.Stable.String_list_selector.V1] | 
 | 
| bin_writer_t [Selector.Stable.String_selector.V1] | 
 | 
| bin_writer_t [Selector.Stable.String_selector.Regexp.V1] | 
 | 
| bin_writer_t [Selector.Stable.Date_selector.V1] | 
 | 
| bin_writer_t [Selector.String_list_selector] | 
 | 
| bin_writer_t [Selector.String_selector.Regexp] | 
 | 
| bin_writer_t [Selector.String_selector] | 
 | 
| bin_writer_t [Selector.Date_selector] | 
 | 
| bin_writer_t [Prod_or_test] | 
 | 
| bin_writer_t [Packed_map.Value] | 
 | 
| bin_writer_t [Packed_map.Key] | 
 | 
| bin_writer_t [Packed_map.S] | 
 | 
| bin_writer_t [Unix.Mac_address] | 
 | 
| bin_writer_t [Int64.Filesize] | 
 | 
| bin_writer_type_desc [Stats_reporting.Stored_data] | 
 | 
| bin_writer_uids [Extended_linux] | 
 | 
| bin_writer_value [Packed_map.S] | 
 | 
| blito [Array.Access_control] | 
 | 
| block [Pp] | 
A block contains objects xs formatted by f and enclosed by curly
braces.
 
 | 
| blocked [Procfs.Process.Stat.Fields] | 
 | 
| blocked [Procfs.Process.Stat] | 
 | 
| blue [Color_print] | 
 | 
| blueprintf [Color_print] | 
 | 
| bold [Color_print] | 
 | 
| boldprintf [Color_print] | 
 | 
| bool [Deprecated_command.Flag.Action] | 
an action for a flag that takes an additional bool argument
 
 | 
| bool [Deprecated_command.Flag] | 
 | 
| bool_acc [Deprecated_command.Flag] | 
 | 
| bool_mut [Deprecated_command.Flag] | 
 | 
| bounce [Procfs.Meminfo.Fields] | 
 | 
| bounce [Procfs.Meminfo] | 
 | 
| break [Pp] | 
The important points in a document are so-called breaks.
 
 | 
| break_null [Pp] | 
break_null behaves like break except it does not insert anything when no
newline is inserted.
 
 | 
| break_with [Pp] | 
The space character used by break my be not always appropriate.
 
 | 
| bsearch [Search_foo] | 
 | 
| bsearch2 [Search_foo] | 
 | 
| bsearch2_exn [Search_foo] | 
 | 
| bsearch2_opt [Search_foo] | 
 | 
| bsearch_exn [Search_foo] | 
 | 
| bsearch_opt [Search_foo] | 
 | 
| bsearch_val [Search_foo] | 
 | 
| bsearch_val_exn [Search_foo] | 
 | 
| bsearch_val_opt [Search_foo] | 
 | 
| btry_wrap_r_lock [Rw_mutex] | 
btry_wrap_r_lock mtx f tries to lock mtx for a reader without
    blocking, executes f and unlocks the mutex again.
 
 | 
| btry_wrap_w_lock [Rw_mutex] | 
btry_wrap_w_lock mtx f tries to lock mtx for a writer without
    blocking, executes f and unlocks the mutex again.
 
 | 
| buffers [Procfs.Meminfo.Fields] | 
 | 
| buffers [Procfs.Meminfo] | 
 | 
| build [Lazy_list] | 
 | 
| bytes [Unix.Quota] | 
 | 
| bytes_of_sexp [Unix.Quota] | 
 | 
 C | 
| cached [Procfs.Meminfo.Fields] | 
 | 
| cached [Procfs.Meminfo] | 
 | 
| call_with_cache [Cache.S] | 
 | 
| call_with_cache [Cache.Keep_all] | 
 | 
| call_with_cache [Cache.Lru] | 
 | 
| callback [Shell.Process] | 
 | 
| capture_remaining_command_line [Deprecated_fcommand] | 
 | 
| cartesian_product [Lazy_list] | 
 | 
| cb_compare [Cbuffer] | 
compare two buffer fragments
 
 | 
| change [Hashtbl.Access_control] | 
 | 
| channel [Iter] | 
call f on channel until End_of_file
 
 | 
| channel_progress [Iter] | 
create a progress function for an input channel
 
 | 
| check [Sys_utils.Sexp_checked_edit] | 
 | 
| check [Number.Verified_spec] | 
 | 
| check_index [Cbuffer] | 
 | 
| check_sexps [Sys_utils.Sexp_checked_edit] | 
 | 
| checked_edit [Sys_utils] | 
checked_edit ~check file
 
 | 
| choice [Readline] | 
 choice ["a",a;"b",b] 
    Prompts the user to choose a between several value (associated to strings)
    and returns the value chosen by the user.
 
 | 
| classify [List] | 
classify l ~equal ~f elements x and y of list l are assigned to the
    same class iff equal (f x) (f y) returns true.
 
 | 
| clear [Hashtbl.Access_control] | 
 | 
| clear [Deprecated_command.Annotated_field] | 
 | 
| clear [Deprecated_command.Flag] | 
 | 
| clear [Cache.S] | 
 | 
| clear [Cache.Store] | 
Remove all the values from the store.
 
 | 
| clear [Cache.Strategy] | 
Inform the strategy that all the elements where dropped from the store.
 
 | 
| clear [Cache.Keep_all] | 
 | 
| clear [Cache.Lru] | 
 | 
| clear [Bitarray] | 
clear t set the contents of every element to false O(n / (word_size - 2))
 
 | 
| clear_filter [Logger] | 
removes the filter from a log
 
 | 
| close [Linebuf] | 
Closes the line buffer (and the underlying file).
 
 | 
| close [Lazy_sequence.Iterator] | 
 | 
| close [Find] | 
close t drops all the resources associated with t.
 
 | 
| closelog [Syslog] | 
closelog () closes the connection to the syslog daemon.
 
 | 
| cmajflt [Procfs.Process.Stat.Fields] | 
 | 
| cmajflt [Procfs.Process.Stat] | 
 | 
| cmd [Shell.Process] | 
 | 
| cmd [Deprecated_fcommand] | 
 | 
| cmdline [Procfs.Process.Fields] | 
 | 
| cmdline [Procfs.Process] | 
 | 
| cminflt [Procfs.Process.Stat.Fields] | 
 | 
| cminflt [Procfs.Process.Stat] | 
 | 
| cmp_fasc [Search_foo] | 
 | 
| cmp_fdesc [Search_foo] | 
 | 
| cnswap [Procfs.Process.Stat.Fields] | 
 | 
| cnswap [Procfs.Process.Stat] | 
 | 
| codename [Sys_utils.Lsb_release.Fields] | 
 | 
| codename [Sys_utils.Lsb_release] | 
 | 
| collate [String] | 
collate s1 s2 sorts string in an order that's usaully more suited for human
    consumption by treating ints specially, e.g.
 
 | 
| color [Color_print] | 
 | 
| color_of_sexp [Color_print] | 
 | 
| colorprintf [Color_print] | 
 | 
| comm [Procfs.Process.Stat.Fields] | 
 | 
| comm [Procfs.Process.Stat] | 
 | 
| commalist [Pp] | 
 | 
| command [Deprecated_service_command] | 
 | 
| command [Deprecated_command.Version] | 
Provides a "version" subcommand.
 
 | 
| commands_only [Invocation] | 
 | 
| comment [Sexp] | 
Takes a string and returns the same string but commented according to
    sexp's syntax
 
 | 
| commit_limit [Procfs.Meminfo.Fields] | 
 | 
| commit_limit [Procfs.Meminfo] | 
 | 
| committed_as [Procfs.Meminfo.Fields] | 
 | 
| committed_as [Procfs.Meminfo] | 
 | 
| compactions_occurred [Deprecated_bench.Result] | 
 | 
| compare [Trie.Key.Part] | 
 | 
| compare [Prod_or_test] | 
 | 
| compare [List] | 
 | 
| compare [Filename] | 
Filename.compare is a comparison that normalizes filenames ("./a" = "a"), uses a more
    human ready algorithm based on String.collate ("rfc02.txt > rfc1.txt") and
    extenstions ("a.c" > "a.h").
 
 | 
| compare_lev [Syslog] | 
compare_lev lev1 lev2 compares logging levels lev1 and lev2.
 
 | 
| compress_table_header [Text_block] | 
 | 
| concat [Splay_tree.S] | 
 | 
| concat [Packed_array.Of_packed_array] | 
 | 
| concat [Lazy_sequence] | 
 | 
| concat [Lazy_list] | 
 | 
| concat [Iter] | 
concatenate a list of iterators
 
 | 
| concat_list [Lazy_list] | 
 | 
| concat_list_seq [Lazy_sequence] | 
 | 
| concat_map [Lazy_sequence] | 
 | 
| concat_seq_list [Lazy_sequence] | 
 | 
| confirm [Readline] | 
Prompts for an answer.
 
 | 
| connect_tmout [Net_utils] | 
Connect a socket with a connect timeout
 
 | 
| cons [Lazy_list] | 
 | 
| const [Deprecated_fcommand] | 
 | 
| contains [Trie.S] | 
 | 
| content [Shell.Process] | 
 | 
| content_and_stderr [Shell.Process] | 
 | 
| contents [String_zipper] | 
 | 
| contents [Readline__input_loop] | 
 | 
| copy [Lazy_sequence.Iterator] | 
 | 
| copy [Hashtbl.Access_control] | 
 | 
| copy [Array.Access_control] | 
 | 
| copy_data [Cbuffer] | 
copies data from one array to another.
 
 | 
| core_file_size [Procfs.Process.Limits.Fields] | 
 | 
| core_file_size [Procfs.Process.Limits] | 
 | 
| cp [Shell] | 
 | 
| cps_create [Cache.Store] | 
cps_create is given in CPS form to enable chaining.
 
 | 
| cps_create [Cache.Strategy] | 
cps_create ~f  is given in CPS form to enable chaining.
 
 | 
| cpu_t_of_sexp [Procfs.Kstat] | 
 | 
| cpu_time [Procfs.Process.Limits.Fields] | 
 | 
| cpu_time [Procfs.Process.Limits] | 
 | 
| cpu_use [Sys_utils.Cpu_use] | 
cpu_use gives an estimated CPU usage (between 0 and 1) in the time period between
      the last 2 calls to update_exn.
 
 | 
| create [Update_queue] | 
 | 
| create [Trie.S] | 
 | 
| create [Sys_utils.Lsb_release.Fields] | 
 | 
| create [String_zipper] | 
 | 
| create [Stats_reporting.Delta] | 
 | 
| create [Shell__line_buffer] | 
create ~eol f
    Create a new line buffer where f will be called once on every line.
 
 | 
| create [Sampler] | 
create dist compiles a discrete probability distribution into a form
    supporting constant-time sampling.
 
 | 
| create [Rw_mutex] | 
create pref
 
 | 
| create [Readline__input_loop] | 
 | 
| create [Readline.History] | 
 | 
| create [Random_selection] | 
create ~random_state desired_sample_size creates an empty sample of 'a values.
 
 | 
| create [Procfs.Mount.Fields] | 
 | 
| create [Procfs.Net.Tcp.Fields] | 
 | 
| create [Procfs.Net.Route.Fields] | 
 | 
| create [Procfs.Net.Dev.Fields] | 
 | 
| create [Procfs.Loadavg.Fields] | 
 | 
| create [Procfs.Kstat.Fields_of_cpu_t] | 
 | 
| create [Procfs.Meminfo.Fields] | 
 | 
| create [Procfs.Process.Fields] | 
 | 
| create [Procfs.Process.Fd.Fields] | 
 | 
| create [Procfs.Process.Status.Fields] | 
 | 
| create [Procfs.Process.Statm.Fields] | 
 | 
| create [Procfs.Process.Stat.Fields] | 
 | 
| create [Procfs.Process.Limits.Fields] | 
 | 
| create [Procfs.Process.Limits.Rlimit.Fields] | 
 | 
| create [Logger] | 
- max_size - the maximum size of each log file (default 50Mb) mode - mode to open the files in, max_archives - maximum number of archives to keep (default 4), full_callback - called when the logger queue backs up so far that log items
                    may have been lost.  Defaults to doing nothing., filter - if set, then every message is passed to filter before actually being
             logged.  If filter returns false the message is dropped., message_to_string - called to convert your message type to a string for logging
 
 | 
| create [List_zipper] | 
 | 
| create [Linebuf] | 
Open a line buffer from the passed filename.
 
 | 
| create [Lazy_sequence.Iterator] | 
 | 
| create [Lazy_list.Iterator] | 
 | 
| create [Find] | 
create ?options dir create a Find.t based in dir
 
 | 
| create [Array.Access_control] | 
 | 
| create [Exception_check] | 
create should not be called more than once
 
 | 
| create [Deprecated_command.Flags_ext] | 
 | 
| create [Deprecated_command.Flag] | 
 | 
| create [Deprecated_command] | 
 | 
| create [Deprecated_bench.Test] | 
 | 
| create [Cbuffer] | 
 | 
| create [Cache.S] | 
 | 
| create [Cache.Keep_all] | 
 | 
| create [Cache.Lru] | 
 | 
| create [Bitarray] | 
create size size must be less than ((word size - 2) * max array length)
 
 | 
| create0 [Deprecated_command] | 
 | 
| create_choice [Deprecated_command.Flags_ext] | 
 | 
| create_choice_optional [Deprecated_command.Flags_ext] | 
 | 
| create_default [Logger] | 
creates a log using the default message type and a filter that drops 
  `Debug messages
 
 | 
| create_field [Stats_reporting] | 
 | 
| create_many [Deprecated_command.Flags_ext] | 
 | 
| create_no_accum [Deprecated_command] | 
 | 
| create_no_accum0 [Deprecated_command] | 
 | 
| create_optional [Deprecated_command.Flags_ext] | 
 | 
| create_rest [Deprecated_command.Flags_ext] | 
 | 
| create_set [Deprecated_command.Flags_ext] | 
 | 
| crit [Loggers.LOGGER] | 
 | 
| critical [Fd_leak_check] | 
Fraction of maximum number of descriptors considered critical.
 
 | 
| cstime [Procfs.Process.Stat.Fields] | 
 | 
| cstime [Procfs.Process.Stat] | 
 | 
| cutime [Procfs.Process.Stat.Fields] | 
 | 
| cutime [Procfs.Process.Stat] | 
 | 
| cwd [Procfs.Process.Fields] | 
 | 
| cwd [Procfs.Process] | 
 | 
| cyan [Color_print] | 
 | 
| cyanprintf [Color_print] | 
 | 
 D | 
| data [Procfs.Process.Statm.Fields] | 
 | 
| data [Procfs.Process.Statm] | 
 | 
| data [Fold_map.S2] | 
 | 
| data [Fold_map.S] | 
 | 
| data [Hashtbl.Access_control] | 
 | 
| data [Cache.Store] | 
data store returns all values in store.
 
 | 
| data_size [Procfs.Process.Limits.Fields] | 
 | 
| data_size [Procfs.Process.Limits] | 
 | 
| date [Deprecated_fcommand] | 
 | 
| date_acc [Deprecated_command.Flag] | 
rest f: a flag that signals the end of flag processing.
 
 | 
| date_mut [Deprecated_command.Flag] | 
rest f: a flag that signals the end of flag processing.
 
 | 
| debug [Loggers.LOGGER] | 
 | 
| decons [Lazy_list] | 
 | 
| default [Readline.History] | 
 | 
| default [Procfs.Net.Route] | 
 | 
| default [Find.Options] | 
 | 
| default [Deprecated_command.Annotated_field] | 
 | 
| delete [Splay_tree.S] | 
 | 
| delete_max [Splay_tree.S] | 
 | 
| delete_min [Splay_tree.S] | 
 | 
| desired_sample_size [Random_selection] | 
the desired sample size
 
 | 
| destination [Procfs.Net.Route.Fields] | 
 | 
| destination [Procfs.Net.Route] | 
 | 
| diff [Sys_utils] | 
diff s1 s2 returns diff (1) output of the two strings.
 
 | 
| diff [Posix_clock.Time_stamp_counter] | 
 | 
| directory [Unix.Mount_entry] | 
 | 
| dirty [Procfs.Meminfo.Fields] | 
 | 
| dirty [Procfs.Meminfo] | 
 | 
| discard [Shell.Process] | 
 | 
| distributor_id [Sys_utils.Lsb_release.Fields] | 
 | 
| distributor_id [Sys_utils.Lsb_release] | 
 | 
| documentation [Documented_match_statement] | 
 | 
| drop [Lazy_sequence] | 
 | 
| drop_after [String_zipper] | 
 | 
| drop_after [List_zipper] | 
 | 
| drop_all_after [String_zipper] | 
 | 
| drop_all_after [List_zipper] | 
 | 
| drop_all_before [String_zipper] | 
 | 
| drop_all_before [List_zipper] | 
 | 
| drop_before [String_zipper] | 
 | 
| drop_before [List_zipper] | 
 | 
| drop_from [Cbuffer] | 
 | 
| drop_last [Cbuffer] | 
 | 
| drop_old [Cbuffer] | 
drop stuff from the end.
 
 | 
| dt [Procfs.Process.Statm.Fields] | 
 | 
| dt [Procfs.Process.Statm] | 
 | 
| dump_freq [Unix.Mount_entry] | 
 | 
 E | 
| edit [Sys_utils.Sexp_checked_edit] | 
 | 
| edit_distance [String] | 
Gives the Levenshtein distance between 2 strings, which is the number of insertions,
    deletions, and substitutions necessary to turn either string into the other.
 
 | 
| edit_sexps [Sys_utils.Sexp_checked_edit] | 
 | 
| egid [Procfs.Process.Status.Fields] | 
 | 
| egid [Procfs.Process.Status] | 
 | 
| either [Deprecated_fcommand] | 
 | 
| elt_of_sexp [Packed_array.Basic] | 
 | 
| emerg [Loggers.LOGGER] | 
 | 
| empty [Splay_tree.S] | 
 | 
| empty [Pp] | 
The empty document is pretty printed to the empty string.
 
 | 
| empty [Packed_map.S] | 
 | 
| empty [Packed_array.S] | 
 | 
| empty [Multi_map] | 
 | 
| empty [Lazy_sequence] | 
 | 
| empty [Lazy_list] | 
 | 
| empty [Iter] | 
an iterator that halts immediately
 
 | 
| empty [Fold_map.S2] | 
 | 
| empty [Fold_map.S] | 
A map containing no bindings
 
 | 
| empty [Deprecated_fcommand] | 
 | 
| empty [Deprecated_bench.Result.Stat] | 
 | 
| empty [Crit_bit] | 
 | 
| endcode [Procfs.Process.Stat.Fields] | 
 | 
| endcode [Procfs.Process.Stat] | 
 | 
| enqueue [Update_queue] | 
 | 
| ensure_at_exit [Unix_utils] | 
ensure_at_exit (): catch all signals, run at_exit functions,
    then re-deliver the signal to self to ensure the default behavior.
 
 | 
| enumerate_from [List] | 
enumerate_from n xs returns a list of pairs constructed by pairing an
    incrementing counter, starting at n, with the elements of xs.
 
 | 
| environ [Procfs.Process.Fields] | 
 | 
| environ [Procfs.Process] | 
 | 
| eprint [Printc] | 
 | 
| eprintl [Printc] | 
 | 
| equal [Unix.Mac_address] | 
 | 
| equal [List] | 
 | 
| equal [Hashtbl.Access_control] | 
 | 
| err [Loggers.LOGGER] | 
 | 
| error [Generic] | 
 | 
| escape_field [Csv_writer] | 
Escape a CSV (even if doesn't have any characters that require escaping).
 
 | 
| esyslog [Syslog] | 
esyslog ?fac ?lev str same as  Syslog.syslog, but also prints to
     stderr.
  
 | 
| esyslogf [Syslog] | 
esyslog_printf ?fac ?lev fmt same as Syslog.syslog_printf,
    but also prints to stderr.
 
 | 
| euid [Procfs.Process.Status.Fields] | 
 | 
| euid [Procfs.Process.Status] | 
 | 
| eval [Selector.Selector] | 
 | 
| exe [Procfs.Process.Fields] | 
 | 
| exe [Procfs.Process] | 
 | 
| exists [Sys_utils.Lsb_release.Fields] | 
 | 
| exists [Procfs.Mount.Fields] | 
 | 
| exists [Procfs.Net.Tcp.Fields] | 
 | 
| exists [Procfs.Net.Route.Fields] | 
 | 
| exists [Procfs.Net.Dev.Fields] | 
 | 
| exists [Procfs.Loadavg.Fields] | 
 | 
| exists [Procfs.Kstat.Fields_of_cpu_t] | 
 | 
| exists [Procfs.Meminfo.Fields] | 
 | 
| exists [Procfs.Process.Fields] | 
 | 
| exists [Procfs.Process.Fd.Fields] | 
 | 
| exists [Procfs.Process.Status.Fields] | 
 | 
| exists [Procfs.Process.Statm.Fields] | 
 | 
| exists [Procfs.Process.Stat.Fields] | 
 | 
| exists [Procfs.Process.Limits.Fields] | 
 | 
| exists [Procfs.Process.Limits.Rlimit.Fields] | 
 | 
| exists [Iter] | 
 | 
| exists [Fold_map.S2] | 
 | 
| exists [Fold_map.S] | 
 | 
| exists [Hashtbl.Access_control] | 
 | 
| existsi [Hashtbl.Access_control] | 
 | 
| exit_signal [Procfs.Process.Stat.Fields] | 
 | 
| exit_signal [Procfs.Process.Stat] | 
 | 
| expand [Filename] | 
expand Makes a path absolute and expands ~ ~username to home directories.
 
 | 
| expand [Cbuffer] | 
double the size of the buffer
 
 | 
| explode [Filename] | 
Splits a given path into a list of strings.
 
 | 
| extra_path [Shell__core] | 
 | 
| extra_path [Shell] | 
variable used by dispatch command to find binaries not in the path.
 
 | 
| extract_command [Procfs.Process.Stat] | 
 | 
 F | 
| f [Fold_map.Foldable2] | 
 | 
| f [Fold_map.Foldable] | 
The folding function.
 
 | 
| f2s [Printc] | 
 | 
| fd [Procfs.Process.Fd.Fields] | 
 | 
| fd [Procfs.Process.Fd] | 
 | 
| fd_stat [Procfs.Process.Fd.Fields] | 
 | 
| fd_stat [Procfs.Process.Fd] | 
 | 
| fd_stat_of_sexp [Procfs.Process.Fd] | 
 | 
| fds [Sys_utils.Cpu_use] | 
 | 
| fds [Procfs.Process.Fields] | 
 | 
| fds [Procfs.Process] | 
 | 
| fgrp [Pp] | 
The break policy inside an agrp is fixed for all breaks of the group.
 
 | 
| field_of_sexp [Stats_reporting] | 
 | 
| fifteen [Procfs.Loadavg.Fields] | 
 | 
| fifteen [Procfs.Loadavg] | 
 | 
| file [Procfs.Mount.Fields] | 
 | 
| file [Procfs.Mount] | 
 | 
| file_kind [Sys] | 
 | 
| file_locks [Procfs.Process.Limits.Fields] | 
 | 
| file_locks [Procfs.Process.Limits] | 
 | 
| file_size [Procfs.Process.Limits.Fields] | 
 | 
| file_size [Procfs.Process.Limits] | 
 | 
| file_size [Sys] | 
 | 
| file_size_exn [Sys] | 
 | 
| fill [Text_block] | 
 | 
| fill [Array.Access_control] | 
 | 
| filter [Multi_map] | 
 | 
| filter [Logger] | 
Sets the filter for a log
 
 | 
| filter [Lazy_sequence] | 
 | 
| filter [Lazy_list] | 
 | 
| filter [Iter] | 
iterate over elements that satisfy the predicate
 
 | 
| filter [Fold_map.S2] | 
 | 
| filter [Fold_map.S] | 
 | 
| filter [Hashtbl.Access_control] | 
 | 
| filter_fold_map [Lazy_sequence] | 
 | 
| filter_inplace [Hashtbl.Access_control] | 
 | 
| filter_map [Lazy_sequence] | 
 | 
| filter_map [Lazy_list] | 
 | 
| filter_map [Hashtbl.Access_control] | 
 | 
| filter_map [Array.Access_control] | 
 | 
| filter_map_partial [Lazy_sequence] | 
 | 
| filter_mapi [Lazy_sequence] | 
 | 
| filter_mapi [Hashtbl.Access_control] | 
 | 
| filter_mapi [Array.Access_control] | 
 | 
| filter_opt [Lazy_list] | 
 | 
| filter_opt [Array.Access_control] | 
 | 
| filter_record [Sexp] | 
 | 
| filteri [Hashtbl.Access_control] | 
 | 
| filteri_inplace [Hashtbl.Access_control] | 
 | 
| find [Splay_tree.S] | 
 | 
| find [Packed_map.S] | 
 | 
| find [Multi_map] | 
find m key returns all the elements that where added to key in m in
      the reverse order in which they where added.
 
 | 
| find [Lazy_list] | 
 | 
| find [Iter] | 
find an element that satisfies the predicate
 
 | 
| find [Fold_map.S2] | 
 | 
| find [Fold_map.S] | 
 | 
| find [Hashtbl.Access_control] | 
 | 
| find [Environment] | 
 | 
| find [Crit_bit] | 
 | 
| find [Cache.S] | 
 | 
| find [Cache.Store] | 
find store key returns the value associated to key in store.
 
 | 
| find [Cache.Keep_all] | 
 | 
| find [Cache.Lru] | 
 | 
| find_all [Find] | 
find_all ?options dir short for to_list (create ?options dir)
 
 | 
| find_exn [Hashtbl.Access_control] | 
 | 
| find_exn [Environment] | 
 | 
| find_or_add [Hashtbl.Access_control] | 
 | 
| findi [Array.Access_control] | 
 | 
| first [String_zipper] | 
 | 
| flag [Deprecated_fcommand] | 
 | 
| flag [Deprecated_command.Flags_ext] | 
 | 
| flag_of_sexp [Extended_linux.Splice] | 
 | 
| flags [Procfs.Net.Route.Fields] | 
 | 
| flags [Procfs.Net.Route] | 
 | 
| flags [Procfs.Process.Stat.Fields] | 
 | 
| flags [Procfs.Process.Stat] | 
 | 
| float [Deprecated_fcommand] | 
 | 
| float [Deprecated_command.Flag.Action] | 
an action for a flag that takes an additional float argument
 
 | 
| float [Deprecated_command.Flag] | 
 | 
| float_acc [Deprecated_command.Flag] | 
 | 
| float_mut [Deprecated_command.Flag] | 
 | 
| flush [Shell__line_buffer] | 
flush b Flushes any pending output to the callback function.
 
 | 
| flush [Readline.History] | 
 | 
| fold [Sys_utils.Lsb_release.Fields.Direct] | 
 | 
| fold [Sys_utils.Lsb_release.Fields] | 
 | 
| fold [Stats_reporting.Stored_data] | 
 | 
| fold [Procfs.Mount.Fields.Direct] | 
 | 
| fold [Procfs.Mount.Fields] | 
 | 
| fold [Procfs.Net.Tcp.Fields.Direct] | 
 | 
| fold [Procfs.Net.Tcp.Fields] | 
 | 
| fold [Procfs.Net.Route.Fields.Direct] | 
 | 
| fold [Procfs.Net.Route.Fields] | 
 | 
| fold [Procfs.Net.Dev.Fields.Direct] | 
 | 
| fold [Procfs.Net.Dev.Fields] | 
 | 
| fold [Procfs.Loadavg.Fields.Direct] | 
 | 
| fold [Procfs.Loadavg.Fields] | 
 | 
| fold [Procfs.Kstat.Fields_of_cpu_t.Direct] | 
 | 
| fold [Procfs.Kstat.Fields_of_cpu_t] | 
 | 
| fold [Procfs.Meminfo.Fields.Direct] | 
 | 
| fold [Procfs.Meminfo.Fields] | 
 | 
| fold [Procfs.Process.Fields.Direct] | 
 | 
| fold [Procfs.Process.Fields] | 
 | 
| fold [Procfs.Process.Fd.Fields.Direct] | 
 | 
| fold [Procfs.Process.Fd.Fields] | 
 | 
| fold [Procfs.Process.Status.Fields.Direct] | 
 | 
| fold [Procfs.Process.Status.Fields] | 
 | 
| fold [Procfs.Process.Statm.Fields.Direct] | 
 | 
| fold [Procfs.Process.Statm.Fields] | 
 | 
| fold [Procfs.Process.Stat.Fields.Direct] | 
 | 
| fold [Procfs.Process.Stat.Fields] | 
 | 
| fold [Procfs.Process.Limits.Fields.Direct] | 
 | 
| fold [Procfs.Process.Limits.Fields] | 
 | 
| fold [Procfs.Process.Limits.Rlimit.Fields.Direct] | 
 | 
| fold [Procfs.Process.Limits.Rlimit.Fields] | 
 | 
| fold [Packed_array.S] | 
 | 
| fold [Multi_map] | 
 | 
| fold [Lazy_sequence.Iterator] | 
 | 
| fold [Iter] | 
fold is the same as reduce
 
 | 
| fold [Generic] | 
 | 
| fold [Fold_map.S2] | 
 | 
| fold [Fold_map.S] | 
 | 
| fold [Find] | 
fold t ~init ~f folds f over the files in t
 
 | 
| fold [Hashtbl.Access_control] | 
 | 
| fold [Crit_bit] | 
 | 
| fold [Bitarray] | 
fold t ~init ~f Fold over the array as in Array.fold
 
 | 
| fold_left [Lazy_list] | 
 | 
| fold_left_term [List] | 
fold_left_term is like fold_left, except that you can halt early.
 
 | 
| fold_map [Lazy_sequence] | 
 | 
| fold_right [Lazy_list] | 
 | 
| foldi [Lazy_sequence] | 
 | 
| foldi [Array] | 
 | 
| foldr [Lazy_list] | 
 | 
| for_all [Sys_utils.Lsb_release.Fields] | 
 | 
| for_all [Procfs.Mount.Fields] | 
 | 
| for_all [Procfs.Net.Tcp.Fields] | 
 | 
| for_all [Procfs.Net.Route.Fields] | 
 | 
| for_all [Procfs.Net.Dev.Fields] | 
 | 
| for_all [Procfs.Loadavg.Fields] | 
 | 
| for_all [Procfs.Kstat.Fields_of_cpu_t] | 
 | 
| for_all [Procfs.Meminfo.Fields] | 
 | 
| for_all [Procfs.Process.Fields] | 
 | 
| for_all [Procfs.Process.Fd.Fields] | 
 | 
| for_all [Procfs.Process.Status.Fields] | 
 | 
| for_all [Procfs.Process.Statm.Fields] | 
 | 
| for_all [Procfs.Process.Stat.Fields] | 
 | 
| for_all [Procfs.Process.Limits.Fields] | 
 | 
| for_all [Procfs.Process.Limits.Rlimit.Fields] | 
 | 
| for_all [Iter] | 
evaluate a predicate over the entire iterator
 
 | 
| for_all [Fold_map.S2] | 
 | 
| for_all [Fold_map.S] | 
 | 
| force [Lazy_sequence] | 
 | 
| force [Lazy_m] | 
Force the lazy value.
 
 | 
| fork_exec [Unix] | 
fork_exec prog args ~stdin ~stdout ~stderr ~setuid ~setgid
   forks a new process that executes the program
   in file prog, with arguments args.
 
 | 
| format [Time.Date] | 
Shortcut for calling  Core_extended.Unix.strftime without having to
     create a Time.t and convert it to a Unix.tm.
  
 | 
| format [Sexp] | 
 | 
| format_failed [Shell.Process] | 
 | 
| fprint [Printc] | 
 | 
| fprintl [Printc] | 
 | 
| freq [Procfs.Mount.Fields] | 
 | 
| freq [Procfs.Mount] | 
 | 
| fsck_pass [Unix.Mount_entry] | 
 | 
| fsgid [Procfs.Process.Status.Fields] | 
 | 
| fsgid [Procfs.Process.Status] | 
 | 
| fsname [Unix.Mount_entry] | 
 | 
| fstype [Unix.Mount_entry] | 
 | 
| fsuid [Procfs.Process.Status.Fields] | 
 | 
| fsuid [Procfs.Process.Status] | 
 | 
| full [Invocation] | 
 | 
 G | 
| gateway [Procfs.Net.Route.Fields] | 
 | 
| gateway [Procfs.Net.Route] | 
 | 
| gen [Deprecated_command.Flag] | 
 | 
| gen_acc [Deprecated_command.Flag] | 
 | 
| gen_mut [Deprecated_command.Flag] | 
 | 
| general_rec [Memo] | 
A version of Memo.general more suitable for memoizing
    recursively-defined functions
 
 | 
| generic [Loggers.LOGGER] | 
 | 
| get [Sys_utils.Cpu_use] | 
get returns a Cpu_use.t for the given pid or the current processes's pid, if none
      given.
 
 | 
| get [Semaphore] | 
get sem
 
 | 
| get [Readline__input_char] | 
 | 
| get [Packed_array.S] | 
 | 
| get [Lazy_sequence.Iterator] | 
 | 
| get [Array.Access_control] | 
 | 
| get [Deprecated_command.Flags_ext] | 
 | 
| get [Deprecated_command.Annotated_field] | 
 | 
| get [Cbuffer] | 
 | 
| get [Bitarray] | 
get t pos get the value in position pos, raises Invalid_argument if the position
    is out of bounds.
 
 | 
| get_all_procs [Procfs] | 
get_all_procs returns a list of all processes on the system
 
 | 
| get_editor [Sys_utils] | 
Get the default editor (program) for this user.
 
 | 
| get_editor_exn [Sys_utils] | 
 | 
| get_exn [Lazy_sequence.Iterator] | 
 | 
| get_expanded_argv [Deprecated_command] | 
 | 
| get_expanded_cmdline [Deprecated_command] | 
 | 
| get_groups [Sys_utils] | 
 | 
| get_hunks [Patience_diff] | 
get_hunks a b ~context ~compare will compare the arrays a and b using
    compare and produce a list of hunks.
 
 | 
| get_lev [Loggers.LOGGER] | 
Get minimum log level
 
 | 
| get_list [Deprecated_command.Annotated_field] | 
 | 
| get_matching_blocks [Patience_diff] | 
 | 
| get_num_open_fds [Fd_leak_check] | 
 | 
| get_opt [Deprecated_command.Annotated_field] | 
 | 
| get_pager [Sys_utils] | 
Analogous to get_editor, defaulting to a list including less and more.
 
 | 
| get_ppids [Unix_utils] | 
get_ppids pid returns the list of parent pids, up to init (1) for pid.
 
 | 
| getbyname_ip [Sys_utils] | 
getbyname_ip () returns the IP of the current host by resolving the hostname.
 
 | 
| getloadavg [Unix] | 
get load averages
 
 | 
| getres [Posix_clock] | 
 | 
| getresuid [Extended_linux] | 
 | 
| gettid [Unix] | 
 | 
| gettime [Posix_clock] | 
 | 
| gid [Procfs.Process.Status.Fields] | 
 | 
| gid [Procfs.Process.Status] | 
 | 
| gray [Color_print] | 
 | 
| grayprintf [Color_print] | 
 | 
| green [Color_print] | 
 | 
| greenprintf [Color_print] | 
 | 
| group [Service_command] | 
 | 
| group [Deprecated_command] | 
group ~summary [...; (name_i, t_i); ...] is an aggregate command
    that dispatches to one of the named sub-commands.
 
 | 
| groups [Sys] | 
Get the names of the groups the user belongs to
 
 | 
| guest [Procfs.Kstat.Fields_of_cpu_t] | 
 | 
| guest [Procfs.Kstat] | 
 | 
 H | 
| h_name_of_sockaddr [Net_utils] | 
Get hostname from sockaddr
 
 | 
| h_name_or_string_of_sockaddr [Net_utils] | 
Get hostname or (on Not_found) inet string from sockaddr
 
 | 
| halign [Text_block] | 
 | 
| hard [Procfs.Process.Limits.Rlimit.Fields] | 
 | 
| hard [Procfs.Process.Limits.Rlimit] | 
 | 
| has_next [Lazy_sequence.Iterator] | 
 | 
| hash [Trie.Key.Part] | 
 | 
| hcat [Text_block] | 
 | 
| hd [Lazy_sequence] | 
 | 
| head [Shell.Process] | 
 | 
| head_exn [Shell.Process] | 
 | 
| height [Text_block] | 
 | 
| hgrp [Pp] | 
A group operator takes a document and let it become a group.
 
 | 
| hlist [Pp] | 
 hlist [x1,..,xn] = hgrp [x1; break; x2; ...; break; xn)  
 
 | 
| home [Sys] | 
Get the home of the effective user
 
 | 
| hostname [Sys] | 
 | 
| hstrut [Text_block] | 
 | 
| htonl [Unix] | 
Host to network order long, like C.
 
 | 
 I | 
| i [Iter] | 
iterate over the iterator: call f on each element
 
 | 
| i2s [Printc] | 
 | 
| idle [Procfs.Kstat.Fields_of_cpu_t] | 
 | 
| idle [Procfs.Kstat] | 
 | 
| iface [Procfs.Net.Route.Fields] | 
 | 
| iface [Procfs.Net.Route] | 
 | 
| iface [Procfs.Net.Dev.Fields] | 
 | 
| iface [Procfs.Net.Dev] | 
 | 
| ifconfig_ips [Sys_utils] | 
ifconfig_ips () returns IPs of all active interfaces on the host by parsing ifconfig
    output.
 
 | 
| ignore_errors [Find.Options] | 
 | 
| implode [Filename] | 
dual to explode
 
 | 
| import_from_sys [Environment] | 
 | 
| in_order [Search_foo] | 
 | 
| inactive [Procfs.Meminfo.Fields] | 
 | 
| inactive [Procfs.Meminfo] | 
 | 
| incr [Hashtbl.Access_control] | 
 | 
| index_t_of_sexp [Procfs.Kstat] | 
 | 
| inet_addr_of_sockaddr [Net_utils] | 
Get inet_addr from sockaddr
 
 | 
| info [Loggers.LOGGER] | 
 | 
| init [Update_queue] | 
 | 
| init [Stats_reporting] | 
 | 
| init [Semaphore] | 
init v initializes a semaphore with an optional value v.
 
 | 
| init [Lazy_sequence] | 
 | 
| init [Fold_map.Foldable2] | 
 | 
| init [Fold_map.Foldable] | 
The initial value of the accumulator.
 
 | 
| init [Array.Access_control] | 
 | 
| init [Deprecated_command.Annotated_field] | 
 | 
| initialize [Lazy_sequence] | 
 | 
| inode [Procfs.Net.Tcp.Fields] | 
 | 
| inode [Procfs.Net.Tcp] | 
 | 
| inodes [Unix.Quota] | 
 | 
| inodes_of_sexp [Unix.Quota] | 
 | 
| input_all_with_reused_buffer [Procfs] | 
 | 
| input_line [Readline] | 
 
 | 
| input_line_eof [Readline] | 
 | 
| insert_after [String_zipper] | 
 | 
| insert_after [List_zipper] | 
 | 
| insert_before [String_zipper] | 
 | 
| insert_before [List_zipper] | 
 | 
| int [Deprecated_fcommand] | 
 | 
| int [Deprecated_command.Flag.Action] | 
an action for a flag that takes an additional int argument
 
 | 
| int [Deprecated_command.Flag] | 
 | 
| int_acc [Deprecated_command.Flag] | 
 | 
| int_mut [Deprecated_command.Flag] | 
 | 
| interfaces [Procfs.Net.Dev] | 
 | 
| invariant [Invariant.S3] | 
 | 
| invariant [Invariant.S2] | 
 | 
| invariant [Invariant.S1] | 
 | 
| inverse [Color_print] | 
 | 
| inverseprintf [Color_print] | 
 | 
| iowait [Procfs.Kstat.Fields_of_cpu_t] | 
 | 
| iowait [Procfs.Kstat] | 
 | 
| ip_of_name [Sys_utils] | 
ip_of_name hostname looks up the hostname and prints the IP in dotted-quad
    format.
 
 | 
| irq [Procfs.Kstat.Fields_of_cpu_t] | 
 | 
| irq [Procfs.Kstat] | 
 | 
| irtt [Procfs.Net.Route.Fields] | 
 | 
| irtt [Procfs.Net.Route] | 
 | 
| is_atom [Sexp] | 
 | 
| is_closed [Linebuf] | 
Returns whether or not the line buffer is closed
 
 | 
| is_empty [Splay_tree.S] | 
 | 
| is_empty [Multi_map] | 
 | 
| is_empty [Lazy_list] | 
 | 
| is_empty [Fold_map.S2] | 
 | 
| is_empty [Fold_map.S] | 
 | 
| is_empty [Hashtbl.Access_control] | 
 | 
| is_executable [Shell__core] | 
 | 
| is_full [Cbuffer] | 
 | 
| is_list [Sexp] | 
 | 
| is_parent [Filename] | 
is_parent dir1 dir2 returns true if dir1 is a parent of dir2
 
 | 
| is_prod [Prod_or_test] | 
 | 
| is_set [Deprecated_command.Flags_ext] | 
 | 
| is_substring [String] | 
is_substring ~substring t returns true if substring is a substring
 * of t.
 
 | 
| is_test [Prod_or_test] | 
 | 
| is_val [Lazy_m] | 
Returns true if the lazy value has been forced and did not throw an
    exception.
 
 | 
| iter [Trie.Key] | 
 | 
| iter [Sys_utils.Lsb_release.Fields.Direct] | 
 | 
| iter [Sys_utils.Lsb_release.Fields] | 
 | 
| iter [Procfs.Mount.Fields.Direct] | 
 | 
| iter [Procfs.Mount.Fields] | 
 | 
| iter [Procfs.Net.Tcp.Fields.Direct] | 
 | 
| iter [Procfs.Net.Tcp.Fields] | 
 | 
| iter [Procfs.Net.Route.Fields.Direct] | 
 | 
| iter [Procfs.Net.Route.Fields] | 
 | 
| iter [Procfs.Net.Dev.Fields.Direct] | 
 | 
| iter [Procfs.Net.Dev.Fields] | 
 | 
| iter [Procfs.Loadavg.Fields.Direct] | 
 | 
| iter [Procfs.Loadavg.Fields] | 
 | 
| iter [Procfs.Kstat.Fields_of_cpu_t.Direct] | 
 | 
| iter [Procfs.Kstat.Fields_of_cpu_t] | 
 | 
| iter [Procfs.Meminfo.Fields.Direct] | 
 | 
| iter [Procfs.Meminfo.Fields] | 
 | 
| iter [Procfs.Process.Fields.Direct] | 
 | 
| iter [Procfs.Process.Fields] | 
 | 
| iter [Procfs.Process.Fd.Fields.Direct] | 
 | 
| iter [Procfs.Process.Fd.Fields] | 
 | 
| iter [Procfs.Process.Status.Fields.Direct] | 
 | 
| iter [Procfs.Process.Status.Fields] | 
 | 
| iter [Procfs.Process.Statm.Fields.Direct] | 
 | 
| iter [Procfs.Process.Statm.Fields] | 
 | 
| iter [Procfs.Process.Stat.Fields.Direct] | 
 | 
| iter [Procfs.Process.Stat.Fields] | 
 | 
| iter [Procfs.Process.Limits.Fields.Direct] | 
 | 
| iter [Procfs.Process.Limits.Fields] | 
 | 
| iter [Procfs.Process.Limits.Rlimit.Fields.Direct] | 
 | 
| iter [Procfs.Process.Limits.Rlimit.Fields] | 
 | 
| iter [Packed_map.S] | 
 | 
| iter [Packed_array.S] | 
 | 
| iter [Multi_map] | 
 | 
| iter [Lazy_sequence.Iterator] | 
 | 
| iter [Lazy_list.Iterator] | 
 | 
| iter [Lazy_list] | 
 | 
| iter [Generic] | 
 | 
| iter [Fold_map.S2] | 
 | 
| iter [Fold_map.S] | 
 | 
| iter [Find] | 
iter t ~f calls f on every file in t
 
 | 
| iter [Hashtbl.Access_control] | 
 | 
| iter [Crit_bit] | 
 | 
| iter [Cbuffer] | 
iter buf ~f calls func on each buffer element starting with 0
    like this: (func pos element)
 
 | 
| iter [Bitarray] | 
iter t ~f Iterate over the array as in Array.iter
 
 | 
| iter_vals [Hashtbl.Access_control] | 
 | 
| iteri [Lazy_sequence] | 
 | 
| iteri [Array.Access_control] | 
 | 
| iterr [Cbuffer] | 
iterr buf ~f calls func on each buffer element starting with end
    like this: (func pos element)
 
 | 
| itrealvalue [Procfs.Process.Stat.Fields] | 
 | 
| itrealvalue [Procfs.Process.Stat] | 
 | 
 J | 
| jiffies_per_second [Procfs] | 
 | 
| jiffies_per_second_exn [Procfs] | 
jiffies_per_second_exn.
 
 | 
 K | 
| key_of_sexp [Packed_map.S] | 
 | 
| keys [Multi_map] | 
Returns all the non-empty keys in m.
 
 | 
| keys [Fold_map.S2] | 
 | 
| keys [Fold_map.S] | 
 | 
| keys [Hashtbl.Access_control] | 
 | 
| kill [Process] | 
kills a process by sending signal; waiting for wait_for and then
    sending a sigkill.
 
 | 
| kstkeip [Procfs.Process.Stat.Fields] | 
 | 
| kstkeip [Procfs.Process.Stat] | 
 | 
| kstkesp [Procfs.Process.Stat.Fields] | 
 | 
| kstkesp [Procfs.Process.Stat] | 
 | 
 L | 
| last [String_zipper] | 
 | 
| last [Lazy_sequence] | 
 | 
| last_accessed [Sys] | 
last_accessed path returns the time path was last accessed.
 
 | 
| last_accessed_exn [Sys] | 
 | 
| last_changed [Sys] | 
last_changed path returns the time path last had its status changed.
 
 | 
| last_changed_exn [Sys] | 
 | 
| last_modified [Sys] | 
last_modify path returns the time the file at path was last modified.
 
 | 
| last_modified_exn [Sys] | 
 | 
| lazy_fold [Lazy_list.Of_container.T] | 
 | 
| lazy_list_of_t [Lazy_list.Of_container.Make] | 
 | 
| lazy_sort [Lazy_list] | 
 | 
| lcs [Extended_list__LCS] | 
 | 
| lcs [List] | 
Find the longest common subsequence between two list.
 
 | 
| left_contents [String_zipper] | 
 | 
| length [Packed_array.Basic] | 
 | 
| length [Lazy_list] | 
 | 
| length [Generic] | 
 | 
| length [Fold_map.S2] | 
 | 
| length [Fold_map.S] | 
 | 
| length [Hashtbl.Access_control] | 
 | 
| length [Cbuffer] | 
 | 
| length_bounded_by [Lazy_sequence] | 
 | 
| length_if_at_most [Lazy_sequence] | 
 | 
| lev_of_string [Syslog] | 
lev_of_string str converts string str to a level.
 
 | 
| lib [Procfs.Process.Statm.Fields] | 
 | 
| lib [Procfs.Process.Statm] | 
 | 
| lift [Deprecated_command.Flag] | 
lift t ~project transforms a flag with accumulator type 'a
      into a flag with a more informative accumulator type 'b
      provided that project x returns a pair consisting of
        1.
 
 | 
| lift_unit [Deprecated_command.Flag] | 
 | 
| limit_of_sexp [Unix.Quota] | 
 | 
| limits [Procfs.Process.Fields] | 
 | 
| limits [Procfs.Process] | 
 | 
| line_break [String] | 
deprecated in favour of word_wrap
 
 | 
| line_to_string [Csv_writer] | 
Convert one CSV line to a string.
 
 | 
| lines [Shell.Process] | 
 | 
| list [Pp] | 
A list of objects which are seperated by some seperator is very common.
 
 | 
| list [Generic] | 
 | 
| list [Sexp] | 
 | 
| list [Deprecated_command.Annotated_field] | 
 | 
| listed [Deprecated_fcommand] | 
 | 
| ln [Shell] | 
 | 
| load [Bin_io_utils] | 
 | 
| load_exn [Procfs.Net.Tcp] | 
This does IO and is not async-ok.
 
 | 
| load_exn [Procfs.Kstat] | 
 | 
| load_sexp_conv_exn_sample [Sexp] | 
 | 
| loadavg [Procfs] | 
 | 
| loadavg_exn [Procfs] | 
loadavg_exn parses /proc/loadavg.
 
 | 
| local_address [Procfs.Net.Tcp.Fields] | 
 | 
| local_address [Procfs.Net.Tcp] | 
 | 
| local_port [Procfs.Net.Tcp.Fields] | 
 | 
| local_port [Procfs.Net.Tcp] | 
 | 
| locked_memory [Procfs.Process.Limits.Fields] | 
 | 
| locked_memory [Procfs.Process.Limits] | 
 | 
| log [Logger] | 
logs a message to log
 
 | 
| logger [Loggers.SPEC] | 
 | 
| look [Semaphore] | 
look sem
 
 | 
| lower [Number.Verified_std.Bounded_spec] | 
 | 
| lpad [Printc] | 
 | 
| ls [Sys] | 
 | 
 M | 
| magenta [Color_print] | 
 | 
| magentaprintf [Color_print] | 
 | 
| main [Service_command.T] | 
 | 
| main_spec [Service_command.T] | 
 | 
| majflt [Procfs.Process.Stat.Fields] | 
 | 
| majflt [Procfs.Process.Stat] | 
 | 
| make_absolute [Filename] | 
make_absolute src Turn src into an absolute path expanded from the current working
    directory.
 
 | 
| make_creator [Sys_utils.Lsb_release.Fields] | 
 | 
| make_creator [Procfs.Mount.Fields] | 
 | 
| make_creator [Procfs.Net.Tcp.Fields] | 
 | 
| make_creator [Procfs.Net.Route.Fields] | 
 | 
| make_creator [Procfs.Net.Dev.Fields] | 
 | 
| make_creator [Procfs.Loadavg.Fields] | 
 | 
| make_creator [Procfs.Kstat.Fields_of_cpu_t] | 
 | 
| make_creator [Procfs.Meminfo.Fields] | 
 | 
| make_creator [Procfs.Process.Fields] | 
 | 
| make_creator [Procfs.Process.Fd.Fields] | 
 | 
| make_creator [Procfs.Process.Status.Fields] | 
 | 
| make_creator [Procfs.Process.Statm.Fields] | 
 | 
| make_creator [Procfs.Process.Stat.Fields] | 
 | 
| make_creator [Procfs.Process.Limits.Fields] | 
 | 
| make_creator [Procfs.Process.Limits.Rlimit.Fields] | 
 | 
| make_flags [Extended_linux.Splice] | 
make_flags ar
 
 | 
| make_relative [Filename] | 
make_relative ~to_:src f returns f relative to src.
 
 | 
| make_ssh_command [Shell.Process] | 
 | 
| mallinfo [Malloc] | 
 | 
| mallinfo_of_sexp [Malloc] | 
 | 
| malloc_stats [Malloc] | 
malloc_stats () prints brief summary statistics on stderr.
 
 | 
| malloc_trim [Malloc] | 
malloc_trim n release all but n bytes of freed top-most memory
    back to the system.
 
 | 
| mallopt [Malloc] | 
mallopt opt n sets malloc configuration option opt to n.
 
 | 
| many [Deprecated_fcommand] | 
 | 
| map [Update_queue] | 
 | 
| map [Sys_utils.Lsb_release.Fields] | 
 | 
| map [Procfs.Mount.Fields] | 
 | 
| map [Procfs.Net.Tcp.Fields] | 
 | 
| map [Procfs.Net.Route.Fields] | 
 | 
| map [Procfs.Net.Dev.Fields] | 
 | 
| map [Procfs.Loadavg.Fields] | 
 | 
| map [Procfs.Kstat.Fields_of_cpu_t] | 
 | 
| map [Procfs.Meminfo.Fields] | 
 | 
| map [Procfs.Process.Fields] | 
 | 
| map [Procfs.Process.Fd.Fields] | 
 | 
| map [Procfs.Process.Status.Fields] | 
 | 
| map [Procfs.Process.Statm.Fields] | 
 | 
| map [Procfs.Process.Stat.Fields] | 
 | 
| map [Procfs.Process.Limits.Fields] | 
 | 
| map [Procfs.Process.Limits.Rlimit.Fields] | 
 | 
| map [Multi_map] | 
 | 
| map [Lazy_sequence] | 
 | 
| map [Lazy_list] | 
 | 
| map [Iter] | 
transform the iterator
 
 | 
| map [Generic] | 
 | 
| map [Hashtbl.Access_control] | 
 | 
| map [Array.Access_control] | 
 | 
| map [Documented_match_statement] | 
 | 
| map [Deprecated_fcommand.Anons] | 
 | 
| map [Deprecated_fcommand.Flag] | 
 | 
| map [Crit_bit] | 
 | 
| map2_exn [Array.Access_control] | 
 | 
| map_accum [List] | 
A combination of map and fold.
 
 | 
| map_case [Documented_match_statement] | 
 | 
| map_cases [Documented_match_statement] | 
 | 
| map_monad [Extended_monad.S2] | 
 | 
| map_monad [Extended_monad.S] | 
 | 
| map_monad [Extended_monad.Make2] | 
 | 
| map_monad [Extended_monad.Make] | 
 | 
| map_monad_ignore [Extended_monad.S2] | 
 | 
| map_monad_ignore [Extended_monad.S] | 
 | 
| map_monad_ignore [Extended_monad.Make2] | 
 | 
| map_monad_ignore [Extended_monad.Make] | 
 | 
| map_pattern [Documented_match_statement] | 
 | 
| map_poly [Sys_utils.Lsb_release.Fields] | 
 | 
| map_poly [Procfs.Mount.Fields] | 
 | 
| map_poly [Procfs.Net.Tcp.Fields] | 
 | 
| map_poly [Procfs.Net.Route.Fields] | 
 | 
| map_poly [Procfs.Net.Dev.Fields] | 
 | 
| map_poly [Procfs.Loadavg.Fields] | 
 | 
| map_poly [Procfs.Kstat.Fields_of_cpu_t] | 
 | 
| map_poly [Procfs.Meminfo.Fields] | 
 | 
| map_poly [Procfs.Process.Fields] | 
 | 
| map_poly [Procfs.Process.Fd.Fields] | 
 | 
| map_poly [Procfs.Process.Status.Fields] | 
 | 
| map_poly [Procfs.Process.Statm.Fields] | 
 | 
| map_poly [Procfs.Process.Stat.Fields] | 
 | 
| map_poly [Procfs.Process.Limits.Fields] | 
 | 
| map_poly [Procfs.Process.Limits.Rlimit.Fields] | 
 | 
| mapi [Multi_map] | 
 | 
| mapi [Lazy_sequence] | 
 | 
| mapi [Hashtbl.Access_control] | 
 | 
| mapi [Array.Access_control] | 
 | 
| mapped [Procfs.Meminfo.Fields] | 
 | 
| mapped [Procfs.Meminfo] | 
 | 
| mask [Procfs.Net.Route.Fields] | 
 | 
| mask [Procfs.Net.Route] | 
 | 
| match_ [Documented_match_statement] | 
match_ t pulls out the underlying function of t
 
 | 
| matches [Selector.String_selector.Regexp] | 
 | 
| max [List] | 
 | 
| max [Deprecated_bench.Result] | 
 | 
| max_exn [List] | 
 | 
| max_len [Search_foo] | 
 | 
| maxf [Search_foo] | 
 | 
| may_log [Loggers.LOGGER] | 
Test whether a log level may be logged.
 
 | 
| maybe [Deprecated_fcommand] | 
 | 
| maybe_add [Random_selection] | 
maybe_add t x will randomly either add x to t or ignore it.
 
 | 
| maybe_escape_field [Csv_writer] | 
Escape the a CSV field if need be.
 
 | 
| maybe_log [Logger] | 
logs a message to Some log, returns silently if log is None
 
 | 
| maybe_raise [Exception_check] | 
maybe_raise name if the exception associated with any name in name
    has been triggered, then raise it, otherwise do nothing.
 
 | 
| maybe_with_default [Deprecated_fcommand] | 
 | 
| mean [Deprecated_bench.Result] | 
 | 
| mean_gettime_cost [Posix_clock] | 
 | 
| mem [Splay_tree.S] | 
 | 
| mem [Packed_map.S] | 
 | 
| mem [Multi_map] | 
mem m key returns true if key has at last one value associated to it
      in m
 
 | 
| mem [Fold_map.S2] | 
 | 
| mem [Fold_map.S] | 
 | 
| mem [Hashtbl.Access_control] | 
 | 
| mem [Environment] | 
 | 
| mem_free [Procfs.Meminfo.Fields] | 
 | 
| mem_free [Procfs.Meminfo] | 
 | 
| mem_total [Procfs.Meminfo.Fields] | 
 | 
| mem_total [Procfs.Meminfo] | 
 | 
| meminfo [Procfs] | 
 | 
| meminfo_exn [Procfs] | 
meminfo_exn queries /proc/meminfo and fills out Meminfo.t.
 
 | 
| memoize [Cache.S] | 
 | 
| memoize [Cache.Keep_all] | 
 | 
| memoize [Cache.Lru] | 
 | 
| memoize [Cache] | 
memoize ~destruct ~expire f
    memoizes the results of f.
 
 | 
| merge [Patience_diff] | 
 | 
| merge [Lazy_list] | 
 | 
| merge [Hashtbl.Access_control] | 
 | 
| merge_into [Hashtbl.Access_control] | 
 | 
| metric [Procfs.Net.Route.Fields] | 
 | 
| metric [Procfs.Net.Route] | 
 | 
| min [List] | 
 | 
| min [Deprecated_bench.Result] | 
 | 
| min_exn [List] | 
 | 
| min_interval [Posix_clock] | 
 | 
| minf [Search_foo] | 
 | 
| minflt [Procfs.Process.Stat.Fields] | 
 | 
| minflt [Procfs.Process.Stat] | 
 | 
| mkdir [Shell] | 
 | 
| mntops [Procfs.Mount.Fields] | 
 | 
| mntops [Procfs.Mount] | 
 | 
| module_name [Number.Verified_std_spec] | 
 | 
| mounts [Procfs] | 
 | 
| mounts_of_fstab [Procfs] | 
 | 
| msgqueue_size [Procfs.Process.Limits.Fields] | 
 | 
| msgqueue_size [Procfs.Process.Limits] | 
 | 
| mtu [Procfs.Net.Route.Fields] | 
 | 
| mtu [Procfs.Net.Route] | 
 | 
| multimerge [Extended_list__multimerge] | 
 | 
| multimerge [List] | 
Merges several list trying to keep the order in which the elements appear.
 
 | 
| multimerge_unique [Extended_list__multimerge] | 
 | 
| multimerge_unique [List] | 
 | 
| mv [Shell] | 
Raises "Failed_command"
 
 | 
 N | 
| name [Number.Verified_std.Bounded_spec] | 
 | 
| name [Linebuf] | 
 | 
| name [Deprecated_command.Flag] | 
 | 
| name [Deprecated_bench.Test] | 
 | 
| name_of_sexp [Stats_reporting.Stored_data] | 
 | 
| names [Sys_utils.Lsb_release.Fields] | 
 | 
| names [Procfs.Mount.Fields] | 
 | 
| names [Procfs.Net.Tcp.Fields] | 
 | 
| names [Procfs.Net.Route.Fields] | 
 | 
| names [Procfs.Net.Dev.Fields] | 
 | 
| names [Procfs.Loadavg.Fields] | 
 | 
| names [Procfs.Kstat.Fields_of_cpu_t] | 
 | 
| names [Procfs.Meminfo.Fields] | 
 | 
| names [Procfs.Process.Fields] | 
 | 
| names [Procfs.Process.Fd.Fields] | 
 | 
| names [Procfs.Process.Status.Fields] | 
 | 
| names [Procfs.Process.Statm.Fields] | 
 | 
| names [Procfs.Process.Stat.Fields] | 
 | 
| names [Procfs.Process.Limits.Fields] | 
 | 
| names [Procfs.Process.Limits.Rlimit.Fields] | 
 | 
| nest [Pp] | 
When the pretty printer decides to represent a break as a newline it also
prints some spaces after it to indent the following line.
 
 | 
| new_only [Patience_diff.Range] | 
new_only hunks drops all Old ranges and converts all Replace
    ranges to New ranges.
 
 | 
| new_only [Patience_diff] | 
new_only hunks drops all Old ranges from hunks and converts all Replace
    ranges to New ranges.
 
 | 
| next [String_zipper] | 
 | 
| next [List_zipper] | 
 | 
| next [Lazy_list.Iterator] | 
 | 
| next [Iter] | 
get the next element of the iterator
 
 | 
| next [Find] | 
next t return the next file from the collection of valid files in t or None
  if no more files remain
 
 | 
| next_exn [Iter] | 
 | 
| nfs_unstable [Procfs.Meminfo.Fields] | 
 | 
| nfs_unstable [Procfs.Meminfo] | 
 | 
| nice [Procfs.Kstat.Fields_of_cpu_t] | 
 | 
| nice [Procfs.Kstat] | 
 | 
| nice [Procfs.Process.Stat.Fields] | 
 | 
| nice [Procfs.Process.Stat] | 
 | 
| nice_priority [Procfs.Process.Limits.Fields] | 
 | 
| nice_priority [Procfs.Process.Limits] | 
 | 
| nil [Text_block] | 
 | 
| no_anons [Deprecated_command.Helpers] | 
 | 
| no_arg [Deprecated_fcommand] | 
 | 
| no_arg_bool [Deprecated_fcommand] | 
 | 
| noarg [Deprecated_command.Flag.Action] | 
an action for a flag that takes no additional argument
 
 | 
| noarg [Deprecated_command.Flag] | 
 | 
| noarg_acc [Deprecated_command.Flag] | 
 | 
| noarg_mut [Deprecated_command.Flag] | 
 | 
| noninteractive_no_hostkey_checking_options [Shell] | 
 | 
| noninteractive_ssh_options [Shell] | 
 | 
| normal [Color_print] | 
 | 
| normalize [Filename] | 
normalize path Removes as much "." and ".." from the path as possible.
 
 | 
| notice [Loggers.LOGGER] | 
 | 
| np_pref [Rw_mutex] | 
np_pref no preference for readers or writers.
 
 | 
| nswap [Procfs.Process.Stat.Fields] | 
 | 
| nswap [Procfs.Process.Stat] | 
 | 
| nth [Lazy_sequence] | 
 | 
| nth [Lazy_list] | 
 | 
| ntohl [Unix] | 
Network to host order long, like C.
 
 | 
| null [Readline.History] | 
A value which is always empty
 
 | 
| number [Extended_list__multimerge] | 
 | 
| number [List] | 
 | 
 O | 
| of_aarray [Packed_map.S] | 
 | 
| of_alist [Packed_map.S] | 
 | 
| of_arg [Deprecated_command.Flag] | 
 | 
| of_array [Packed_array.Basic] | 
 | 
| of_array [Packed_array.S] | 
 | 
| of_array [Lazy_sequence] | 
 | 
| of_array [Lazy_list] | 
 | 
| of_array [Iter] | 
create an iterator that will go over array elements
 
 | 
| of_array [Array.Access_control] | 
 | 
| of_array [Cbuffer] | 
initialize Cbuffer from array
 
 | 
| of_array_copy [Array.Access_control] | 
 | 
| of_channel [Iter] | 
create an iterator that will read from file using f
 
 | 
| of_core_command [Deprecated_command] | 
 | 
| of_exec_env [Environment] | 
 | 
| of_exn [Exn.Exn_string] | 
 | 
| of_fun [Lazy_m] | 
Create a lazy value of a function.
 
 | 
| of_hashtbl [Packed_map.S] | 
 | 
| of_hashtbl [Hashtbl.Access_control] | 
 | 
| of_int [Procfs.Net.Tcp_state] | 
 | 
| of_int [Unix.Inet_port] | 
 | 
| of_int_exn [Unix.Inet_port] | 
 | 
| of_iterator [Lazy_list] | 
 | 
| of_line [Procfs.Net.Tcp] | 
These don't do any IO and should be async-ok
 
 | 
| of_line [Bin_io_utils] | 
 | 
| of_line_exn [Procfs.Net.Tcp] | 
 | 
| of_list [Readline.History] | 
 | 
| of_list [Packed_array.S] | 
 | 
| of_list [Lazy_sequence] | 
 | 
| of_list [Lazy_list] | 
 | 
| of_list [Iter] | 
create an iterator that will go over list elements
 
 | 
| of_list [Fold_map.S2] | 
 | 
| of_list [Fold_map.S] | 
 | 
| of_list [Extended_option] | 
 | 
| of_list [Array.Access_control] | 
 | 
| of_map [Fold_map.S2] | 
 | 
| of_map [Fold_map.S] | 
 | 
| of_opt [Iter] | 
create an iterator that may iterate over one value
 
 | 
| of_option [List] | 
of_option o returns a list that is empty if o is None, otherwise it is a singleton
    list.
 
 | 
| of_passwd_file [Unix.Extended_passwd] | 
of_passwd_file parse a passwd-like file
 
 | 
| of_passwd_file_exn [Unix.Extended_passwd] | 
of_passwd_file_exn parse a passwd-like file
 
 | 
| of_passwd_line [Unix.Extended_passwd] | 
of_passwd_line parse a passwd-like line
 
 | 
| of_passwd_line_exn [Unix.Extended_passwd] | 
of_passwd_line_exn parse a passwd-like line
 
 | 
| of_prod_bool [Prod_or_test] | 
 | 
| of_regexp [Selector.String_selector.Regexp] | 
 | 
| of_sexp_allow_extra_fields [Sexp] | 
of_sexp_allow_extra_fields of_sexp sexp uses of_sexp to convert sexp to a
    value, but will not fail if there any extra fields in a record.
 
 | 
| of_sexps [Sexp.Diff] | 
 | 
| of_sorted_aarray [Packed_map.S] | 
 | 
| of_string [Procfs.Net.Dev] | 
 | 
| of_string [Procfs.Process.Status] | 
 | 
| of_string [Procfs.Process.Statm] | 
 | 
| of_string [Procfs.Process.Stat] | 
 | 
| of_string [Procfs.Process.Limits] | 
 | 
| of_string [Procfs.Process.Inode] | 
 | 
| of_string [Unix.Mac_address] | 
 | 
| of_string [Unix.Inet_port] | 
 | 
| of_string [Int64.Filesize] | 
 | 
| of_string_exn [Unix.Inet_port] | 
 | 
| of_test_bool [Prod_or_test] | 
 | 
| of_val [Lazy_m] | 
Create a lazy value of a non-lazy value.
 
 | 
| ok [Generic] | 
 | 
| ok [Result.Exn] | 
ok t returns x if t = Ok x, or raises e if t = Error e.
 
 | 
| old_only [Patience_diff.Range] | 
old_only hunks drops all New ranges and converts all Replace
      ranges to Old ranges.
 
 | 
| old_only [Patience_diff] | 
old_only hunks drops all New ranges from hunks and converts all Replace
    ranges to Old ranges.
 
 | 
| one [Procfs.Loadavg.Fields] | 
 | 
| one [Procfs.Loadavg] | 
 | 
| one [Float.Fraction] | 
 | 
| oom_adj [Procfs.Process.Fields] | 
 | 
| oom_adj [Procfs.Process] | 
 | 
| oom_score [Procfs.Process.Fields] | 
 | 
| oom_score [Procfs.Process] | 
 | 
| open_connection_tmout [Net_utils] | 
Open a connection with timeouts
 
 | 
| open_fd_connection_tmout [Net_utils] | 
Create a socket with timeouts
 
 | 
| open_files [Procfs.Process.Limits.Fields] | 
 | 
| open_files [Procfs.Process.Limits] | 
 | 
| openlog [Syslog] | 
openlog ?id ?opt ?fac () opens a connection to the system logger
    (possibly delayed) using prefixed identifier id, options opt,
    and faculty fac.
 
 | 
| opt_of_sexp [Malloc] | 
 | 
| option [Generic] | 
 | 
| optional [Deprecated_fcommand] | 
 | 
| optional [Deprecated_command.Annotated_field] | 
 | 
| optional_with_default [Deprecated_fcommand] | 
 | 
| options [Unix.Mount_entry] | 
 | 
| order_of_magnitude_difference [Float] | 
order_of_magnitude_difference a b
   by how many orders of magnitude do a and b differ?
   The return value is non-negative.
 
 | 
| output_lines [Csv_writer] | 
Prints a valid csv file to a given channel (note that line are ended
    "\r\n")
 
 | 
 P | 
| pad_left [String] | 
pad_left ~char s len
    Returns s padded to the length len by adding characters char to the
    left of the string.
 
 | 
| pad_right [String] | 
 | 
| page_contents [Sys_utils] | 
page_contents ?pager ?tmp_name str will show str in a pager.
 
 | 
| page_tables [Procfs.Meminfo.Fields] | 
 | 
| page_tables [Procfs.Meminfo] | 
 | 
| parent [Filename] | 
parent path The parent of the root directory is the root directory
 
 | 
| parse_date [English] | 
 | 
| parse_int [English] | 
parse_int s: Like standard int_of_string, but try to convert the first
    twenty english numbers (eg.
 
 | 
| parse_line [Unix.Mount_entry] | 
 | 
| parse_time [English] | 
 | 
| passno [Procfs.Mount.Fields] | 
 | 
| passno [Procfs.Mount] | 
 | 
| password [Readline] | 
Prompts for a password.
 
 | 
| path_expand [Shell__core] | 
 | 
| peek [Lazy_sequence.Iterator] | 
 | 
| pending_signals [Procfs.Process.Limits.Fields] | 
 | 
| pending_signals [Procfs.Process.Limits] | 
 | 
| percent_fds_in_use [Fd_leak_check] | 
percent_fds_in_use () reports the percentage of fds that are in use.
 
 | 
| permute [Array.Access_control] | 
 | 
| pgrep [Procfs] | 
pgrep f returns all processes for which f is true
 
 | 
| pgrp [Procfs.Process.Stat.Fields] | 
 | 
| pgrp [Procfs.Process.Stat] | 
 | 
| phys_length [Cbuffer] | 
 | 
| physical_ram [Unix_utils] | 
physical_ram ()
 
 | 
| pid [Procfs.Process.Fields] | 
 | 
| pid [Procfs.Process] | 
 | 
| pid_alive [Sys_utils] | 
 | 
| pkill [Procfs] | 
pkill ~signal f sends the signal to all processes for which f returns true.
 
 | 
| policy [Procfs.Process.Stat.Fields] | 
 | 
| policy [Procfs.Process.Stat] | 
 | 
| port_of_in_channel [Net_utils] | 
Get port from a socket associated with an in_channel
 
 | 
| port_of_sockaddr [Net_utils] | 
Get port from sockaddr
 
 | 
| pp_hum' [Sexp] | 
A more readable but less compact pretty printer than the one bundled by
   sexplib.
 
 | 
| ppid [Procfs.Process.Stat.Fields] | 
 | 
| ppid [Procfs.Process.Stat] | 
 | 
| prepend [Documented_match_statement] | 
prepend ~specific_cases t matches on specific_cases before moving on to t.
 
 | 
| pretty [Float] | 
pretty-print a float using no more than five characters, using abberviations
   k, m, g, t.
 
 | 
| previous [String_zipper] | 
 | 
| previous [List_zipper] | 
 | 
| print [Readline__input_loop] | 
 | 
| print [Printc] | 
 | 
| print [Sexp.Diff] | 
 | 
| print [Deprecated_bench] | 
 | 
| print_diff [Sexp] | 
 | 
| print_ranges [Patience_diff] | 
 | 
| print_version [Deprecated_command.Version] | 
 | 
| printl [Printc] | 
 | 
| priority [Procfs.Process.Stat.Fields] | 
 | 
| priority [Procfs.Process.Stat] | 
 | 
| process_age [Procfs] | 
 | 
| process_age' [Procfs] | 
 | 
| processes [Procfs.Process.Limits.Fields] | 
 | 
| processes [Procfs.Process.Limits] | 
 | 
| processor [Procfs.Process.Stat.Fields] | 
 | 
| processor [Procfs.Process.Stat] | 
 | 
| progress [Iter] | 
get the position in the iterator either None or Some x in 0;1
 
 | 
| progress_string [Iter] | 
convert the progress return value to a string: None->"", Some->" 33%"
 
 | 
| protect [Lazy_sequence] | 
 | 
 Q | 
| query [Sys_utils.Lsb_release] | 
 | 
| query [Sntp] | 
query hostname returns the difference between the clock on the
  local host and the clock on the host specified by hostname.
 
 | 
| query [Unix.Quota] | 
 | 
| quote_blit [Csv_writer] | 
Copy and escapes the content of a field over from one string to
    another.
 
 | 
| quote_len [Csv_writer] | 
Get the escaped length of one quoted field (without the quotes).
 
 | 
 R | 
| r_lock [Rw_mutex] | 
r_lock mtx locks mtx for a reader.
 
 | 
| r_pref [Rw_mutex] | 
r_pref preference kind for readers.
 
 | 
| r_unlock [Rw_mutex] | 
r_unlock mtx unlocks mtx for a reader.
 
 | 
| ram_limit_spec [Unix_utils] | 
ram_limit_spec command line arguments to set ram limits.
 
 | 
| random [Float.Fraction] | 
 | 
| random_split [Array] | 
makes a random split & subset of an array; p (the fraction that you want to split) is
   constrained to be 0, 1.
 
 | 
| random_sub [Array] | 
 | 
| ranges [Patience_diff] | 
ranges hunks concatenates all the ranges of all hunks together *
 
 | 
| ratio [Patience_diff] | 
 | 
| rdtsc [Posix_clock.Time_stamp_counter] | 
 | 
| rdtscp [Posix_clock.Time_stamp_counter] | 
 | 
| read [Linebuf] | 
Calls try_read every 0.01 seconds and returns when a line is available.
 
 | 
| read_lines [Lazy_sequence] | 
 | 
| read_msg_and_snapshot [Stats_reporting.Stored_data] | 
 | 
| read_only [Update_queue] | 
 | 
| realtime_priority [Procfs.Process.Limits.Fields] | 
 | 
| realtime_priority [Procfs.Process.Limits] | 
 | 
| red [Color_print] | 
 | 
| redprintf [Color_print] | 
 | 
| reduce [Multi_map] | 
 | 
| reduce [Iter] | 
fold over the iterator: call f on each element and return the accumulator
 
 | 
| reentrant_unit [Memo] | 
 | 
| refcnt [Procfs.Net.Route.Fields] | 
 | 
| refcnt [Procfs.Net.Route] | 
 | 
| release [Sys_utils.Lsb_release.Fields] | 
 | 
| release [Sys_utils.Lsb_release] | 
 | 
| remote [Shell.Process] | 
 | 
| remote_address [Procfs.Net.Tcp.Fields] | 
 | 
| remote_address [Procfs.Net.Tcp] | 
 | 
| remote_port [Procfs.Net.Tcp.Fields] | 
 | 
| remote_port [Procfs.Net.Tcp] | 
 | 
| remove [Trie.S] | 
 | 
| remove [Multi_map] | 
remove m key Remove all the values associated the key key in m
 
 | 
| remove [Fold_map.S2] | 
 | 
| remove [Fold_map.S] | 
 | 
| remove [Hashtbl.Access_control] | 
 | 
| remove [Environment] | 
 | 
| remove [Crit_bit] | 
 | 
| remove [Cache.S] | 
 | 
| remove [Cache.Store] | 
remove store key removes the binding for key in store.
 
 | 
| remove [Cache.Strategy] | 
Informs the strategy that an element was removed from the store.
 
 | 
| remove [Cache.Keep_all] | 
 | 
| remove [Cache.Lru] | 
 | 
| remove_one [Hashtbl.Access_control] | 
 | 
| render [Text_block] | 
 | 
| render_as_regexp [Trie.S] | 
 | 
| replace [Hashtbl.Access_control] | 
 | 
| replace [Cache.Store] | 
replace store ~key ~data associated the data to key; remove any
      previously existing binding.
 
 | 
| replace_left [String_zipper] | 
 | 
| replace_left [List_zipper] | 
 | 
| replace_right [String_zipper] | 
 | 
| replace_right [List_zipper] | 
 | 
| report_on_exn [Fd_leak_check] | 
 | 
| report_open_files [Fd_leak_check] | 
report_open_files () prints a dump of open file descriptors to stderr
    in two formats, one using the proc file system, the other by executing
    /usr/sbin/lsof in a child process.
 
 | 
| required [Deprecated_fcommand] | 
 | 
| required [Deprecated_command.Annotated_field] | 
 | 
| reset [Linebuf] | 
reopens the file and seeks to the beginning.
 
 | 
| resident [Procfs.Process.Statm.Fields] | 
 | 
| resident [Procfs.Process.Statm] | 
 | 
| resident_mem_use_in_kb [Sys_utils.Cpu_use] | 
 | 
| resident_set [Procfs.Process.Limits.Fields] | 
 | 
| resident_set [Procfs.Process.Limits] | 
 | 
| rest [Procfs.Net.Tcp.Fields] | 
 | 
| rest [Procfs.Net.Tcp] | 
 | 
| rest [Deprecated_command.Flag.Action] | 
rest f: an action for a flag that signals the end of flag
        processing.
 
 | 
| rest_acc [Deprecated_command.Flag] | 
 | 
| rest_mut [Deprecated_command.Flag] | 
 | 
| restart [Service_command] | 
 | 
| retrnsmt [Procfs.Net.Tcp.Fields] | 
 | 
| retrnsmt [Procfs.Net.Tcp] | 
 | 
| rgb [Color_print] | 
 | 
| rgbprintf [Color_print] | 
 | 
| right_contents [String_zipper] | 
 | 
| rlim [Procfs.Process.Stat.Fields] | 
 | 
| rlim [Procfs.Process.Stat] | 
 | 
| rm [Shell] | 
 | 
| root [Procfs.Process.Fields] | 
 | 
| root [Procfs.Process] | 
 | 
| rpad [Printc] | 
 | 
| rss [Procfs.Process.Stat.Fields] | 
 | 
| rss [Procfs.Process.Stat] | 
 | 
| rt_priority [Procfs.Process.Stat.Fields] | 
 | 
| rt_priority [Procfs.Process.Stat] | 
 | 
| run [Timed_function] | 
Runs a function in a fork process to ensure a timeout.
 
 | 
| run [Shell.Process] | 
 | 
| run [Shell] | 
Runs a command and discards its output.
 
 | 
| run [Process] | 
 | 
| run [Deprecated_command] | 
 | 
| run_check_at_exit [Fd_leak_check] | 
Toggle to turn on/off checking for descriptor leaks at exit (default: off)
 
 | 
| run_fold [Shell] | 
Fold over the lines in the stdout of a process;
    The `Continue/`Stop argument is there to allow early returning.
 
 | 
| run_full [Shell] | 
Return the full command's output in one string.
 
 | 
| run_k [Shell.Process] | 
 | 
| run_lines [Shell] | 
Runs a command and returns its output line separated.
 
 | 
| run_main [Extended_common] | 
 | 
| run_one [Shell] | 
Returns the first line of the command's output.
 
 | 
| run_one_exn [Shell] | 
 | 
| rx_bytes [Procfs.Net.Dev.Fields] | 
 | 
| rx_bytes [Procfs.Net.Dev] | 
 | 
| rx_compressed [Procfs.Net.Dev.Fields] | 
 | 
| rx_compressed [Procfs.Net.Dev] | 
 | 
| rx_drop [Procfs.Net.Dev.Fields] | 
 | 
| rx_drop [Procfs.Net.Dev] | 
 | 
| rx_errs [Procfs.Net.Dev.Fields] | 
 | 
| rx_errs [Procfs.Net.Dev] | 
 | 
| rx_fifo [Procfs.Net.Dev.Fields] | 
 | 
| rx_fifo [Procfs.Net.Dev] | 
 | 
| rx_frame [Procfs.Net.Dev.Fields] | 
 | 
| rx_frame [Procfs.Net.Dev] | 
 | 
| rx_multicast [Procfs.Net.Dev.Fields] | 
 | 
| rx_multicast [Procfs.Net.Dev] | 
 | 
| rx_packets [Procfs.Net.Dev.Fields] | 
 | 
| rx_packets [Procfs.Net.Dev] | 
 | 
| rx_queue [Procfs.Net.Tcp.Fields] | 
 | 
| rx_queue [Procfs.Net.Tcp] | 
 | 
 S | 
| safe_create [Thread] | 
Behaves like Thread.create but exits the program if an exception trickles
    to the toplevel.
 
 | 
| sample [Sampler] | 
randomly sample the distribution in constant time
 
 | 
| sandwich [Splay_tree.S] | 
 | 
| save [Bin_io_utils] | 
 | 
| scp [Shell] | 
scp user host from to copy local file from to to
 
 | 
| scroll_lock [Sys] | 
scroll_lock false disables scroll locking.
 
 | 
| segfault_me_now [Low_level_debug] | 
 | 
| select [Random_selection] | 
randomly select a subset of size sample_size from a stream of unknown length.
 
 | 
| select [Alternating_primary_backup_assignment] | 
 | 
| send [Sendmail] | 
 | 
| session [Procfs.Process.Stat.Fields] | 
 | 
| session [Procfs.Process.Stat] | 
 | 
| set [Stats_reporting.Delta] | 
 | 
| set [Splay_tree.S] | 
 | 
| set [Multi_map] | 
 | 
| set [Fold_map.S2] | 
 | 
| set [Fold_map.S] | 
 | 
| set [Unix.Quota] | 
 | 
| set [Hashtbl.Access_control] | 
 | 
| set [Array.Access_control] | 
 | 
| set [Deprecated_command.Annotated_field] | 
 | 
| set [Deprecated_command.Flag] | 
 | 
| set [Cbuffer] | 
 | 
| set [Bitarray] | 
set t pos set the value in position pos, raises Invalid_argument if the position
    is out of bounds.
 
 | 
| set_date [Deprecated_command.Flag] | 
 | 
| set_date_opt [Deprecated_command.Flag] | 
 | 
| set_defaults [Shell.Process] | 
 | 
| set_diff [List] | 
set_diff l1 l2 returns a list of all elements of l1 that are not in l2
 
 | 
| set_float [Stats_reporting.Delta] | 
 | 
| set_float [Deprecated_command.Flag] | 
 | 
| set_float_opt [Deprecated_command.Flag] | 
 | 
| set_gen [Deprecated_command.Flag] | 
 | 
| set_gen_opt [Deprecated_command.Flag] | 
 | 
| set_in_channel_timeout [Net_utils] | 
Set a timeout for a socket associated with an in_channel
 
 | 
| set_int [Deprecated_command.Flag] | 
 | 
| set_int_opt [Deprecated_command.Flag] | 
 | 
| set_inter [List] | 
set_inter l1 l2 returns a list without duplicates of all elements of l1 that are in l2
 
 | 
| set_lev [Loggers.LOGGER] | 
Set minimum log level
 
 | 
| set_out_channel_timeout [Net_utils] | 
Set a timeout for a socket associated with an out_channel
 
 | 
| set_string [Deprecated_command.Flag] | 
 | 
| set_string_opt [Deprecated_command.Flag] | 
 | 
| seteuid [Unix] | 
 | 
| setlogmask [Syslog] | 
setlogmask ?levs ?from_lev ?to_lev () sets the log mask.
 
 | 
| setresuid [Extended_linux] | 
 | 
| setreuid [Unix] | 
 | 
| sexp [Deprecated_fcommand] | 
 | 
| sexp_of_any [Array.Access_control] | 
 | 
| sexp_of_bigint [Procfs] | 
 | 
| sexp_of_bytes [Unix.Quota] | 
 | 
| sexp_of_color [Color_print] | 
 | 
| sexp_of_cpu_t [Procfs.Kstat] | 
 | 
| sexp_of_elt [Packed_array.Basic] | 
 | 
| sexp_of_fd_stat [Procfs.Process.Fd] | 
 | 
| sexp_of_field [Stats_reporting] | 
 | 
| sexp_of_flag [Extended_linux.Splice] | 
 | 
| sexp_of_index_t [Procfs.Kstat] | 
 | 
| sexp_of_inodes [Unix.Quota] | 
 | 
| sexp_of_key [Packed_map.S] | 
 | 
| sexp_of_limit [Unix.Quota] | 
 | 
| sexp_of_mallinfo [Malloc] | 
 | 
| sexp_of_name [Stats_reporting.Stored_data] | 
 | 
| sexp_of_opt [Malloc] | 
???
 
 | 
| sexp_of_statvfs [Unix] | 
 | 
| sexp_of_t [Trie.Key.Part] | 
 | 
| sexp_of_t [Sys_utils.Lsb_release] | 
 | 
| sexp_of_t [Stats_reporting.Stored_data] | 
 | 
| sexp_of_t [Selector.Stable.String_list_selector.V1] | 
 | 
| sexp_of_t [Selector.Stable.String_selector.V1] | 
 | 
| sexp_of_t [Selector.Stable.String_selector.Regexp.V1] | 
 | 
| sexp_of_t [Selector.Stable.Date_selector.V1] | 
 | 
| sexp_of_t [Selector.String_list_selector] | 
 | 
| sexp_of_t [Selector.String_selector.Regexp] | 
 | 
| sexp_of_t [Selector.String_selector] | 
 | 
| sexp_of_t [Selector.Date_selector] | 
 | 
| sexp_of_t [Prod_or_test] | 
 | 
| sexp_of_t [Procfs.Meminfo] | 
 | 
| sexp_of_t [Procfs.Process.Fd] | 
 | 
| sexp_of_t [Procfs.Process.Status] | 
 | 
| sexp_of_t [Procfs.Process.Statm] | 
 | 
| sexp_of_t [Procfs.Process.Stat] | 
 | 
| sexp_of_t [Procfs.Process.Limits.Rlimit] | 
 | 
| sexp_of_t [Procfs.Process.Limits] | 
 | 
| sexp_of_t [Procfs.Process.Inode] | 
 | 
| sexp_of_t [Procfs.Process] | 
 | 
| sexp_of_t [Process.Status] | 
 | 
| sexp_of_t [Patience_diff.Range] | 
ranges_all_same ranges returns true if all ranges are Same
 
 | 
| sexp_of_t [Packed_map.Value] | 
 | 
| sexp_of_t [Packed_map.Key] | 
 | 
| sexp_of_t [Packed_map.S] | 
 | 
| sexp_of_t [Unix.Mount_entry] | 
 | 
| sexp_of_t [Unix.Mac_address] | 
 | 
| sexp_of_t [Unix.Inet_port] | 
 | 
| sexp_of_t [Sexp.Comprehension] | 
 | 
| sexp_of_t [Sexp.Make_explicit_sexp_option] | 
 | 
| sexp_of_t [Result.Exn] | 
 | 
| sexp_of_t [Int64.Filesize] | 
 | 
| sexp_of_t [Cbuffer] | 
 | 
| sexp_of_type_desc [Stats_reporting.Stored_data] | 
 | 
| sexp_of_uids [Extended_linux] | 
 | 
| sexp_of_value [Procfs.Process.Limits.Rlimit] | 
 | 
| sexp_of_value [Packed_map.S] | 
 | 
| sgid [Procfs.Process.Status.Fields] | 
 | 
| sgid [Procfs.Process.Status] | 
 | 
| sh [Shell] | 
 | 
| sh_full [Shell] | 
 | 
| sh_lines [Shell] | 
 | 
| sh_one [Shell] | 
 | 
| sh_one_exn [Shell] | 
 | 
| sh_test [Shell] | 
 | 
| share [Procfs.Process.Statm.Fields] | 
 | 
| share [Procfs.Process.Statm] | 
 | 
| shell [Shell.Process] | 
 | 
| shrink [Cbuffer] | 
half the size of the buffer
 
 | 
| sigcatch [Procfs.Process.Stat.Fields] | 
 | 
| sigcatch [Procfs.Process.Stat] | 
 | 
| sigignore [Procfs.Process.Stat.Fields] | 
 | 
| sigignore [Procfs.Process.Stat] | 
 | 
| signal [Semaphore] | 
signal sem v allows one thread blocked in  Semaphore.wait on
    semaphore  sem to continue.
  
 | 
| signal [Procfs.Process.Stat.Fields] | 
 | 
| signal [Procfs.Process.Stat] | 
 | 
| singleton [Multi_map] | 
 | 
| singleton [Fold_map.S2] | 
 | 
| singleton [Fold_map.S] | 
 | 
| size [Procfs.Process.Statm.Fields] | 
 | 
| size [Procfs.Process.Statm] | 
 | 
| size [Deprecated_bench.Test] | 
 | 
| sl [Procfs.Net.Tcp.Fields] | 
 | 
| sl [Procfs.Net.Tcp] | 
 | 
| slab [Procfs.Meminfo.Fields] | 
 | 
| slab [Procfs.Meminfo] | 
 | 
| slice [Packed_array.S] | 
 | 
| slot_spec [Service_command.T] | 
 | 
| snoc [Lazy_list] | 
 | 
| soft [Procfs.Process.Limits.Rlimit.Fields] | 
 | 
| soft [Procfs.Process.Limits.Rlimit] | 
 | 
| softirq [Procfs.Kstat.Fields_of_cpu_t] | 
 | 
| softirq [Procfs.Kstat] | 
 | 
| sort [Lazy_list] | 
 | 
| space [Text_block] | 
 | 
| spec [Procfs.Mount.Fields] | 
 | 
| spec [Procfs.Mount] | 
 | 
| splay [Splay_tree.S] | 
 | 
| splay' [Splay_tree.S] | 
 | 
| splice [Extended_linux.Splice] | 
splice ?assume_fd_is_nonblocking ~fd_in ?off_in ~fd_out ?off_out
      ~len flags see man-page for details.
 
 | 
| square [List] | 
Takes a list of `key*`value lists and returns a
   header * table_body body that is obtained by splitting the lists and
   re-oddering the terms (so that they all have the same header).
 
 | 
| square_unique [List] | 
 | 
| squeeze [String] | 
squeeze str reduces all sequences of spaces, newlines, tables, and
 * carriage returns to single spaces.
 
 | 
| ssh [Shell] | 
 | 
| ssh_full [Shell] | 
 | 
| ssh_lines [Shell] | 
 | 
| ssh_one [Shell] | 
 | 
| ssh_one_exn [Shell] | 
 | 
| ssh_test [Shell] | 
 | 
| stack_size [Procfs.Process.Limits.Fields] | 
 | 
| stack_size [Procfs.Process.Limits] | 
 | 
| start [Service_command] | 
 | 
| start [Runtime_blockout_detector] | 
start starts a thread that watches for blockouts where the OCaml
    lock isn't released.
 
 | 
| start_canary_thread [Low_level_debug] | 
A canary thread starts two threads, one in caml and one in C.
 
 | 
| startcode [Procfs.Process.Stat.Fields] | 
 | 
| startcode [Procfs.Process.Stat] | 
 | 
| startstack [Procfs.Process.Stat.Fields] | 
 | 
| startstack [Procfs.Process.Stat] | 
 | 
| starttime [Procfs.Process.Stat.Fields] | 
 | 
| starttime [Procfs.Process.Stat] | 
 | 
| stat [Procfs.Process.Fields] | 
 | 
| stat [Procfs.Process] | 
 | 
| state [Procfs.Net.Tcp.Fields] | 
 | 
| state [Procfs.Net.Tcp] | 
 | 
| state [Procfs.Process.Stat.Fields] | 
 | 
| state [Procfs.Process.Stat] | 
 | 
| statfs [Extended_linux] | 
 | 
| statm [Procfs.Process.Fields] | 
 | 
| statm [Procfs.Process] | 
 | 
| status [Service_command] | 
 | 
| status [Procfs.Process.Fields] | 
 | 
| status [Procfs.Process] | 
 | 
| status_to_string [Shell.Process] | 
 | 
| statvfs [Unix] | 
get file system statistics
 
 | 
| statvfs_of_sexp [Unix] | 
 | 
| steal [Procfs.Kstat.Fields_of_cpu_t] | 
 | 
| steal [Procfs.Kstat] | 
 | 
| step [Readline__input_loop] | 
 | 
| step [Deprecated_fcommand] | 
step allows you to transform the way parameters are applied.
 
 | 
| stime [Procfs.Process.Stat.Fields] | 
 | 
| stime [Procfs.Process.Stat] | 
 | 
| stop [Service_command] | 
 | 
| stop_me_now [Low_level_debug] | 
 | 
| stop_upon_exit [Low_level_debug] | 
 | 
| stop_upon_sigbus [Low_level_debug] | 
 | 
| stop_upon_sigpipe [Low_level_debug] | 
 | 
| stop_upon_sigsegv [Low_level_debug] | 
 | 
| string [Generic] | 
 | 
| string [Deprecated_fcommand] | 
 | 
| string [Deprecated_command.Flag] | 
 | 
| string_acc [Deprecated_command.Flag] | 
 | 
| string_mut [Deprecated_command.Flag] | 
 | 
| string_of_lev [Syslog] | 
string_of_lev lev converts a level lev to a string.
 
 | 
| string_of_sockaddr [Net_utils] | 
Get string from sockaddr
 
 | 
| strptime [Unix] | 
 | 
| sub [Lazy_sequence] | 
 | 
| suid [Procfs.Process.Status.Fields] | 
 | 
| suid [Procfs.Process.Status] | 
 | 
| summarize [Sexp] | 
Returns a smaller sexp by replacing sections with "...".
 
 | 
| supported_filesystems [Procfs] | 
 | 
| swap_array [Cbuffer] | 
swap_array buf len copies the contents of buf to a new array of length
    len and places that new data into the buffer
 
 | 
| swap_cached [Procfs.Meminfo.Fields] | 
 | 
| swap_cached [Procfs.Meminfo] | 
 | 
| swap_free [Procfs.Meminfo.Fields] | 
 | 
| swap_free [Procfs.Meminfo] | 
 | 
| swap_total [Procfs.Meminfo.Fields] | 
 | 
| swap_total [Procfs.Meminfo] | 
 | 
| sys [Procfs.Kstat.Fields_of_cpu_t] | 
 | 
| sys [Procfs.Kstat] | 
 | 
| syslog [Syslog] | 
syslog ?fac ?lev str logs message str using syslog with faculty
    fac at level lev.
 
 | 
| syslogf [Syslog] | 
syslog_printf ?fac ?lev fmt same as  Syslog.syslog, but allows
     printf-style specification of the message using  fmt.
  
 | 
 T | 
| t [Iter] | 
create an iterator from an iterating function
 
 | 
| t2 [Deprecated_fcommand] | 
 | 
| t3 [Deprecated_fcommand] | 
 | 
| t4 [Deprecated_fcommand] | 
 | 
| t_of_sexp [Trie.Key.Part] | 
 | 
| t_of_sexp [Sys_utils.Lsb_release] | 
 | 
| t_of_sexp [Stats_reporting.Stored_data] | 
 | 
| t_of_sexp [Selector.Stable.String_list_selector.V1] | 
 | 
| t_of_sexp [Selector.Stable.String_selector.V1] | 
 | 
| t_of_sexp [Selector.Stable.String_selector.Regexp.V1] | 
 | 
| t_of_sexp [Selector.Stable.Date_selector.V1] | 
 | 
| t_of_sexp [Selector.String_list_selector] | 
 | 
| t_of_sexp [Selector.String_selector.Regexp] | 
 | 
| t_of_sexp [Selector.String_selector] | 
 | 
| t_of_sexp [Selector.Date_selector] | 
 | 
| t_of_sexp [Prod_or_test] | 
 | 
| t_of_sexp [Procfs.Meminfo] | 
 | 
| t_of_sexp [Procfs.Process.Fd] | 
 | 
| t_of_sexp [Procfs.Process.Status] | 
 | 
| t_of_sexp [Procfs.Process.Statm] | 
 | 
| t_of_sexp [Procfs.Process.Stat] | 
 | 
| t_of_sexp [Procfs.Process.Limits.Rlimit] | 
 | 
| t_of_sexp [Procfs.Process.Limits] | 
 | 
| t_of_sexp [Procfs.Process.Inode] | 
 | 
| t_of_sexp [Procfs.Process] | 
 | 
| t_of_sexp [Patience_diff.Range] | 
 | 
| t_of_sexp [Packed_map.Value] | 
 | 
| t_of_sexp [Packed_map.Key] | 
 | 
| t_of_sexp [Packed_map.S] | 
 | 
| t_of_sexp [Unix.Mount_entry] | 
 | 
| t_of_sexp [Unix.Mac_address] | 
 | 
| t_of_sexp [Unix.Inet_port] | 
 | 
| t_of_sexp [Sexp.Comprehension] | 
 | 
| t_of_sexp [Sexp.Make_explicit_sexp_option] | 
 | 
| t_of_sexp [Int64.Filesize] | 
 | 
| t_of_sexp [Cbuffer] | 
 | 
| tail [Linebuf] | 
Seeks to the end of the file and blocks until another line is available -- this new
    line is not returned.
 
 | 
| take [Lazy_sequence] | 
 | 
| task_stats [Procfs.Process.Fields] | 
 | 
| task_stats [Procfs.Process] | 
 | 
| tcp_socket [Net_utils] | 
Create a standard TCP/IP-socket
 
 | 
| tee [Extended_linux.Splice] | 
tee ?assume_fd_is_nonblocking ~fd_in ~fd_out len flags see man-page
      for details.
 
 | 
| ten [Procfs.Loadavg.Fields] | 
 | 
| ten [Procfs.Loadavg] | 
 | 
| test [Shell.Process] | 
 | 
| test [Shell] | 
 | 
| test_k [Shell.Process] | 
 | 
| text [Text_block] | 
 | 
| text [Procfs.Process.Statm.Fields] | 
 | 
| text [Procfs.Process.Statm] | 
 | 
| text [Pp] | 
The text function turns a string into a document.
 
 | 
| timeout [Procfs.Net.Tcp.Fields] | 
 | 
| timeout [Procfs.Net.Tcp] | 
 | 
| timestamp [Logger] | 
Returns a timestamp as a string suitable for log files
 
 | 
| tl [Lazy_sequence] | 
 | 
| tm_when [Procfs.Net.Tcp.Fields] | 
 | 
| tm_when [Procfs.Net.Tcp] | 
 | 
| to_alist [Packed_map.S] | 
 | 
| to_alist [Fold_map.S2] | 
 | 
| to_alist [Fold_map.S] | 
 | 
| to_alist [Hashtbl.Access_control] | 
 | 
| to_array [Packed_array.S] | 
 | 
| to_array [Lazy_list] | 
 | 
| to_array [Iter] | 
iterate a function and collect results to a array
 
 | 
| to_array [Cbuffer] | 
 | 
| to_array_copy [Array.Access_control] | 
 | 
| to_array_opt [Iter] | 
 | 
| to_buffer [Sexp.Diff] | 
 | 
| to_exec_env [Environment] | 
 | 
| to_file [Pp] | 
 | 
| to_flag [Deprecated_command.Annotated_field] | 
 | 
| to_int [Procfs.Net.Tcp_state] | 
 | 
| to_int [Unix.Inet_port] | 
 | 
| to_line [Bin_io_utils] | 
 | 
| to_list [Sys_utils.Lsb_release.Fields] | 
 | 
| to_list [Readline.History] | 
 | 
| to_list [Random_selection] | 
the current selection from values previously seen by t.
 
 | 
| to_list [Procfs.Mount.Fields] | 
 | 
| to_list [Procfs.Net.Tcp.Fields] | 
 | 
| to_list [Procfs.Net.Route.Fields] | 
 | 
| to_list [Procfs.Net.Dev.Fields] | 
 | 
| to_list [Procfs.Loadavg.Fields] | 
 | 
| to_list [Procfs.Kstat.Fields_of_cpu_t] | 
 | 
| to_list [Procfs.Meminfo.Fields] | 
 | 
| to_list [Procfs.Process.Fields] | 
 | 
| to_list [Procfs.Process.Fd.Fields] | 
 | 
| to_list [Procfs.Process.Status.Fields] | 
 | 
| to_list [Procfs.Process.Statm.Fields] | 
 | 
| to_list [Procfs.Process.Stat.Fields] | 
 | 
| to_list [Procfs.Process.Limits.Fields] | 
 | 
| to_list [Procfs.Process.Limits.Rlimit.Fields] | 
 | 
| to_list [Packed_array.S] | 
 | 
| to_list [Lazy_list] | 
 | 
| to_list [Iter] | 
iterate a function and collect results to a list
 
 | 
| to_list [Generic] | 
 | 
| to_list [Find] | 
to_list t returns all of the remaining files in t as a list in the order they
  would have been returned by subsequent calls to next
 
 | 
| to_list_opt [Iter] | 
 | 
| to_map [Fold_map.S2] | 
 | 
| to_map [Fold_map.S] | 
 | 
| to_regexp [Selector.String_selector.Regexp] | 
 | 
| to_rev_list [Lazy_list] | 
 | 
| to_spec [Deprecated_command.Flag] | 
 | 
| to_spec_unit [Deprecated_command.Flag] | 
 | 
| to_spec_units [Deprecated_command.Flag] | 
 | 
| to_string [Shell.Process] | 
 | 
| to_string [Selector.String_selector.Regexp] | 
 | 
| to_string [Procfs.Process.Inode] | 
 | 
| to_string [Process.Status] | 
 | 
| to_string [Pp] | 
 | 
| to_string [Posix_clock] | 
 | 
| to_string [Unix.Mac_address] | 
 | 
| to_string [Unix.Inet_port] | 
 | 
| to_string [Sexp.Diff] | 
 | 
| to_string [Int64.Filesize] | 
 | 
| to_string [Exn] | 
The to_string function is slightly tweaked to avoid escaping the string
content of Failure.
 
 | 
| to_string_cisco [Unix.Mac_address] | 
 | 
| to_string_hum [Time.Extended_span] | 
Convert a time span to a human-readable string, e.g.
 
 | 
| to_string_hum [Float] | 
 | 
| to_string_hum [Exn] | 
This is also an ever so slight variation of to_string target more at user
than developers (Failure s is just printed as s)
 
 | 
| to_string_hum' [Sexp] | 
The ocaml pretty printer (used by sexplib) is a speed daemon  but is,
   sadly enough, produces wrong output (e.g it overflows in places where this
   could have avoided).
 
 | 
| top_command [Procfs.Process.Fields] | 
 | 
| top_command [Procfs.Process] | 
 | 
| touch [Cache.Strategy] | 
Marks an element as "fresh".
 
 | 
| tpgid [Procfs.Process.Stat.Fields] | 
 | 
| tpgid [Procfs.Process.Stat] | 
 | 
| tr [Procfs.Net.Tcp.Fields] | 
 | 
| tr [Procfs.Net.Tcp] | 
 | 
| try_r_lock [Rw_mutex] | 
try_r_lock mtx tries to lock mtx for a reader without blocking.
 
 | 
| try_read [Linebuf] | 
Tries to read a line from the file.
 
 | 
| try_read_lnum [Linebuf] | 
try_read_lnum is like try_read except also provides the line number of the
    read line.
 
 | 
| try_read_lnum_verbose [Linebuf] | 
Like try_read, except that it returns more verbose errors
 
 | 
| try_w_lock [Rw_mutex] | 
try_w_lock mtx tries to lock mtx for a writer without blocking.
 
 | 
| try_wrap_r_lock [Rw_mutex] | 
try_wrap_r_lock mtx f tries to lock mtx for a reader without
    blocking, executes f and unlocks the mutex again.
 
 | 
| try_wrap_w_lock [Rw_mutex] | 
try_wrap_w_lock mtx f tries to lock mtx for a writer without
    blocking, executes f and unlocks the mutex again.
 
 | 
| tty_nr [Procfs.Process.Stat.Fields] | 
 | 
| tty_nr [Procfs.Process.Stat] | 
 | 
| tx_bytes [Procfs.Net.Dev.Fields] | 
 | 
| tx_bytes [Procfs.Net.Dev] | 
 | 
| tx_carrier [Procfs.Net.Dev.Fields] | 
 | 
| tx_carrier [Procfs.Net.Dev] | 
 | 
| tx_colls [Procfs.Net.Dev.Fields] | 
 | 
| tx_colls [Procfs.Net.Dev] | 
 | 
| tx_compressed [Procfs.Net.Dev.Fields] | 
 | 
| tx_compressed [Procfs.Net.Dev] | 
 | 
| tx_drop [Procfs.Net.Dev.Fields] | 
 | 
| tx_drop [Procfs.Net.Dev] | 
 | 
| tx_errs [Procfs.Net.Dev.Fields] | 
 | 
| tx_errs [Procfs.Net.Dev] | 
 | 
| tx_fifo [Procfs.Net.Dev.Fields] | 
 | 
| tx_fifo [Procfs.Net.Dev] | 
 | 
| tx_packets [Procfs.Net.Dev.Fields] | 
 | 
| tx_packets [Procfs.Net.Dev] | 
 | 
| tx_queue [Procfs.Net.Tcp.Fields] | 
 | 
| tx_queue [Procfs.Net.Tcp] | 
 | 
| type_desc_of_sexp [Stats_reporting.Stored_data] | 
 | 
 U | 
| uid [Procfs.Net.Tcp.Fields] | 
 | 
| uid [Procfs.Net.Tcp] | 
 | 
| uid [Procfs.Process.Status.Fields] | 
 | 
| uid [Procfs.Process.Status] | 
 | 
| uids_of_sexp [Extended_linux] | 
 | 
| underline [Color_print] | 
 | 
| underlineprintf [Color_print] | 
 | 
| unescaped [String] | 
unescaped s is the inverse operation of escaped: it takes a string where
   all the special characters are escaped following the lexical convention of
   OCaml and returns an unescaped copy.
 
 | 
| unescaped_res [String] | 
Same as unescaped but instead of raising Failure _ returns an error
   message with the position in the string in case of failure.
 
 | 
| unfold [Lazy_list] | 
 | 
| unfold [Iter] | 
 | 
| unified [Patience_diff] | 
unified hunks converts all Replace ranges in hunks to an Old range
    followed by a New range.
 
 | 
| unify [Lazy_list] | 
 | 
| unit [Cache] | 
Returns memoized version of any function with argument unit.
 
 | 
| uniter [Lazy_list] | 
 | 
| unsafe_get [Packed_array.Basic] | 
 | 
| unsafe_slice [Packed_array.Basic] | 
 | 
| unsafe_tail [Linebuf] | 
Same as tail except it may return before a new line is available on the file
    i.e.
 
 | 
| unused [Procfs.Process.Stat.Fields] | 
 | 
| unused [Procfs.Process.Stat] | 
 | 
| unwrap [Exn] | 
unwrap e
 
 | 
| unzip [Packed_array.Tuple2] | 
 | 
| update_exn [Sys_utils.Cpu_use] | 
update_exn updates a Cpu_use.t.
 
 | 
| upper [Number.Verified_std.Bounded_spec] | 
 | 
| uptime [Procfs] | 
 | 
| use [Procfs.Net.Route.Fields] | 
 | 
| use [Procfs.Net.Route] | 
 | 
| user [Procfs.Kstat.Fields_of_cpu_t] | 
 | 
| user [Procfs.Kstat] | 
 | 
| utime [Procfs.Process.Stat.Fields] | 
 | 
| utime [Procfs.Process.Stat] | 
 | 
 V | 
| valign [Text_block] | 
 | 
| value_of_sexp [Procfs.Process.Limits.Rlimit] | 
 | 
| value_of_sexp [Packed_map.S] | 
 | 
| value_raise [Extended_option] | 
 | 
| vcat [Text_block] | 
 | 
| verify [Number.S] | 
 | 
| vfstype [Procfs.Mount.Fields] | 
 | 
| vfstype [Procfs.Mount] | 
 | 
| vgrp [Pp] | 
The vgrp operator creates a vertical group.
 
 | 
| visible_filesystem [Unix.Mount_entry] | 
 | 
| vlist [Pp] | 
 vlist [x1,..,xn] = vgrp [x1; break; x2; ...; break; xn)  
 
 | 
| vmalloc_chunk [Procfs.Meminfo.Fields] | 
 | 
| vmalloc_chunk [Procfs.Meminfo] | 
 | 
| vmalloc_total [Procfs.Meminfo.Fields] | 
 | 
| vmalloc_total [Procfs.Meminfo] | 
 | 
| vmalloc_used [Procfs.Meminfo.Fields] | 
 | 
| vmalloc_used [Procfs.Meminfo] | 
 | 
| vmsplice [Extended_linux.Splice] | 
 | 
| vsize [Procfs.Process.Stat.Fields] | 
 | 
| vsize [Procfs.Process.Stat] | 
 | 
| vstrut [Text_block] | 
 | 
 W | 
| w_lock [Rw_mutex] | 
w_lock mtx locks mtx for a writer.
 
 | 
| w_pref [Rw_mutex] | 
w_pref preference kind for writers.
 
 | 
| w_unlock [Rw_mutex] | 
w_unlock mtx unlocks mtx for a writer.
 
 | 
| wait [Semaphore] | 
wait sem blocks the calling thread on semaphore sem if it was not
    initialized with Some x or not signalled before.
 
 | 
| warning [Loggers.LOGGER] | 
 | 
| watch [Update_queue] | 
watch t f will call f every time that that t's state is updated.
 
 | 
| wchan [Procfs.Process.Stat.Fields] | 
 | 
| wchan [Procfs.Process.Stat] | 
 | 
| which [Shell__core] | 
 | 
| which [Shell] | 
 | 
| whoami [Shell__core] | 
 | 
| whoami [Shell] | 
Get the username.
 
 | 
| width [Text_block] | 
 | 
| window [Procfs.Net.Route.Fields] | 
 | 
| window [Procfs.Net.Route] | 
 | 
| with_connection [Tcp] | 
 | 
| with_open_temp_file [Filename] | 
with_open_temp_file ~write ~f prefix suffix create a temporary file; runs write on
    its out_channel and then f on the resulting file.
 
 | 
| with_pid [Procfs] | 
with_pid pid returns a single process that matches pid
 
 | 
| with_pid_exn [Procfs] | 
with_pid_exn pid returns a single process that matches pid, or raises Not_found
 
 | 
| with_sequence [Lazy_sequence.Iterator] | 
 | 
| with_temp_dir [Filename] | 
Runs f with a temporary dir as option and removes the directory afterwards.
 
 | 
| with_tmp [Sys_utils] | 
with_tmp pre suf f creates a temp file, calls f with the file name, and removes the
    file afterwards.
 
 | 
| with_uid [Procfs] | 
with_uid uid returns all processes owned by uid
 
 | 
| with_username [Procfs] | 
with_username user calls with_uid after looking up the user's uid
 
 | 
| with_username_exn [Procfs] | 
with_username_exn user calls with_uid after looking up the user's uid
 
 | 
| without_compactions [Gc] | 
without_compactions f a will call f a so that Gc.compact is never called
    during its execution, then restore compactions to the previous setting.
 
 | 
| word_wrap [String] | 
word_wrap ~soft_limit s
 
 | 
| wrap_block_signals [Unix_utils] | 
wrap_block_signals f blocks all signals before execution of f, and
    restores them afterwards.
 
 | 
| wrap_r_lock [Rw_mutex] | 
wrap_r_lock mtx f locks mtx for a reader, executes f and
    unlocks the mutex again.
 
 | 
| wrap_w_lock [Rw_mutex] | 
wrap_w_lock mtx f locks mtx for a writer, executes f and
    unlocks the mutex again.
 
 | 
| write_wrap [Extended_common] | 
write_wrap ~atomic ~f fname Runs f on an out_channel.
 
 | 
| writeback [Procfs.Meminfo.Fields] | 
 | 
| writeback [Procfs.Meminfo] | 
 | 
 Y | 
| yellow [Color_print] | 
 | 
| yellowprintf [Color_print] | 
 | 
 Z | 
| zero [Number.Verified_std_spec] | 
 | 
| zero [Number.S0] | 
 | 
| zero [Deprecated_fcommand] | 
 | 
| zip_exn [Packed_array.Tuple2] | 
 | 
| zip_full [Lazy_sequence] | 
 |