|
| ($) [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] |
|