| 
| ($) [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] | 
 | 
| (>>=!) [Or_exn.Infix] | 
 | 
| (>>=?) [Or_exn.Infix] | 
 | 
| (>>|!) [Or_exn.Infix] | 
The two following operators raise in case of Error
 
 | 
| (>>|) [Generic] | 
 | 
| (>>|?) [Or_exn.Infix] | 
 | 
| (~%) [Printc] | 
alias for sprintf
 
 | 
| (~:) [Printc] | 
alias for String.concat
 
 | 
| __ [Generic] | 
 | 
 A | 
| 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_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] | 
 | 
| 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] | 
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] | 
 | 
| app [Fn.Abstract] | 
 | 
| 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.
 
 | 
| bell [Console.Ansi] | 
 | 
| bench [Bench] | 
 | 
| bench_raw [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_flag [Extended_linux.Splice] | 
 | 
| bin_mallinfo [Malloc] | 
 | 
| bin_opt [Malloc] | 
Malloc options
 
 | 
| bin_read_any [Array.Access_control] | 
 | 
| bin_read_any_ [Array.Access_control] | 
 | 
| bin_read_any__ [Array.Access_control] | 
 | 
| bin_read_color [Color_print] | 
 | 
| bin_read_color_ [Color_print] | 
 | 
| bin_read_color__ [Color_print] | 
 | 
| bin_read_flag [Extended_linux.Splice] | 
 | 
| bin_read_flag_ [Extended_linux.Splice] | 
 | 
| bin_read_flag__ [Extended_linux.Splice] | 
 | 
| bin_read_mallinfo [Malloc] | 
 | 
| bin_read_mallinfo_ [Malloc] | 
 | 
| bin_read_mallinfo__ [Malloc] | 
 | 
| bin_read_opt [Malloc] | 
 | 
| bin_read_opt_ [Malloc] | 
 | 
| bin_read_opt__ [Malloc] | 
 | 
| bin_read_statvfs [Unix] | 
 | 
| bin_read_statvfs_ [Unix] | 
 | 
| bin_read_statvfs__ [Unix] | 
 | 
| 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 [Int64.Filesize] | 
 | 
| 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_ [Int64.Filesize] | 
 | 
| 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__ [Int64.Filesize] | 
 | 
| bin_read_uids [Extended_linux] | 
 | 
| bin_read_uids_ [Extended_linux] | 
 | 
| bin_read_uids__ [Extended_linux] | 
 | 
| bin_reader_any [Array.Access_control] | 
 | 
| bin_reader_color [Color_print] | 
 | 
| bin_reader_flag [Extended_linux.Splice] | 
 | 
| bin_reader_mallinfo [Malloc] | 
 | 
| bin_reader_opt [Malloc] | 
 | 
| bin_reader_statvfs [Unix] | 
 | 
| 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 [Int64.Filesize] | 
 | 
| bin_reader_uids [Extended_linux] | 
 | 
| bin_size_any [Array.Access_control] | 
 | 
| bin_size_color [Color_print] | 
 | 
| bin_size_flag [Extended_linux.Splice] | 
 | 
| bin_size_mallinfo [Malloc] | 
 | 
| bin_size_opt [Malloc] | 
 | 
| bin_size_statvfs [Unix] | 
 | 
| 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 [Int64.Filesize] | 
 | 
| bin_size_uids [Extended_linux] | 
 | 
| bin_statvfs [Unix] | 
 | 
| bin_t [Selector.String_list_selector] | 
 | 
| bin_t [Selector.String_selector.Regexp] | 
 | 
| bin_t [Selector.String_selector] | 
 | 
| bin_t [Selector.Date_selector] | 
 | 
| bin_t [Int64.Filesize] | 
 | 
| bin_uids [Extended_linux] | 
 | 
| bin_write_any [Array.Access_control] | 
 | 
| bin_write_any_ [Array.Access_control] | 
 | 
| bin_write_color [Color_print] | 
 | 
| bin_write_color_ [Color_print] | 
 | 
| bin_write_flag [Extended_linux.Splice] | 
 | 
| bin_write_flag_ [Extended_linux.Splice] | 
 | 
| bin_write_mallinfo [Malloc] | 
 | 
| bin_write_mallinfo_ [Malloc] | 
 | 
| bin_write_opt [Malloc] | 
 | 
| bin_write_opt_ [Malloc] | 
 | 
| bin_write_statvfs [Unix] | 
 | 
| bin_write_statvfs_ [Unix] | 
 | 
| 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 [Int64.Filesize] | 
 | 
| 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_ [Int64.Filesize] | 
 | 
| bin_write_uids [Extended_linux] | 
 | 
| bin_write_uids_ [Extended_linux] | 
 | 
| bin_writer_any [Array.Access_control] | 
 | 
| bin_writer_color [Color_print] | 
 | 
| bin_writer_flag [Extended_linux.Splice] | 
 | 
| bin_writer_mallinfo [Malloc] | 
 | 
| bin_writer_opt [Malloc] | 
 | 
| bin_writer_statvfs [Unix] | 
 | 
| 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 [Int64.Filesize] | 
 | 
| bin_writer_uids [Extended_linux] | 
 | 
| blank [Ascii_table.Display] | 
 | 
| blit [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] | 
 | 
| buffers [Procfs.Meminfo.Fields] | 
 | 
| buffers [Procfs.Meminfo] | 
 | 
| build [Lazy_list] | 
 | 
 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
 
 | 
| center [Ascii_table.Align] | 
 | 
| 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] | 
 | 
