|
($) [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] |
|
__pa_ounit_275876e34cf609db118f3d84b799a790 [Std] |
|
__pa_ounit_275876e34cf609db118f3d84b799a790 [Invariant] |
|
__pa_ounit_275876e34cf609db118f3d84b799a790 [Extended_option] |
|
__pa_ounit_275876e34cf609db118f3d84b799a790 [Extended_monad] |
|
A |
active [Procfs.Meminfo.Fields] |
|
active [Procfs.Meminfo] |
|
add [Time_stamp_counter.Cycles] |
|
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_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 [Unix.Cidr] |
|
address_space [Procfs.Process.Limits.Fields] |
|
address_space [Procfs.Process.Limits] |
|
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] |
|
app [Fn.Abstract] |
|
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 .
|
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_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] |
|
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_elt [Packed_array.Basic] |
|
bin_read_elt_ [Packed_array.Basic] |
|
bin_read_elt__ [Packed_array.Basic] |
|
bin_read_field [Stats_reporting] |
|
bin_read_field_ [Stats_reporting] |
|
bin_read_field__ [Stats_reporting] |
|
bin_read_flag [Extended_linux.Splice] |
|
bin_read_flag_ [Extended_linux.Splice] |
|
bin_read_flag__ [Extended_linux.Splice] |
|
bin_read_key [Packed_map.S] |
|
bin_read_key_ [Packed_map.S] |
|
bin_read_key__ [Packed_map.S] |
|
bin_read_mallinfo [Malloc] |
|
bin_read_mallinfo_ [Malloc] |
|
bin_read_mallinfo__ [Malloc] |
|
bin_read_name [Stats_reporting] |
|
bin_read_name_ [Stats_reporting] |
|
bin_read_name__ [Stats_reporting] |
|
bin_read_opt [Malloc] |
|
bin_read_opt_ [Malloc] |
|
bin_read_opt__ [Malloc] |
|
bin_read_snapshot [Time_stamp_counter.Cycles] |
|
bin_read_snapshot_ [Time_stamp_counter.Cycles] |
|
bin_read_snapshot__ [Time_stamp_counter.Cycles] |
|
bin_read_statvfs [Unix] |
|
bin_read_statvfs_ [Unix] |
|
bin_read_statvfs__ [Unix] |
|
bin_read_t [Time_stamp_counter.Cycles] |
|
bin_read_t [Stats_reporting] |
|
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_t_ [Time_stamp_counter.Cycles] |
|
bin_read_t_ [Stats_reporting] |
|
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_t__ [Time_stamp_counter.Cycles] |
|
bin_read_t__ [Stats_reporting] |
|
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] |
|
bin_read_type_desc_ [Stats_reporting] |
|
bin_read_type_desc__ [Stats_reporting] |
|
bin_read_uids [Extended_linux] |
|
bin_read_uids_ [Extended_linux] |
|
bin_read_uids__ [Extended_linux] |
|
bin_read_value [Packed_map.S] |
|
bin_read_value_ [Packed_map.S] |
|
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] |
|
bin_reader_opt [Malloc] |
|
bin_reader_snapshot [Time_stamp_counter.Cycles] |
|
bin_reader_statvfs [Unix] |
|
bin_reader_t [Time_stamp_counter.Cycles] |
|
bin_reader_t [Stats_reporting] |
|
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] |
|
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] |
|
bin_size_opt [Malloc] |
|
bin_size_snapshot [Time_stamp_counter.Cycles] |
|
bin_size_statvfs [Unix] |
|
bin_size_t [Time_stamp_counter.Cycles] |
|
bin_size_t [Stats_reporting] |
|
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] |
|
bin_size_uids [Extended_linux] |
|
bin_size_value [Packed_map.S] |
|
bin_snapshot [Time_stamp_counter.Cycles] |
|
bin_statvfs [Unix] |
|
bin_t [Time_stamp_counter.Cycles] |
|
bin_t [Stats_reporting] |
|
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] |
|
bin_uids [Extended_linux] |
|
bin_value [Packed_map.S] |
|
bin_write_any [Array.Access_control] |
|
bin_write_any_ [Array.Access_control] |
|
bin_write_color [Color_print] |
|
bin_write_color_ [Color_print] |
|
bin_write_elt [Packed_array.Basic] |
|
bin_write_elt_ [Packed_array.Basic] |
|
bin_write_field [Stats_reporting] |
|
bin_write_field_ [Stats_reporting] |
|
bin_write_flag [Extended_linux.Splice] |
|
bin_write_flag_ [Extended_linux.Splice] |
|
bin_write_key [Packed_map.S] |
|
bin_write_key_ [Packed_map.S] |
|
bin_write_mallinfo [Malloc] |
|
bin_write_mallinfo_ [Malloc] |
|
bin_write_name [Stats_reporting] |
|
bin_write_name_ [Stats_reporting] |
|
bin_write_opt [Malloc] |
|
bin_write_opt_ [Malloc] |
|
bin_write_snapshot [Time_stamp_counter.Cycles] |
|
bin_write_snapshot_ [Time_stamp_counter.Cycles] |
|
bin_write_statvfs [Unix] |
|
bin_write_statvfs_ [Unix] |
|
bin_write_t [Time_stamp_counter.Cycles] |
|
bin_write_t [Stats_reporting] |
|
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_t_ [Time_stamp_counter.Cycles] |
|
bin_write_t_ [Stats_reporting] |
|
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] |
|
bin_write_type_desc_ [Stats_reporting] |
|
bin_write_uids [Extended_linux] |
|
bin_write_uids_ [Extended_linux] |
|
bin_write_value [Packed_map.S] |
|
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] |
|
bin_writer_opt [Malloc] |
|
bin_writer_snapshot [Time_stamp_counter.Cycles] |
|
bin_writer_statvfs [Unix] |
|
bin_writer_t [Time_stamp_counter.Cycles] |
|
bin_writer_t [Stats_reporting] |
|
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] |
|
bin_writer_uids [Extended_linux] |
|
bin_writer_value [Packed_map.S] |
|
bits [Unix.Cidr] |
|
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 break s.
|
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
|
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] |
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
|
clock_mono_getres [Time_stamp_counter] |
|
clock_mono_gettime [Time_stamp_counter] |
|
clock_rt_getres [Time_stamp_counter] |
Some experimentation with different clocks
|
clock_rt_gettime [Time_stamp_counter] |
|
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 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.
|
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 [Bench.Result] |
|
compare [Trie.Key.Part] |
|
compare [Prod_or_test] |
|
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 [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] |
|
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] |
|
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_mhz [Time_stamp_counter.Cycles] |
|
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 [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_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] |
|
desired_sample_size [Random_selection] |
the desired sample size
|
destination [Procfs.Net.Route.Fields] |
|
destination [Procfs.Net.Route] |
|
diff [Time_stamp_counter.Cycles] |
|
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 [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 [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 [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.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] |
|
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 [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 [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] |
|
fn [Fn.Abstract] |
|
fold [Sys_utils.Lsb_release.Fields.Direct] |
|
fold [Sys_utils.Lsb_release.Fields] |
|
fold [Stats_reporting] |
|
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 [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.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.
|
get_snapshot [Time_stamp_counter.Cycles] |
|
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
|
hard [Procfs.Process.Limits.Rlimit.Fields] |
|
hard [Procfs.Process.Limits.Rlimit] |
|
has_next [Lazy_sequence.Iterator] |
|
hash [Trie.Key.Part] |
|
hd [Lazy_sequence] |
|
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] |
|
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] |
|
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 [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_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_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_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.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 .
|
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 [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 [Ascii_table.Align] |
|
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 [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_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 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 .
|
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.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_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 [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_ [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 [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 [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] |
|
name_of_sexp [Stats_reporting] |
|
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.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] |
|
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] |
|
now [Time_stamp_counter.Cycles] |
|
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_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 [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_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 [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_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 [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] |
|
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] |
|
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_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] |
|
resize_if_required [Stats_reporting] |
|
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 [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
|
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.
|
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 [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 [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] |
|
sexp_of_opt [Malloc] |
???
|
sexp_of_snapshot [Time_stamp_counter.Cycles] |
|
sexp_of_statvfs [Unix] |
|
sexp_of_t [Time_stamp_counter.Cycles] |
|
sexp_of_t [Trie.Key.Part] |
|
sexp_of_t [Sys_utils.Lsb_release] |
|
sexp_of_t [Stats_reporting] |
|
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 [Unix.Cidr] |
|
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] |
|
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] |
|
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] |
|
slice [Packed_array.S] |
|
slot_spec [Service_command.T] |
|
snapshot_of_sexp [Time_stamp_counter.Cycles] |
|
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] |
|
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.
|
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
|
string_with_attr [Console.Ansi] |
|
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 [Time_stamp_counter.Cycles] |
|
t_of_sexp [Trie.Key.Part] |
|
t_of_sexp [Sys_utils.Lsb_release] |
|
t_of_sexp [Stats_reporting] |
|
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 [Unix.Cidr] |
|
t_of_sexp [Sexp.Make_explicit_sexp_option] |
|
t_of_sexp [Int64.Filesize] |
|
t_of_sexp [Cbuffer] |
|
t_of_sexp__ [Prod_or_test] |
|
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] |
|
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] |
|
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_cycle_count [Time_stamp_counter.Cycles] |
|
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 [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_ns [Time_stamp_counter.Cycles] |
|
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 [Unix.Cidr] |
|
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] |
|
to_time [Time_stamp_counter.Cycles] |
|
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] |
|
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.
|
unsave_cursor [Console.Ansi] |
|
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 |
value_of_sexp [Procfs.Process.Limits.Rlimit] |
|
value_of_sexp [Packed_map.S] |
|
value_of_sexp__ [Procfs.Process.Limits.Rlimit] |
|
value_raise [Extended_option] |
|
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] |
|
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_exn [Packed_array.Tuple2] |
|
zip_full [Lazy_sequence] |
|