| 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] | 
 | 
| 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 is usaully more suited
   for human consumption by treating ints specificaly:
   (e.g.
 
 | 
| color [Color_print] | 
 | 
| color_of_sexp [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.
 
 | 
| 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 [Bench.Result] | 
 | 
| compare [Trie.Key.Part] | 
 | 
| compare [List] | 
 | 
| compare [Filename] | 
Filename.compare is a comparaison that normalizes filenames ("./a" = "a") use
   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.
 
 | 
| 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] | 
 | 
| consolidate_strings [String] | 
Consolidates a list of strings (almost ^) losslessly.
 
 | 
| consolidate_strings' [String] | 
Consolidates a list of strings in such a way that the result does not exceed the given
    length.
 
 | 
| const [Deprecated_fcommand] | 
 | 
| contains [Trie.S] | 
 | 
| content [Shell.Process] | 
 | 
| contents [String_zipper] | 
 | 
| contents [Readline__input_loop] | 
 | 
| 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_time [Procfs.Process.Limits.Fields] | 
 | 
| cpu_time [Procfs.Process.Limits] | 
 | 
| cpu_use [Sys_utils.Cpu_use] | 
 | 
| create [Uuid] | 
 | 
| create [Update_queue] | 
 | 
| create [Trie.S] | 
 | 
| create [Sys_utils.Lsb_release.Fields] | 
 | 
| create [String_zipper] | 
 | 
| 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.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 [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)
 
 | 
| create [Bench.Test] | 
 | 
| create [Ascii_table.Column] | 
creates a column given the header and the to-string function
 
 | 
| create0 [Deprecated_command] | 
 | 
| create_attr [Ascii_table.Column] | 
like create, except that the to_string function must provide a list of
      attributes.
 
 | 
| 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_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] | 
 | 
| 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] | 
 | 
| 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_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] | 
 | 
 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] | 
 | 
| emerg [Loggers.LOGGER] | 
 | 
| empty [Pp] | 
The empty document is pretty printed to the empty string.
 
 | 
| empty [Multi_map] | 
 | 
| 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 [Crit_bit] | 
 | 
| empty [Bench.Result.Stat] | 
 | 
| 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] | 
 | 
| eprintf [Console.Ansi] | 
 | 
| eprintl [Printc] | 
 | 
| 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.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 in a list of strings.
 
 | 
| extra_path [Shell__core] | 
 | 
| extra_path [Shell] | 
variable used by dispatch command to find binaries not in the path.
 
 | 
 F | 
| f [Fold_map.Foldable2] | 
 | 
| f [Fold_map.Foldable] | 
The folding function.
 
 | 
| f2s [Printc] | 
 | 
| failwith [Or_exn] | 
 | 
| 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 [Procfs.Process.Fields] | 
 | 
| fds [Procfs.Process] | 
 | 
| fgrp [Pp] | 
The break policy inside an agrp is fixed for all breaks of the group.
 
 | 
| 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 [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 [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 [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] | 
 | 
| fn [Fn.Abstract] | 
 | 
| fold [Sys_utils.Lsb_release.Fields.Direct] | 
 | 
| fold [Sys_utils.Lsb_release.Fields] | 
 | 
| 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.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 [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 [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.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_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] | 
 | 
| fsgid [Procfs.Process.Status.Fields] | 
 | 
| fsgid [Procfs.Process.Status] | 
 | 
| fsuid [Procfs.Process.Status.Fields] | 
 | 
| fsuid [Procfs.Process.Status] | 
 | 
 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] | 
update_exn updates a Cpu_use.t.
 
 | 
| get [Semaphore] | 
get sem
 
 | 
| get [Readline__input_char] | 
 | 
| 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
 
 | 
 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
 
 | 
| hard [Procfs.Process.Limits.Rlimit.Fields] | 
 | 
| hard [Procfs.Process.Limits.Rlimit] | 
 | 
| has_next [Lazy_sequence.Iterator] | 
 | 
| hash [Trie.Key.Part] | 
 | 
| head [Shell.Process] | 
 | 
| head_exn [Shell.Process] | 
 | 
| 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
 
 | 
| home_cursor [Console.Ansi] | 
 | 
| hostname [Sys] | 
 | 
| htonl [Unix] | 
Host to network order long, like C.
 
 | 
 I | 
| i [Iter] | 
iterate over the iterator: call f on each element
 
 | 
| i2s [Printc] | 
 | 
| 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] | 
 | 
| inet4_addr_of_int_exn [Unix.Cidr] | 
Some things (like the kernel) report addresses and ports as hex or decimal integers.
 
 | 
| inet_addr_of_sockaddr [Net_utils] | 
Get inet_addr from sockaddr
 
 | 
| inet_addr_to_int_exn [Unix.Cidr] | 
 | 
| info [Loggers.LOGGER] | 
 | 
| init [Update_queue] | 
 | 
| 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] | 
 | 
| 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] | 
 | 
| intersperse [List] | 
intersperse returns a list with the given element placed between every two
  original elements.
 
 | 
| inverse [Color_print] | 
 | 
| inverseprintf [Color_print] | 
 | 
| ip_of_name [Sys_utils] | 
ip_of_name hostname looks up the hostname and prints the IP in dotted-quad
    format.
 
 | 
| 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_color_tty [Console] | 
 | 
| 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_set [Deprecated_command.Flags_ext] | 
 | 
| is_substring [String] | 
is_substring ~substring t returns true if substring is a substring
 * of t.
 
 | 
| 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.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 [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 [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 | 
| 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.
 
 | 
| kill_line [Console.Ansi] | 
 | 
| kstkeip [Procfs.Process.Stat.Fields] | 
 | 
| kstkeip [Procfs.Process.Stat] | 
 | 
| kstkesp [Procfs.Process.Stat.Fields] | 
 | 
| kstkesp [Procfs.Process.Stat] | 
 | 
 L | 
| last [String_zipper] | 
 | 
| 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 [Ascii_table.Align] | 
 | 
| left_contents [String_zipper] | 
 | 
| 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] | 
 | 
| limits [Procfs.Process.Fields] | 
 | 
| limits [Procfs.Process] | 
 | 
| line [Ascii_table.Display] | 
 | 
| 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_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] | 
 | 
| 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 in 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.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.
 
 | 
| 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.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_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.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 [Hashtbl.Access_control] | 
 | 
| mapi [Array.Access_control] | 
 | 
| mapped [Procfs.Meminfo.Fields] | 
 | 
| mapped [Procfs.Meminfo] | 
 | 
| mask [Procfs.Net.Route.Fields] | 
 | 
| mask [Procfs.Net.Route] | 
 | 
| match_ [Unix.Cidr] | 
Is the given address inside the given Cidr.t? Note that the broadcast and network
  addresses are considered valid so match_ 10.0.0.0/8 10.0.0.0  is true.
 
 | 
| match_ [Documented_match_statement] | 
match_ t pulls out the underlying function of t
 
 | 
| match_exn [Unix.Cidr] | 
 | 
| matches [Selector.String_selector.Regexp] | 
 | 
| max [List] | 
 | 
| max [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 [Bench.Result] | 
 | 
| mean_gettime_cost [Posix_clock] | 
 | 
| 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 [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 [Bench.Test] | 
 | 
| 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.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] | 
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.Process.Stat.Fields] | 
 | 
| nice [Procfs.Process.Stat] | 
 | 
| nice_priority [Procfs.Process.Limits.Fields] | 
 | 
| nice_priority [Procfs.Process.Limits] | 
 | 
| 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_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_arg [Deprecated_command.Flag] | 
 | 
| 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 [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 [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 [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_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_string [Procfs.Net.Dev] | 
 | 
| of_string [Procfs.Process.Inode] | 
 | 
| of_string [Unix.Mac_address] | 
 | 
| of_string [Unix.Inet_port] | 
 | 
| of_string [Unix.Cidr] | 
Generate a Cidr.t based on a string like "10.0.0.0/8".
 
 | 
| of_string [Int64.Filesize] | 
 | 
| of_string_exn [Unix.Inet_port] | 
 | 
| of_string_exn [Unix.Cidr] | 
 | 
| 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] | 
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] | 
 | 
| 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.
 
 | 
| ounit_tests [Uuid] | 
 | 
| ounit_tests [Update_queue] | 
 | 
| ounit_tests [Unix_utils] | 
 | 
| ounit_tests [Trie] | 
 | 
| ounit_tests [Tcp] | 
 | 
| ounit_tests [Sys_utils] | 
 | 
| ounit_tests [Syslog] | 
Print to stderr as well
 
 | 
| ounit_tests [String_zipper] | 
 | 
| ounit_tests [Timed_function] | 
 | 
| ounit_tests [Std] | 
 | 
| ounit_tests [Sntp] | 
 | 
| ounit_tests [Shell__line_buffer] | 
 | 
| ounit_tests [Shell__core] | 
 | 
| ounit_tests [Shell] | 
 | 
| ounit_tests [Service_command] | 
 | 
| ounit_tests [Sendmail] | 
 | 
| ounit_tests [Semaphore] | 
 | 
| ounit_tests [Selector] | 
 | 
| ounit_tests [Search_foo] | 
 | 
| ounit_tests [Sampler] | 
 | 
| ounit_tests [Rw_mutex] | 
 | 
| ounit_tests [Runtime_blockout_detector] | 
 | 
| ounit_tests [Readline__input_loop] | 
 | 
| ounit_tests [Readline__input_char] | 
 | 
| ounit_tests [Readline] | 
 | 
| ounit_tests [Random_selection] | 
 | 
| ounit_tests [Procfs] | 
 | 
| ounit_tests [Process] | 
 | 
| ounit_tests [Printc] | 
alias for String.concat
 
 | 
| ounit_tests [Pp] | 
 | 
| ounit_tests [Posix_clock] | 
 | 
| ounit_tests [Patience_diff] | 
 | 
| ounit_tests [Or_exn] | 
 | 
| ounit_tests [Number] | 
 | 
| ounit_tests [Net_utils] | 
 | 
| ounit_tests [Multi_map] | 
 | 
| ounit_tests [Malloc] | 
 | 
| ounit_tests [Low_level_debug] | 
 | 
| ounit_tests [Loggers] | 
 | 
| ounit_tests [Logger] | 
 | 
| ounit_tests [List_zipper] | 
 | 
| ounit_tests [Linebuf] | 
 | 
| ounit_tests [Lazy_sequence] | 
 | 
| ounit_tests [Lazy_m] | 
 | 
| ounit_tests [Lazy_list] | 
 | 
| ounit_tests [Iter] | 
 | 
| ounit_tests [Inline_tests] | 
 | 
| ounit_tests [Generic] | 
 | 
| ounit_tests [Fold_map] | 
 | 
| ounit_tests [Find] | 
 | 
| ounit_tests [Fd_leak_check] | 
 | 
| ounit_tests [Extra_fields] | 
 | 
| ounit_tests [Unix] | 
 | 
| ounit_tests [Time] | 
 | 
| ounit_tests [Thread] | 
 | 
| ounit_tests [Sys] | 
 | 
| ounit_tests [String] | 
 | 
| ounit_tests [Sexp] | 
 | 
| ounit_tests [Result] | 
Extension to the 
 
 | 
| ounit_tests [Nativeint] | 
 | 
| ounit_tests [Extended_monad] | 
 | 
| ounit_tests [Memo] | 
 | 
| ounit_tests [Extended_list__multimerge] | 
 | 
| ounit_tests [Extended_list__LCS] | 
 | 
| ounit_tests [List] | 
 | 
| ounit_tests [Extended_linux] | 
 | 
| ounit_tests [Int64] | 
 | 
| ounit_tests [Int63] | 
 | 
| ounit_tests [Int32] | 
 | 
| ounit_tests [Int] | 
 | 
| ounit_tests [Hashtbl] | 
 | 
| ounit_tests [Gc] | 
 | 
| ounit_tests [Fn] | 
 | 
| ounit_tests [Float] | 
 | 
| ounit_tests [Filename] | 
normalize path
   Removes as much "." and ".." from the path as possible.
 
 | 
| ounit_tests [Exn] | 
 | 
| ounit_tests [Extended_common] | 
 | 
| ounit_tests [Array] | 
 | 
| ounit_tests [Exception_check] | 
 | 
| ounit_tests [Environment] | 
 | 
| ounit_tests [English] | 
 | 
| ounit_tests [Documented_match_statement] | 
 | 
| ounit_tests [Deprecated_service_command] | 
 | 
| ounit_tests [Deprecated_fcommand] | 
 | 
| ounit_tests [Deprecated_command] | 
 | 
| ounit_tests [Csv_writer] | 
 | 
| ounit_tests [Crit_bit] | 
 | 
| ounit_tests [Console] | 
 | 
| ounit_tests [Color_print] | 
 | 
| ounit_tests [Cbuffer] | 
 | 
| ounit_tests [Cache] | 
 | 
| ounit_tests [Bitarray] | 
 | 
| ounit_tests [Bin_io_utils] | 
 | 
| ounit_tests [Bench] | 
 | 
| ounit_tests [Atomic_edit] | 
 | 
| ounit_tests [Ascii_table] | 
 | 
| ounit_tests [Alternating_primary_backup_assignment] | 
 | 
| output [Console.Ansi] | 
 | 
| output [Ascii_table] | 
The idea is that you have a Column.t list and a list of rows, where each
    row contains the data for each column.
 
 | 
| output_lines [Csv_writer] | 
Prints a valid csv file to a given channel (note that line are ended
    "\r\n")
 
 | 
| output_string [Console.Ansi] | 
 | 
 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_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 [Bench] | 
 | 
| print_diff [Sexp] | 
 | 
| print_list [Console] | 
print a list in a columnize way (like the output of ls)
 
 | 
| print_ranges [Patience_diff] | 
 | 
| print_version [Deprecated_command.Version] | 
 | 
| printf [Console.Ansi] | 
 | 
| printl [Printc] | 
 | 
| priority [Procfs.Process.Stat.Fields] | 
 | 
| priority [Procfs.Process.Stat] | 
 | 
| 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.
 
 | 
| 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] | 
 | 
| ratio [Patience_diff] | 
 | 
| rdtsc [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_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
 
 | 
| 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_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_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 [Ascii_table.Align] | 
 | 
| 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 [Inline_tests] | 
 | 
| 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] | 
 | 
| running_byte_code [Sys] | 
running_byte_code ()
 
 | 
| 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
 
 | 
| sample_size [Bench.Result] | 
 | 
| save [Bin_io_utils] | 
 | 
| save_cursor [Console.Ansi] | 
 | 
| scp [Shell] | 
scp user host from to copy local file from to to
 
 | 
| scroll_lock [Sys] | 
scroll_lock false disables scroll locking.
 
 | 
| 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 [Multi_map] | 
 | 
| set [Fold_map.S2] | 
 | 
| set [Fold_map.S] | 
 | 
| 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 [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_color [Color_print] | 
 | 
| sexp_of_fd_stat [Procfs.Process.Fd] | 
 | 
| sexp_of_flag [Extended_linux.Splice] | 
 | 
| sexp_of_mallinfo [Malloc] | 
 | 
| sexp_of_opt [Malloc] | 
 | 
| sexp_of_statvfs [Unix] | 
 | 
| sexp_of_t [Trie.Key.Part] | 
 | 
| sexp_of_t [Sys_utils.Lsb_release] | 
 | 
| 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 [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 [Unix.Mac_address] | 
 | 
| sexp_of_t [Sexp.Make_explicit_sexp_option] | 
 | 
| sexp_of_t [Result.Exn] | 
 | 
| sexp_of_t [Int64.Filesize] | 
 | 
| sexp_of_t [Cbuffer] | 
 | 
| sexp_of_uids [Extended_linux] | 
 | 
| sexp_of_value [Procfs.Process.Limits.Rlimit] | 
 | 
| 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] | 
 | 
| short_box [Ascii_table.Display] | 
 | 
| 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 [Bench.Test] | 
 | 
| sl [Procfs.Net.Tcp.Fields] | 
 | 
| sl [Procfs.Net.Tcp] | 
 | 
| slab [Procfs.Meminfo.Fields] | 
 | 
| slab [Procfs.Meminfo] | 
 | 
| slot_spec [Service_command.T] | 
 | 
| snoc [Lazy_list] | 
 | 
| soft [Procfs.Process.Limits.Rlimit.Fields] | 
 | 
| soft [Procfs.Process.Limits.Rlimit] | 
 | 
| sort [Lazy_list] | 
 | 
| spec [Procfs.Mount.Fields] | 
 | 
| spec [Procfs.Mount] | 
 | 
| splice [Extended_linux.Splice] | 
splice ?assume_fd_is_nonblocking ~fd_in ?off_in ~fd_out ?off_out
      ~len flags see man-page for details.
 
 | 
| split_while [List] | 
split_while xs f splits xs into sublists ys and zs such that ys is
        the longest prefix on which f is true, and zs is the remaining elements.
 
 | 
| 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] | 
 | 
| stdev [Bench.Result] | 
stdev returns stdev of run_times if array has length > 1
 
 | 
| 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 [Lazy_sequence] | 
 | 
| 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
 
 | 
| string_with_attr [Console.Ansi] | 
 | 
| strptime [Unix] | 
 | 
| 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] | 
 | 
| 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 [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 [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 [Unix.Mac_address] | 
 | 
| 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_while [List] | 
take_while xs f produces the longest prefix of xs on which f is always true.
 
 | 
| tall_box [Ascii_table.Display] | 
 | 
| 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] | 
 | 
| tests [Inline_tests] | 
 | 
| 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
 
 | 
| tm_when [Procfs.Net.Tcp.Fields] | 
 | 
| tm_when [Procfs.Net.Tcp] | 
 | 
| to_alist [Fold_map.S2] | 
 | 
| to_alist [Fold_map.S] | 
 | 
| to_alist [Hashtbl.Access_control] | 
 | 
| 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_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.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 [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 [Int64.Filesize] | 
 | 
| to_string [Exn] | 
The to_string function is slightly tweaked to avoid escaping the string
content of Failure.
 
 | 
| to_string [Ascii_table] | 
 | 
| 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).
 
 | 
| to_string_noattr [Ascii_table] | 
 | 
| 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_with [Or_exn] | 
Various use cases:
       Or_exn.try_with ~f x
   Or_exn.try_with () ~f:(fun () ->
   ....
   )
   let f_or_exn = Or_exn.try_with ~f
    
 
 | 
| try_with_bind [Or_exn] | 
 | 
| 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] | 
 | 
 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_tail [Linebuf] | 
Same as tail except it may return before a new line is available on the file
    i.e.
 
 | 
| unsave_cursor [Console.Ansi] | 
 | 
| unused [Procfs.Process.Stat.Fields] | 
 | 
| unused [Procfs.Process.Stat] | 
 | 
| unwrap [Exn] | 
unwrap e
 
 | 
| update_exn [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.
 
 | 
| upper [Number.Verified_std.Bounded_spec] | 
 | 
| uptime [Procfs] | 
 | 
| use [Procfs.Net.Route.Fields] | 
 | 
| use [Procfs.Net.Route] | 
 | 
| utime [Procfs.Process.Stat.Fields] | 
 | 
| utime [Procfs.Process.Stat] | 
 | 
 V | 
| value_of_sexp [Procfs.Process.Limits.Rlimit] | 
 | 
| value_of_sexp__ [Procfs.Process.Limits.Rlimit] | 
 | 
| verify [Number.S] | 
 | 
| vfstype [Procfs.Mount.Fields] | 
 | 
| vfstype [Procfs.Mount] | 
 | 
| vgrp [Pp] | 
The vgrp operator creates a vertical group.
 
 | 
| 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] | 
 | 
 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 [Console] | 
The width in characters of the current output.
 
 | 
| 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_full [Lazy_sequence] | 
 |