|
($) [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 .
|
(%:) [Fcommand] |
|
(%:) [Core_command.Spec] |
(name %: typ) specifies a required anonymous argument of type typ .
|
(++) [Fcommand] |
spec1 ++ spec2 composes command-line specifications spec1 and
spec2 .
|
(++) [Core_command.Spec] |
specification composition: spec1 ++ spec2 ++ ... specN is the way composition.
|
(==>) [Lazy_sequence] |
|
(==>>) [Lazy_sequence] |
|
(~%) [Printc] |
alias for sprintf
|
(~:) [Printc] |
alias for String.concat
|
A |
active [Procfs.Meminfo.Fields] |
|
active [Procfs.Meminfo] |
|
ad_hoc [Core_command.Spec] |
specifies an exact usage message for a sequence of anonymous strings
|
add [Trie.S] |
|
add [Multi_map] |
|
add [Hmap] |
|
add [Fold_map.S2] |
|
add [Fold_map.S] |
add m ~key ~data adds the key to the value already bound to key in m .
|
add [Hashtbl.Access_control] |
|
add [Environment] |
|
add [Crit_bit] |
|
add [Cbuffer] |
|
add [Cache.S] |
|
add [Cache.Keep_all] |
|
add [Cache.Lru] |
|
add_char [Shell__line_buffer] |
|
add_exn [Hashtbl.Access_control] |
|
add_multi [Hashtbl.Access_control] |
|
add_string [Shell__line_buffer] |
|
add_substring [Shell__line_buffer] |
add_substring b s ofs len takes len characters from offset ofs in
string s and appends them at the end of the buffer b .
|
address_space [Procfs.Process.Limits.Fields] |
|
address_space [Procfs.Process.Limits] |
|
agrp [Pp] |
The automatic group agrp is the most versatile.
|
alert [Loggers.LOGGER] |
|
alist [Pp] |
|
all [Posix_clock] |
|
all_levs [Syslog] |
all_levs array of all logging levels sorted in ascending order.
|
all_same [Patience_diff.Hunk] |
all_same hunk returns true if hunk contains only Same ranges.
|
all_same [Patience_diff] |
get_status hunks returns `Same if each hunk in hunks has only Same ranges.
|
all_str_levs [Syslog] |
all_str_levs array of all logging levels as strings sorted in
ascending order.
|
anon [Fcommand] |
|
anon [Core_command.Spec] |
anon spec specifies a command that, among other things, takes
the anonymous arguments specified by spec .
|
anon_pages [Procfs.Meminfo.Fields] |
|
anon_pages [Procfs.Meminfo] |
|
any_of_sexp [Array.Access_control] |
|
app [Fn.Abstract] |
|
append [Lazy_list] |
|
append [Array.Access_control] |
|
append_to_path [Environment] |
|
arg [Command.Flag.Action] |
an action for a flag that takes an additional string argument
|
arg_mut [Command.Flag] |
|
arg_type [Core_command.Spec] |
an argument type includes information about how to parse values of that type
from the command line, and (optionally) how to auto-complete partial arguments of
that type via bash's programmable TAB-completion.
|
args [Core_command.Spec] |
|
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 [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 .
|
basic [Core_command] |
basic ~summary ?readme spec main is a basic command that executes
a function main which is passed parameters parsed from the command
line according to spec .
|
bell [Console.Ansi] |
|
bench [Bench] |
|
bench_raw [Bench] |
|
bigint_of_sexp [Procfs] |
|
bin_any [Array.Access_control] |
|
bin_flag [Extended_linux.Splice] |
|
bin_mallinfo [Malloc] |
|
bin_opt [Malloc] |
|
bin_read_any [Array.Access_control] |
|
bin_read_any_ [Array.Access_control] |
|
bin_read_any__ [Array.Access_control] |
|
bin_read_flag [Extended_linux.Splice] |
|
bin_read_flag_ [Extended_linux.Splice] |
|
bin_read_flag__ [Extended_linux.Splice] |
|
bin_read_mallinfo [Malloc] |
|
bin_read_mallinfo_ [Malloc] |
|
bin_read_mallinfo__ [Malloc] |
|
bin_read_opt [Malloc] |
|
bin_read_opt_ [Malloc] |
|
bin_read_opt__ [Malloc] |
|
bin_read_statvfs [Unix] |
|
bin_read_statvfs_ [Unix] |
|
bin_read_statvfs__ [Unix] |
|
bin_read_t [Int64.Filesize] |
|
bin_read_t_ [Int64.Filesize] |
|
bin_read_t__ [Int64.Filesize] |
|
bin_read_uids [Extended_linux] |
|
bin_read_uids_ [Extended_linux] |
|
bin_read_uids__ [Extended_linux] |
|
bin_reader_any [Array.Access_control] |
|
bin_reader_flag [Extended_linux.Splice] |
|
bin_reader_mallinfo [Malloc] |
|
bin_reader_opt [Malloc] |
|
bin_reader_statvfs [Unix] |
|
bin_reader_t [Int64.Filesize] |
|
bin_reader_uids [Extended_linux] |
|
bin_size_any [Array.Access_control] |
|
bin_size_flag [Extended_linux.Splice] |
|
bin_size_mallinfo [Malloc] |
|
bin_size_opt [Malloc] |
|
bin_size_statvfs [Unix] |
|
bin_size_t [Int64.Filesize] |
|
bin_size_uids [Extended_linux] |
|
bin_statvfs [Unix] |
|
bin_t [Int64.Filesize] |
|
bin_uids [Extended_linux] |
|
bin_write_any [Array.Access_control] |
|
bin_write_any_ [Array.Access_control] |
|
bin_write_flag [Extended_linux.Splice] |
|
bin_write_flag_ [Extended_linux.Splice] |
|
bin_write_mallinfo [Malloc] |
|
bin_write_mallinfo_ [Malloc] |
|
bin_write_opt [Malloc] |
|
bin_write_opt_ [Malloc] |
|
bin_write_statvfs [Unix] |
|
bin_write_statvfs_ [Unix] |
|
bin_write_t [Int64.Filesize] |
|
bin_write_t_ [Int64.Filesize] |
|
bin_write_uids [Extended_linux] |
|
bin_write_uids_ [Extended_linux] |
|
bin_writer_any [Array.Access_control] |
|
bin_writer_flag [Extended_linux.Splice] |
|
bin_writer_mallinfo [Malloc] |
|
bin_writer_opt [Malloc] |
|
bin_writer_statvfs [Unix] |
|
bin_writer_t [Int64.Filesize] |
|
bin_writer_uids [Extended_linux] |
|
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] |
|
bool [Core_command.Spec] |
|
bool [Command.Flag.Action] |
an action for a flag that takes an additional bool argument
|
bool [Command.Flag] |
|
bool_acc [Command.Flag] |
|
bool_mut [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] |
|
buffers [Procfs.Meminfo.Fields] |
|
buffers [Procfs.Meminfo] |
|
build [Lazy_list] |
|
C |
cached [Procfs.Meminfo.Fields] |
|
cached [Procfs.Meminfo] |
|
call_with_cache [Cache.S] |
|
call_with_cache [Cache.Keep_all] |
|
call_with_cache [Cache.Lru] |
|
callback [Shell.Process] |
|
capture_remaining_command_line [Fcommand] |
|
cartesian_product [Lazy_list] |
|
cb_compare [Cbuffer] |
compare two buffer fragments
|
center [Ascii_table.Align] |
|
change [Hashtbl.Access_control] |
|
channel [Iter] |
call f on channel until End_of_file
|
channel_progress [Iter] |
create a progress function for an input channel
|
check [Sys_utils.Sexp_checked_edit] |
|
check [Number.Verified_spec] |
|
check_index [Cbuffer] |
|
check_sexps [Sys_utils.Sexp_checked_edit] |
|
checked_edit [Sys_utils] |
checked_edit ~check file
|
choice [Readline] |
|
classify [List] |
classify l ~equal ~f elements x and y of list l are assigned to the
same class iff equal (f x) (f y) returns true.
|
clear [Hashtbl.Access_control] |
|
clear [Command.Annotated_field] |
|
clear [Command.Flag] |
|
clear [Cache.S] |
|
clear [Cache.Store] |
Remove all the values from the store.
|
clear [Cache.Strategy] |
Inform the strategy that all the elements where dropped from the store.
|
clear [Cache.Keep_all] |
|
clear [Cache.Lru] |
|
clear [Bitarray] |
clear t set the contents of every element to false O(n / (word_size - 2))
|
clear_filter [Logger] |
removes the filter from a log
|
close [Linebuf] |
Closes the line buffer (and the underlying file).
|
close [Lazy_sequence.Iterator] |
|
close [Find] |
close t drops all the resources associated with t.
|
closelog [Syslog] |
|
cmajflt [Procfs.Process.Stat.Fields] |
|
cmajflt [Procfs.Process.Stat] |
|
cmd [Shell.Process] |
|
cmd [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] |
|
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.
|
comm [Procfs.Process.Stat.Fields] |
|
comm [Procfs.Process.Stat] |
|
commalist [Pp] |
|
command [Service_command] |
|
command [Command.Version] |
Provides a "version" subcommand.
|
comment [Sexp] |
Takes a string and returns the same string but commented according to
sexp's syntax
|
commit_limit [Procfs.Meminfo.Fields] |
|
commit_limit [Procfs.Meminfo] |
|
committed_as [Procfs.Meminfo.Fields] |
|
committed_as [Procfs.Meminfo] |
|
compactions_occurred [Bench.Result] |
|
compare [Trie.Key.Part] |
|
compare [List] |
|
compare [Filename] |
Filename.compare is a comparaison that normalizes filenames ("./a" = "a") use
a more human ready algorithm based on String.collate
("rfc02.txt > rfc1.txt") and extenstions ("a.c" > "a.h").
|
compare_lev [Syslog] |
compare_lev lev1 lev2 compares logging levels lev1 and lev2 .
|
concat [Lazy_list] |
|
concat [Iter] |
concatenate a list of iterators
|
concat_list [Lazy_list] |
|
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 [Fcommand] |
|
const [Core_command.Spec] |
const v inserts v as a hard-coded argument to the command.
|
contains [Trie.S] |
|
content [Shell.Process] |
|
contents [String_zipper] |
|
contents [Readline__input_loop] |
|
copy [Hashtbl.Access_control] |
|
copy [Array.Access_control] |
|
copy_data [Cbuffer] |
copies data from one array to another.
|
core_file_size [Procfs.Process.Limits.Fields] |
|
core_file_size [Procfs.Process.Limits] |
|
cp [Shell] |
|
cps_create [Cache.Store] |
cps_create is given in CPS form to enable chaining.
|
cps_create [Cache.Strategy] |
cps_create ~f is given in CPS form to enable chaining.
|
cpu_time [Procfs.Process.Limits.Fields] |
|
cpu_time [Procfs.Process.Limits] |
|
cpu_use [Sys_utils.Cpu_use] |
|
create [Uuid] |
|
create [Update_queue] |
|
create [Trie.S] |
|
create [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 [Procfs.Mount.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 [Hmap.Key] |
|
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 [Command.Flags_ext] |
|
create [Command.Flag] |
|
create [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 [Command] |
|
create_attr [Ascii_table.Column] |
like create, except that the to_string function must provide a list of
attributes.
|
create_choice [Command.Flags_ext] |
|
create_choice_optional [Command.Flags_ext] |
|
create_default [Logger] |
creates a log using the default message type and a filter that drops
`Debug messages
|
create_many [Command.Flags_ext] |
|
create_no_accum [Command] |
|
create_no_accum0 [Command] |
|
create_optional [Command.Flags_ext] |
|
create_rest [Command.Flags_ext] |
|
create_set [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] |
|
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 [Fcommand] |
|
date [Core_command.Spec] |
|
date_acc [Command.Flag] |
rest f : a flag that signals the end of flag processing.
|
date_mut [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 [Command.Annotated_field] |
|
destination [Procfs.Net.Route.Fields] |
|
destination [Procfs.Net.Route] |
|
diff [Sys_utils] |
diff s1 s2 returns diff (1) output of the two strings.
|
dirty [Procfs.Meminfo.Fields] |
|
dirty [Procfs.Meminfo] |
|
discard [Shell.Process] |
|
documentation [Documented_match_statement] |
|
drop_after [String_zipper] |
|
drop_after [List_zipper] |
|
drop_all_after [String_zipper] |
|
drop_all_after [List_zipper] |
|
drop_all_before [String_zipper] |
|
drop_all_before [List_zipper] |
|
drop_before [String_zipper] |
|
drop_before [List_zipper] |
|
drop_from [Cbuffer] |
|
drop_last [Cbuffer] |
|
drop_old [Cbuffer] |
drop stuff from the end.
|
dt [Procfs.Process.Statm.Fields] |
|
dt [Procfs.Process.Statm] |
|
E |
edit [Sys_utils.Sexp_checked_edit] |
|
edit_distance [String] |
Gives the Levenshtein distance between 2 strings, which is the number of insertions,
deletions, and substitutions necessary to turn either string into the other.
|
edit_sexps [Sys_utils.Sexp_checked_edit] |
|
egid [Procfs.Process.Status.Fields] |
|
egid [Procfs.Process.Status] |
|
either [Fcommand] |
|
emerg [Loggers.LOGGER] |
|
empty [Pp] |
The empty document is pretty printed to the empty string.
|
empty [Multi_map] |
|
empty [Lazy_list] |
|
empty [Iter] |
an iterator that halts immediately
|
empty [Hmap] |
|
empty [Fold_map.S2] |
|
empty [Fold_map.S] |
A map containing no bindings
|
empty [Fcommand] |
|
empty [Crit_bit] |
|
empty [Bench.Result.Stat] |
|
endcode [Procfs.Process.Stat.Fields] |
|
endcode [Procfs.Process.Stat] |
|
enqueue [Update_queue] |
|
ensure_at_exit [Unix_utils] |
ensure_at_exit () : catch all signals, run at_exit functions,
then re-deliver the signal to self to ensure the default behavior.
|
enumerate_from [List] |
enumerate_from n xs returns a list of pairs constructed by pairing an
incrementing counter, starting at n , with the elements of xs .
|
environ [Procfs.Process.Fields] |
|
environ [Procfs.Process] |
|
eprint [Printc] |
|
eprintf [Console.Ansi] |
|
eprintl [Printc] |
|
equal [List] |
|
equal [Hashtbl.Access_control] |
|
err [Loggers.LOGGER] |
|
escape [Core_command.Deprecated.Spec] |
|
escape [Core_command.Spec] |
escape flags may be passed at most once.
|
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 .
|
esyslog_printf [Syslog] |
|
euid [Procfs.Process.Status.Fields] |
|
euid [Procfs.Process.Status] |
|
eval [Selector.Selector] |
|
exe [Procfs.Process.Fields] |
|
exe [Procfs.Process] |
|
exists [Procfs.Mount.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 [Procfs.Process.Fields] |
|
fds [Procfs.Process] |
|
fgrp [Pp] |
The break policy inside an agrp is fixed for all breaks of the group.
|
fifteen [Procfs.Loadavg.Fields] |
|
fifteen [Procfs.Loadavg] |
|
file [Procfs.Mount.Fields] |
|
file [Procfs.Mount] |
|
file [Core_command.Spec] |
|
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_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] |
|
final_pass [Sexp.Make_sexp_maybe2] |
|
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 [Hmap] |
|
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 [Hmap] |
|
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 [Fcommand] |
|
flag [Core_command.Spec] |
flag name spec ~doc specifies a command that, among other things, takes
a flag named name on its command line.
|
flag [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 [Fcommand] |
|
float [Core_command.Spec] |
|
float [Command.Flag.Action] |
an action for a flag that takes an additional float argument
|
float [Command.Flag] |
|
float_acc [Command.Flag] |
|
float_mut [Command.Flag] |
|
flush [Shell__line_buffer] |
flush b Flushes any pending output to the callback function.
|
flush [Readline.History] |
|
fn [Fn.Abstract] |
|
fold [Procfs.Mount.Fields.Direct] |
|
fold [Procfs.Mount.Fields] |
|
fold [Procfs.Net.Route.Fields.Direct] |
|
fold [Procfs.Net.Route.Fields] |
|
fold [Procfs.Net.Dev.Fields.Direct] |
|
fold [Procfs.Net.Dev.Fields] |
|
fold [Procfs.Loadavg.Fields.Direct] |
|
fold [Procfs.Loadavg.Fields] |
|
fold [Procfs.Meminfo.Fields.Direct] |
|
fold [Procfs.Meminfo.Fields] |
|
fold [Procfs.Process.Fields.Direct] |
|
fold [Procfs.Process.Fields] |
|
fold [Procfs.Process.Fd.Fields.Direct] |
|
fold [Procfs.Process.Fd.Fields] |
|
fold [Procfs.Process.Status.Fields.Direct] |
|
fold [Procfs.Process.Status.Fields] |
|
fold [Procfs.Process.Statm.Fields.Direct] |
|
fold [Procfs.Process.Statm.Fields] |
|
fold [Procfs.Process.Stat.Fields.Direct] |
|
fold [Procfs.Process.Stat.Fields] |
|
fold [Procfs.Process.Limits.Fields.Direct] |
|
fold [Procfs.Process.Limits.Fields] |
|
fold [Procfs.Process.Limits.Rlimit.Fields.Direct] |
|
fold [Procfs.Process.Limits.Rlimit.Fields] |
|
fold [Multi_map] |
|
fold [Lazy_sequence.Iterator] |
|
fold [Iter] |
fold is the same as reduce
|
fold [Fold_map.S2] |
|
fold [Fold_map.S] |
|
fold [Find] |
fold t ~init ~f folds f over the files in t
|
fold [Hashtbl.Access_control] |
|
fold [Crit_bit] |
|
fold [Bitarray] |
fold t ~init ~f Fold over the array as in Array.fold
|
fold_left [Lazy_list] |
|
fold_left_term [List] |
fold_left_term is like fold_left, except that you can halt early.
|
fold_map [Lazy_sequence] |
|
fold_right [Lazy_list] |
|
foldi [Array] |
|
foldr [Lazy_list] |
|
for_all [Procfs.Mount.Fields] |
|
for_all [Procfs.Net.Route.Fields] |
|
for_all [Procfs.Net.Dev.Fields] |
|
for_all [Procfs.Loadavg.Fields] |
|
for_all [Procfs.Meminfo.Fields] |
|
for_all [Procfs.Process.Fields] |
|
for_all [Procfs.Process.Fd.Fields] |
|
for_all [Procfs.Process.Status.Fields] |
|
for_all [Procfs.Process.Statm.Fields] |
|
for_all [Procfs.Process.Stat.Fields] |
|
for_all [Procfs.Process.Limits.Fields] |
|
for_all [Procfs.Process.Limits.Rlimit.Fields] |
|
for_all [Iter] |
evaluate a predicate over the entire iterator
|
for_all [Fold_map.S2] |
|
for_all [Fold_map.S] |
|
force [Lazy_m] |
Force the lazy value.
|
fork_exec [Unix] |
fork_exec prog args ~stdin ~stdout ~stderr ~setuid ~setgid
forks a new process that executes the program
in file prog , with arguments args .
|
format [Time.Date] |
Shortcut for calling Core_extended.Unix.strftime without having to
create a Time.t and convert it to a Unix.tm.
|
format [Sexp] |
|
format_failed [Shell.Process] |
|
fprint [Printc] |
|
fprintl [Printc] |
|
freq [Procfs.Mount.Fields] |
|
freq [Procfs.Mount] |
|
fsgid [Procfs.Process.Status.Fields] |
|
fsgid [Procfs.Process.Status] |
|
fsuid [Procfs.Process.Status.Fields] |
|
fsuid [Procfs.Process.Status] |
|
G |
gateway [Procfs.Net.Route.Fields] |
|
gateway [Procfs.Net.Route] |
|
gen [Command.Flag] |
|
gen_acc [Command.Flag] |
|
gen_mut [Command.Flag] |
|
general_rec [Memo] |
A version of Memo.general more suitable for memoizing
recursively-defined functions
|
generic [Loggers.LOGGER] |
|
get [Sys_utils.Cpu_use] |
update_exn updates a Cpu_use.t.
|
get [Semaphore] |
get sem
|
get [Readline__input_char] |
|
get [Lazy_sequence.Iterator] |
|
get [Array.Access_control] |
|
get [Command.Flags_ext] |
|
get [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 [Command] |
|
get_expanded_cmdline [Command] |
|
get_flag_names [Core_command.Deprecated] |
|
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 [Command.Annotated_field] |
|
get_matching_blocks [Patience_diff] |
|
get_opt [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] |
get_ip_from_hostname () 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] |
|
group [Core_service_command] |
|
group [Core_command] |
group ~summary subcommand_alist is a compound command with named
subcommands, as found in subcommand_alist .
|
group [Command] |
group ~summary [...; (name_i, t_i); ...] is an aggregate command
that dispatches to one of the named sub-commands.
|
groups [Sys] |
Get the names of the groups the user belongs to
|
H |
h_name_of_sockaddr [Net_utils] |
Get hostname from sockaddr
|
h_name_or_string_of_sockaddr [Net_utils] |
Get hostname or (on Not_found) inet string from sockaddr
|
hard [Procfs.Process.Limits.Rlimit.Fields] |
|
hard [Procfs.Process.Limits.Rlimit] |
|
has_next [Lazy_sequence.Iterator] |
|
hash [Trie.Key.Part] |
|
head [Shell.Process] |
|
help [Core_command.Spec] |
|
help_recursive [Core_command.Deprecated] |
|
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] |
|
I |
i [Iter] |
iterate over the iterator: call f on each element
|
i2s [Printc] |
|
iface [Procfs.Net.Route.Fields] |
|
iface [Procfs.Net.Route] |
|
iface [Procfs.Net.Dev.Fields] |
|
iface [Procfs.Net.Dev] |
|
ifconfig_ips [Sys_utils] |
ifconfig_ips () returns IPs of all active interfaces on the host by parsing ifconfig
output.
|
ignore_errors [Find.Options] |
|
implode [Filename] |
dual to explode
|
import_from_sys [Environment] |
|
in_order [Search_foo] |
|
inactive [Procfs.Meminfo.Fields] |
|
inactive [Procfs.Meminfo] |
|
incr [Hashtbl.Access_control] |
|
inet_addr_of_sockaddr [Net_utils] |
Get inet_addr from sockaddr
|
info [Loggers.LOGGER] |
|
init [Update_queue] |
|
init [Semaphore] |
init v initializes a semaphore with an optional value v .
|
init [Lazy_sequence] |
|
init [Fold_map.Foldable2] |
|
init [Fold_map.Foldable] |
The initial value of the accumulator.
|
init [Array.Access_control] |
|
init [Command.Annotated_field] |
|
initialize [Lazy_sequence] |
|
input_line [Readline] |
|
input_line_eof [Readline] |
|
insert_after [String_zipper] |
|
insert_after [List_zipper] |
|
insert_before [String_zipper] |
|
insert_before [List_zipper] |
|
int [Fcommand] |
|
int [Core_command.Spec] |
|
int [Command.Flag.Action] |
an action for a flag that takes an additional int argument
|
int [Command.Flag] |
|
int_acc [Command.Flag] |
|
int_mut [Command.Flag] |
|
intersperse [List] |
intersperse returns a list with the given element placed between every two
original elements.
|
irtt [Procfs.Net.Route.Fields] |
|
irtt [Procfs.Net.Route] |
|
is_atom [Sexp] |
|
is_closed [Linebuf] |
Returns whether or not the line buffer is closed
|
is_color_tty [Console] |
|
is_empty [Multi_map] |
|
is_empty [Lazy_list] |
|
is_empty [Fold_map.S2] |
|
is_empty [Fold_map.S] |
|
is_empty [Hashtbl.Access_control] |
|
is_executable [Shell__core] |
|
is_full [Cbuffer] |
|
is_list [Sexp] |
|
is_parent [Filename] |
|
is_set [Command.Flags_ext] |
|
is_substring [String] |
is_substring ~substring t returns true if substring is a substring
of t.
|
is_val [Lazy_m] |
Returns true if the lazy value has been forced and did not throw an
exception.
|
iter [Trie.Key] |
|
iter [Procfs.Mount.Fields.Direct] |
|
iter [Procfs.Mount.Fields] |
|
iter [Procfs.Net.Route.Fields.Direct] |
|
iter [Procfs.Net.Route.Fields] |
|
iter [Procfs.Net.Dev.Fields.Direct] |
|
iter [Procfs.Net.Dev.Fields] |
|
iter [Procfs.Loadavg.Fields.Direct] |
|
iter [Procfs.Loadavg.Fields] |
|
iter [Procfs.Meminfo.Fields.Direct] |
|
iter [Procfs.Meminfo.Fields] |
|
iter [Procfs.Process.Fields.Direct] |
|
iter [Procfs.Process.Fields] |
|
iter [Procfs.Process.Fd.Fields.Direct] |
|
iter [Procfs.Process.Fd.Fields] |
|
iter [Procfs.Process.Status.Fields.Direct] |
|
iter [Procfs.Process.Status.Fields] |
|
iter [Procfs.Process.Statm.Fields.Direct] |
|
iter [Procfs.Process.Statm.Fields] |
|
iter [Procfs.Process.Stat.Fields.Direct] |
|
iter [Procfs.Process.Stat.Fields] |
|
iter [Procfs.Process.Limits.Fields.Direct] |
|
iter [Procfs.Process.Limits.Fields] |
|
iter [Procfs.Process.Limits.Rlimit.Fields.Direct] |
|
iter [Procfs.Process.Limits.Rlimit.Fields] |
|
iter [Multi_map] |
|
iter [Lazy_sequence.Iterator] |
|
iter [Lazy_list.Iterator] |
|
iter [Lazy_list] |
|
iter [Fold_map.S2] |
|
iter [Fold_map.S] |
|
iter [Find] |
iter t ~f calls f on every file in t
|
iter [Hashtbl.Access_control] |
|
iter [Crit_bit] |
|
iter [Cbuffer] |
iter buf ~f calls func on each buffer element starting with 0
like this: (func pos element)
|
iter [Bitarray] |
iter t ~f Iterate over the array as in Array.iter
|
iter_vals [Hashtbl.Access_control] |
|
iteri [Array.Access_control] |
|
iterr [Cbuffer] |
iterr buf ~f calls func on each buffer element starting with end
like this: (func pos element)
|
itrealvalue [Procfs.Process.Stat.Fields] |
|
itrealvalue [Procfs.Process.Stat] |
|
J |
jiffies_per_second [Procfs] |
|
jiffies_per_second_exn [Procfs] |
jiffies_per_second_exn .
|
K |
keys [Multi_map] |
Returns all the non-empty keys in m .
|
keys [Fold_map.S2] |
|
keys [Fold_map.S] |
|
keys [Hashtbl.Access_control] |
|
kill [Process] |
kills a process by sending signal ; waiting for wait_for and then
sending a sigkill .
|
kill_line [Console.Ansi] |
|
kstkeip [Procfs.Process.Stat.Fields] |
|
kstkeip [Procfs.Process.Stat] |
|
kstkesp [Procfs.Process.Stat.Fields] |
|
kstkesp [Procfs.Process.Stat] |
|
L |
last [String_zipper] |
|
last_accessed [Sys] |
last_accessed path returns the time path was last accessed.
|
last_accessed_exn [Sys] |
|
last_changed [Sys] |
last_changed path returns the time path last had its status changed.
|
last_changed_exn [Sys] |
|
last_modified [Sys] |
last_modify path returns the time the file at path was last modified.
|
last_modified_exn [Sys] |
|
lazy_fold [Lazy_list.Of_container.T] |
|
lazy_list_of_t [Lazy_list.Of_container.Make] |
|
lazy_sort [Lazy_list] |
|
lcs [Extended_list__LCS] |
|
lcs [List] |
Find the longest common subsequence between two list.
|
left [Ascii_table.Align] |
|
left_contents [String_zipper] |
|
length [Lazy_list] |
|
length [Fold_map.S2] |
|
length [Fold_map.S] |
|
length [Hashtbl.Access_control] |
|
length [Cbuffer] |
|
lev_of_string [Syslog] |
lev_of_string str converts string str to a level.
|
lib [Procfs.Process.Statm.Fields] |
|
lib [Procfs.Process.Statm] |
|
lift [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 [Command.Flag] |
|
limits [Procfs.Process.Fields] |
|
limits [Procfs.Process] |
|
line [Ascii_table.Display] |
|
line_break [String] |
deprecated in favour of word_wrap
|
line_to_string [Csv_writer] |
Convert one CSV line to a string.
|
lines [Shell.Process] |
|
list [Pp] |
A list of objects which are seperated by some seperator is very common.
|
list [Sexp] |
|
list [Command.Annotated_field] |
|
listed [Fcommand] |
|
listed [Core_command.Spec] |
listed flags may be passed zero or more times
|
ln [Shell] |
|
load [Bin_io_utils] |
|
load_sexp_conv_exn_sample [Sexp] |
|
loadavg [Procfs] |
|
loadavg_exn [Procfs] |
loadavg_exn parses /proc/loadavg.
|
locked_memory [Procfs.Process.Limits.Fields] |
|
locked_memory [Procfs.Process.Limits] |
|
log [Logger] |
logs a message to log
|
logger [Loggers.SPEC] |
|
look [Semaphore] |
|
lower [Number.Verified_std.Bounded_spec] |
|
lpad [Printc] |
|
ls [Sys] |
|
M |
main [Core_service_command.T] |
|
main_spec [Core_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 [Procfs.Mount.Fields] |
|
make_creator [Procfs.Net.Route.Fields] |
|
make_creator [Procfs.Net.Dev.Fields] |
|
make_creator [Procfs.Loadavg.Fields] |
|
make_creator [Procfs.Meminfo.Fields] |
|
make_creator [Procfs.Process.Fields] |
|
make_creator [Procfs.Process.Fd.Fields] |
|
make_creator [Procfs.Process.Status.Fields] |
|
make_creator [Procfs.Process.Statm.Fields] |
|
make_creator [Procfs.Process.Stat.Fields] |
|
make_creator [Procfs.Process.Limits.Fields] |
|
make_creator [Procfs.Process.Limits.Rlimit.Fields] |
|
make_flags [Extended_linux.Splice] |
make_flags ar
|
make_relative [Filename] |
make_relative ~to_:src f
returns f relative to src .
|
mallinfo [Malloc] |
mallinfo ()
|
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 [Fcommand] |
|
map [Update_queue] |
|
map [Procfs.Mount.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 [Fcommand.Anons] |
|
map [Fcommand.Flag] |
|
map [Hashtbl.Access_control] |
|
map [Array.Access_control] |
|
map [Documented_match_statement] |
|
map [Crit_bit] |
|
map2 [Array.Access_control] |
|
map_cases [Documented_match_statement] |
|
map_monad [Extended_monad.S2] |
|
map_monad [Extended_monad.S] |
|
map_monad [Extended_monad.Make2] |
|
map_monad [Extended_monad.Make] |
|
map_monad_ignore [Extended_monad.S2] |
|
map_monad_ignore [Extended_monad.S] |
|
map_monad_ignore [Extended_monad.Make2] |
|
map_monad_ignore [Extended_monad.Make] |
|
map_pattern [Documented_match_statement] |
|
map_poly [Procfs.Mount.Fields] |
|
map_poly [Procfs.Net.Route.Fields] |
|
map_poly [Procfs.Net.Dev.Fields] |
|
map_poly [Procfs.Loadavg.Fields] |
|
map_poly [Procfs.Meminfo.Fields] |
|
map_poly [Procfs.Process.Fields] |
|
map_poly [Procfs.Process.Fd.Fields] |
|
map_poly [Procfs.Process.Status.Fields] |
|
map_poly [Procfs.Process.Statm.Fields] |
|
map_poly [Procfs.Process.Stat.Fields] |
|
map_poly [Procfs.Process.Limits.Fields] |
|
map_poly [Procfs.Process.Limits.Rlimit.Fields] |
|
mapi [Multi_map] |
|
mapi [Hashtbl.Access_control] |
|
mapi [Array.Access_control] |
|
mapped [Procfs.Meminfo.Fields] |
|
mapped [Procfs.Meminfo] |
|
mask [Procfs.Net.Route.Fields] |
|
mask [Procfs.Net.Route] |
|
match_ [Documented_match_statement] |
match_ t pulls out the underlying function of t
|
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 [Fcommand] |
|
maybe [Core_command.Spec] |
(maybe anons) indicates that some anonymous arguments are optional
|
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 [Fcommand] |
|
maybe_with_default [Core_command.Spec] |
(maybe_with_default default anons) indicates an optional anonymous
argument with a default value
|
mean [Bench.Result] |
|
mean_gettime_cost [Posix_clock] |
|
mem [Multi_map] |
mem m key returns true if key has at last one value associated to it
in m
|
mem [Fold_map.S2] |
|
mem [Fold_map.S] |
|
mem [Hashtbl.Access_control] |
|
mem [Environment] |
|
mem_free [Procfs.Meminfo.Fields] |
|
mem_free [Procfs.Meminfo] |
|
mem_total [Procfs.Meminfo.Fields] |
|
mem_total [Procfs.Meminfo] |
|
meminfo [Procfs] |
|
meminfo_exn [Procfs] |
meminfo_exn queries /proc/meminfo and fills out Meminfo.t.
|
memoize [Cache.S] |
|
memoize [Cache.Keep_all] |
|
memoize [Cache.Lru] |
|
memoize [Cache] |
memoize ~destruct ~expire f
memoizes the results of f .
|
merge [Patience_diff] |
|
merge [Lazy_list] |
|
merge [Hashtbl.Access_control] |
|
merge_into [Hashtbl.Access_control] |
|
metric [Procfs.Net.Route.Fields] |
|
metric [Procfs.Net.Route] |
|
min [List] |
|
min [Bench.Result] |
|
min_exn [List] |
|
min_interval [Posix_clock] |
|
minf [Search_foo] |
|
minflt [Procfs.Process.Stat.Fields] |
|
minflt [Procfs.Process.Stat] |
|
mkdir [Shell] |
|
mntops [Procfs.Mount.Fields] |
|
mntops [Procfs.Mount] |
|
module_name [Number.Verified_std_spec] |
|
mounts [Procfs] |
|
mounts_of_fstab [Procfs] |
|
msgqueue_size [Procfs.Process.Limits.Fields] |
|
msgqueue_size [Procfs.Process.Limits] |
|
mtu [Procfs.Net.Route.Fields] |
|
mtu [Procfs.Net.Route] |
|
multimerge [Extended_list__multimerge] |
|
multimerge [List] |
Merges several list trying to keep the order in which the elements appear.
|
multimerge_unique [Extended_list__multimerge] |
|
multimerge_unique [List] |
|
mv [Shell] |
Raises "Failed_command"
|
N |
name [Number.Verified_std.Bounded_spec] |
|
name [Linebuf] |
|
name [Command.Flag] |
|
name [Bench.Test] |
|
names [Procfs.Mount.Fields] |
|
names [Procfs.Net.Route.Fields] |
|
names [Procfs.Net.Dev.Fields] |
|
names [Procfs.Loadavg.Fields] |
|
names [Procfs.Meminfo.Fields] |
|
names [Procfs.Process.Fields] |
|
names [Procfs.Process.Fd.Fields] |
|
names [Procfs.Process.Status.Fields] |
|
names [Procfs.Process.Statm.Fields] |
|
names [Procfs.Process.Stat.Fields] |
|
names [Procfs.Process.Limits.Fields] |
|
names [Procfs.Process.Limits.Rlimit.Fields] |
|
nest [Pp] |
When the pretty printer decides to represent a break as a newline it also
prints some spaces after it to indent the following line.
|
new_only [Patience_diff] |
new_only hunks drops all Old ranges from hunks and converts all Replace
ranges to New ranges.
|
next [String_zipper] |
|
next [List_zipper] |
|
next [Lazy_list.Iterator] |
|
next [Iter] |
get the next element of the iterator
|
next [Find] |
next t return the next file from the collection of valid files in t or None
if no more files remain
|
next_exn [Iter] |
|
nfs_unstable [Procfs.Meminfo.Fields] |
|
nfs_unstable [Procfs.Meminfo] |
|
nice [Procfs.Process.Stat.Fields] |
|
nice [Procfs.Process.Stat] |
|
nice_priority [Procfs.Process.Limits.Fields] |
|
nice_priority [Procfs.Process.Limits] |
|
no_anons [Command.Helpers] |
|
no_arg [Fcommand] |
|
no_arg [Core_command.Deprecated.Spec] |
|
no_arg [Core_command.Spec] |
no_arg flags may be passed at most once.
|
no_arg_bool [Fcommand] |
|
no_arg_register [Core_command.Spec] |
no_arg_register ~key is like no_arg , but registers in
the auto-completion environment
|
noarg [Command.Flag.Action] |
an action for a flag that takes no additional argument
|
noarg [Command.Flag] |
|
noarg_acc [Command.Flag] |
|
noarg_mut [Command.Flag] |
|
noninteractive_no_hostkey_checking_options [Shell] |
|
noninteractive_ssh_options [Shell] |
|
normalize [Filename] |
normalize path
Removes as much "." and ".." from the path as possible.
|
notice [Loggers.LOGGER] |
|
np_pref [Rw_mutex] |
np_pref no preference for readers or writers.
|
nswap [Procfs.Process.Stat.Fields] |
|
nswap [Procfs.Process.Stat] |
|
nth [Lazy_list] |
|
null [Readline.History] |
A value which is always empty
|
number [Extended_list__multimerge] |
|
number [List] |
|
O |
of_arg [Command.Flag] |
|
of_array [Lazy_list] |
|
of_array [Iter] |
create an iterator that will go over array elements
|
of_array [Array.Access_control] |
|
of_array [Cbuffer] |
initialize Cbuffer from array
|
of_array_copy [Array.Access_control] |
|
of_channel [Iter] |
create an iterator that will read from file using f
|
of_core_command [Command] |
|
of_exec_env [Environment] |
|
of_exn [Exn.Exn_string] |
|
of_fun [Lazy_m] |
Create a lazy value of a function.
|
of_hashtbl [Hashtbl.Access_control] |
|
of_iterator [Lazy_list] |
|
of_line [Bin_io_utils] |
|
of_list [Readline.History] |
|
of_list [Lazy_sequence] |
|
of_list [Lazy_list] |
|
of_list [Iter] |
create an iterator that will go over list elements
|
of_list [Fold_map.S2] |
|
of_list [Fold_map.S] |
|
of_list [Array.Access_control] |
|
of_map [Fold_map.S2] |
|
of_map [Fold_map.S] |
|
of_opt [Iter] |
create an iterator that may iterate over one value
|
of_option [List] |
of_option o returns a list that is empty if o is None, otherwise it is a singleton
list.
|
of_passwd_file [Unix.Extended_passwd] |
of_passwd_file parse a passwd-like file
|
of_passwd_file_exn [Unix.Extended_passwd] |
of_passwd_file_exn parse a passwd-like file
|
of_passwd_line [Unix.Extended_passwd] |
of_passwd_line parse a passwd-like line
|
of_passwd_line_exn [Unix.Extended_passwd] |
of_passwd_line_exn parse a passwd-like line
|
of_regexp [Selector.String_selector.Regexp] |
|
of_sexp_allow_extra_fields [Sexp] |
of_sexp_allow_extra_fields of_sexp sexp uses of_sexp to convert sexp to a
value, but will not fail if there any extra fields in a record.
|
of_string [Procfs.Net.Dev] |
|
of_string [Procfs.Process.Inode] |
|
of_string [Int64.Filesize] |
|
of_val [Lazy_m] |
Create a lazy value of a non-lazy value.
|
ok [Result.Exn] |
ok t returns x if t = Ok x , or raises e if t = Error e .
|
old_only [Patience_diff] |
old_only hunks drops all New ranges from hunks and converts all Replace
ranges to Old ranges.
|
one [Procfs.Loadavg.Fields] |
|
one [Procfs.Loadavg] |
|
one [Float.Fraction] |
|
oom_adj [Procfs.Process.Fields] |
|
oom_adj [Procfs.Process] |
|
oom_score [Procfs.Process.Fields] |
|
oom_score [Procfs.Process] |
|
open_connection_tmout [Net_utils] |
Open a connection with timeouts
|
open_fd_connection_tmout [Net_utils] |
Create a socket with timeouts
|
open_files [Procfs.Process.Limits.Fields] |
|
open_files [Procfs.Process.Limits] |
|
openlog [Syslog] |
openlog ?id ?opt ?fac () opens a connection to the system logger
(possibly delayed) using prefixed identifier id , options opt ,
and faculty fac .
|
opt_of_sexp [Malloc] |
???
|
optional [Fcommand] |
|
optional [Core_command.Spec] |
optional flags may be passed at most once
|
optional [Command.Annotated_field] |
|
optional_with_default [Fcommand] |
|
optional_with_default [Core_command.Spec] |
optional_with_default flags may be passed at most once, and
default to a given value
|
order_of_magnitude_difference [Float] |
order_of_magnitude_difference a b
by how many orders of magnitude do a and b differ?
The return value is non-negative.
|
ounit_tests [Uuid] |
|
ounit_tests [Update_queue] |
|
ounit_tests [Unix_utils] |
|
ounit_tests [Trie] |
|
ounit_tests [Tcp] |
|
ounit_tests [Sys_utils] |
|
ounit_tests [Syslog] |
Print to stderr as well
|
ounit_tests [String_zipper] |
|
ounit_tests [Timed_function] |
|
ounit_tests [Std] |
|
ounit_tests [Sntp] |
|
ounit_tests [Shell__line_buffer] |
|
ounit_tests [Shell__core] |
|
ounit_tests [Shell] |
|
ounit_tests [Service_command] |
|
ounit_tests [Sendmail] |
|
ounit_tests [Semaphore] |
|
ounit_tests [Selector] |
|
ounit_tests [Search_foo] |
|
ounit_tests [Sampler] |
|
ounit_tests [Rw_mutex] |
|
ounit_tests [Runtime_blockout_detector] |
|
ounit_tests [Readline__input_loop] |
|
ounit_tests [Readline__input_char] |
|
ounit_tests [Readline] |
|
ounit_tests [Procfs] |
|
ounit_tests [Process] |
|
ounit_tests [Printc] |
alias for String.concat
|
ounit_tests [Pp] |
|
ounit_tests [Posix_clock] |
|
ounit_tests [Patience_diff] |
|
ounit_tests [Number] |
|
ounit_tests [Net_utils] |
|
ounit_tests [Multi_map] |
|
ounit_tests [Malloc] |
|
ounit_tests [Low_level_debug] |
|
ounit_tests [Loggers] |
|
ounit_tests [Logger] |
|
ounit_tests [List_zipper] |
|
ounit_tests [Linebuf] |
|
ounit_tests [Lazy_sequence] |
|
ounit_tests [Lazy_m] |
|
ounit_tests [Lazy_list] |
|
ounit_tests [Iter] |
|
ounit_tests [Hmap] |
|
ounit_tests [Fold_map] |
|
ounit_tests [Find] |
|
ounit_tests [Fd_leak_check] |
|
ounit_tests [Fcommand] |
|
ounit_tests [Extra_fields] |
|
ounit_tests [Unix] |
|
ounit_tests [Time] |
|
ounit_tests [Thread] |
|
ounit_tests [Sys] |
|
ounit_tests [String] |
|
ounit_tests [Sexp] |
|
ounit_tests [Result] |
Extension to the
|
ounit_tests [Nativeint] |
|
ounit_tests [Extended_monad] |
|
ounit_tests [Memo] |
|
ounit_tests [Extended_list__multimerge] |
|
ounit_tests [Extended_list__LCS] |
|
ounit_tests [List] |
|
ounit_tests [Extended_linux] |
|
ounit_tests [Int64] |
|
ounit_tests [Int63] |
|
ounit_tests [Int32] |
|
ounit_tests [Int] |
|
ounit_tests [Hashtbl] |
|
ounit_tests [Gc] |
|
ounit_tests [Fn] |
|
ounit_tests [Float] |
|
ounit_tests [Filename] |
normalize path
Removes as much "." and ".." from the path as possible.
|
ounit_tests [Exn] |
|
ounit_tests [Extended_common] |
|
ounit_tests [Array] |
|
ounit_tests [Exception_check] |
|
ounit_tests [Environment] |
|
ounit_tests [English] |
|
ounit_tests [Documented_match_statement] |
|
ounit_tests [Csv_writer] |
|
ounit_tests [Crit_bit] |
|
ounit_tests [Core_service_command] |
|
ounit_tests [Core_command] |
|
ounit_tests [Console] |
|
ounit_tests [Command] |
|
ounit_tests [Cbuffer] |
|
ounit_tests [Cache] |
|
ounit_tests [Bitarray] |
|
ounit_tests [Bin_io_utils] |
|
ounit_tests [Bench] |
|
ounit_tests [Atomic_edit] |
|
ounit_tests [Ascii_table] |
|
ounit_tests [Alternating_primary_backup_assignment] |
|
output [Console.Ansi] |
|
output [Ascii_table] |
The idea is that you have a Column.t list and a list of rows, where each
row contains the data for each column.
|
output_lines [Csv_writer] |
Prints a valid csv file to a given channel (note that line are ended
"\r\n")
|
output_string [Console.Ansi] |
|
P |
pad_left [String] |
pad_left ~char s len
Returns s padded to the length len by adding characters char to the
left of the string.
|
pad_right [String] |
|
page_contents [Sys_utils] |
page_contents ?pager ?tmp_name str will show str in a pager.
|
page_tables [Procfs.Meminfo.Fields] |
|
page_tables [Procfs.Meminfo] |
|
parent [Filename] |
parent path
The parent of the root directory is the root directory
|
parse_date [English] |
|
parse_int [English] |
parse_int s : Like standard int_of_string, but try to convert the first
twenty english numbers (eg.
|
parse_time [English] |
|
passno [Procfs.Mount.Fields] |
|
passno [Procfs.Mount] |
|
password [Readline] |
Prompts for a password.
|
path [Core_command.Spec] |
|
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 [Bench] |
|
print_diff [Sexp] |
|
print_list [Console] |
print a list in a columnize way (like the output of ls)
|
print_ranges [Patience_diff] |
|
printf [Console.Ansi] |
|
printl [Printc] |
|
priority [Procfs.Process.Stat.Fields] |
|
priority [Procfs.Process.Stat] |
|
processes [Procfs.Process.Limits.Fields] |
|
processes [Procfs.Process.Limits] |
|
processor [Procfs.Process.Stat.Fields] |
|
processor [Procfs.Process.Stat] |
|
progress [Iter] |
get the position in the iterator either None or Some x in 0;1
|
progress_string [Iter] |
convert the progress return value to a string: None->"", Some->" 33%"
|
protect [Lazy_sequence] |
|
Q |
query [Sntp] |
query hostname returns the difference between the clock on the
local host and the clock on the host specified by hostname .
|
quote_blit [Csv_writer] |
Copy and escapes the content of a field over from one string to
another.
|
quote_len [Csv_writer] |
Get the escaped length of one quoted field (without the quotes).
|
R |
r_lock [Rw_mutex] |
r_lock mtx locks mtx for a reader.
|
r_pref [Rw_mutex] |
r_pref preference kind for readers.
|
r_unlock [Rw_mutex] |
r_unlock mtx unlocks mtx for a reader.
|
ram_limit_spec [Unix_utils] |
ram_limit_spec command line arguments to set ram limits.
|
random [Float.Fraction] |
|
random_split [Array] |
makes a random split & subset of an array; p (the fraction that you want to split) is
constrained to be 0, 1 .
|
random_sub [Array] |
|
ratio [Patience_diff] |
|
read [Linebuf] |
Calls try_read every 0.01 seconds and returns when a line is available.
|
read_only [Update_queue] |
|
realtime_priority [Procfs.Process.Limits.Fields] |
|
realtime_priority [Procfs.Process.Limits] |
|
reduce [Multi_map] |
|
reduce [Iter] |
fold over the iterator: call f on each element and return the accumulator
|
refcnt [Procfs.Net.Route.Fields] |
|
refcnt [Procfs.Net.Route] |
|
remote [Shell.Process] |
|
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 [Fcommand] |
|
required [Core_command.Spec] |
required flags must be passed exactly once
|
required [Command.Annotated_field] |
|
reset [Linebuf] |
reopens the file and seeks to the beginning.
|
resident [Procfs.Process.Statm.Fields] |
|
resident [Procfs.Process.Statm] |
|
resident_set [Procfs.Process.Limits.Fields] |
|
resident_set [Procfs.Process.Limits] |
|
rest [Command.Flag.Action] |
rest f : an action for a flag that signals the end of flag
processing.
|
rest_acc [Command.Flag] |
|
rest_mut [Command.Flag] |
|
restart [Core_service_command] |
|
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 [Core_command.Deprecated] |
|
run [Core_command] |
run a command against Sys.argv
|
run [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.
|
running_byte_code [Sys] |
running_byte_code ()
|
rx_bytes [Procfs.Net.Dev.Fields] |
|
rx_bytes [Procfs.Net.Dev] |
|
rx_compressed [Procfs.Net.Dev.Fields] |
|
rx_compressed [Procfs.Net.Dev] |
|
rx_drop [Procfs.Net.Dev.Fields] |
|
rx_drop [Procfs.Net.Dev] |
|
rx_errs [Procfs.Net.Dev.Fields] |
|
rx_errs [Procfs.Net.Dev] |
|
rx_fifo [Procfs.Net.Dev.Fields] |
|
rx_fifo [Procfs.Net.Dev] |
|
rx_frame [Procfs.Net.Dev.Fields] |
|
rx_frame [Procfs.Net.Dev] |
|
rx_multicast [Procfs.Net.Dev.Fields] |
|
rx_multicast [Procfs.Net.Dev] |
|
rx_packets [Procfs.Net.Dev.Fields] |
|
rx_packets [Procfs.Net.Dev] |
|
S |
safe_create [Thread] |
Behaves like Thread.create but exits the program if an exception trickles
to the toplevel.
|
sample [Sampler] |
take a sample from the distribution in constant time
|
sample_size [Bench.Result] |
|
save [Bin_io_utils] |
|
save_cursor [Console.Ansi] |
|
scp [Shell] |
scp user host from to copy local file from to to
|
scroll_lock [Sys] |
scroll_lock false disables scroll locking.
|
select [Alternating_primary_backup_assignment] |
|
send [Sendmail] |
|
sequence [Core_command.Spec] |
(sequence name typ) specifies a sequence of anonymous arguments
of type typ .
|
session [Procfs.Process.Stat.Fields] |
|
session [Procfs.Process.Stat] |
|
set [Multi_map] |
|
set [Fold_map.S2] |
|
set [Fold_map.S] |
|
set [Hashtbl.Access_control] |
|
set [Array.Access_control] |
|
set [Command.Annotated_field] |
|
set [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 [Command.Flag] |
|
set_date_opt [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 [Command.Flag] |
|
set_float_opt [Command.Flag] |
|
set_gen [Command.Flag] |
|
set_gen_opt [Command.Flag] |
|
set_in_channel_timeout [Net_utils] |
Set a timeout for a socket associated with an in_channel
|
set_int [Command.Flag] |
|
set_int_opt [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 [Command.Flag] |
|
set_string_opt [Command.Flag] |
|
seteuid [Unix] |
|
setlogmask [Syslog] |
setlogmask ?levs ?from_lev ?to_lev () sets the log mask.
|
setresuid [Extended_linux] |
|
setreuid [Unix] |
|
sexp [Fcommand] |
|
sexp_of_any [Array.Access_control] |
|
sexp_of_bigint [Procfs] |
|
sexp_of_fd_stat [Procfs.Process.Fd] |
|
sexp_of_flag [Extended_linux.Splice] |
|
sexp_of_mallinfo [Malloc] |
|
sexp_of_opt [Malloc] |
|
sexp_of_statvfs [Unix] |
|
sexp_of_t [Trie.Key.Part] |
|
sexp_of_t [Selector.String_list_selector] |
|
sexp_of_t [Selector.String_selector.Regexp] |
|
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 [Sexp.Make_explicit_sexp_option] |
|
sexp_of_t [Result.Exn] |
|
sexp_of_t [Int64.Filesize] |
|
sexp_of_t [Cbuffer] |
|
sexp_of_uids [Extended_linux] |
|
sexp_of_value [Procfs.Process.Limits.Rlimit] |
|
sgid [Procfs.Process.Status.Fields] |
|
sgid [Procfs.Process.Status] |
|
sh [Shell] |
|
sh_full [Shell] |
|
sh_lines [Shell] |
|
sh_one [Shell] |
|
sh_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] |
|
slab [Procfs.Meminfo.Fields] |
|
slab [Procfs.Meminfo] |
|
slot_spec [Core_service_command.T] |
|
snoc [Lazy_list] |
|
soft [Procfs.Process.Limits.Rlimit.Fields] |
|
soft [Procfs.Process.Limits.Rlimit] |
|
sort [Lazy_list] |
|
spec [Procfs.Mount.Fields] |
|
spec [Procfs.Mount] |
|
splice [Extended_linux.Splice] |
splice ?assume_fd_is_nonblocking ~fd_in ?off_in ~fd_out ?off_out
~len flags see man-page for details.
|
split_while [List] |
split_while xs f splits xs into sublists ys and zs such that ys is
the longest prefix on which f is true, and zs is the remaining elements.
|
square [List] |
Takes a list of `key*`value lists and returns a
header * table_body body that is obtained by splitting the lists and
re-oddering the terms (so that they all have the same header).
|
square_unique [List] |
|
squeeze [String] |
squeeze str reduces all sequences of spaces, newlines, tables, and
carriage returns to single spaces.
|
ssh [Shell] |
|
ssh_full [Shell] |
|
ssh_lines [Shell] |
|
ssh_one [Shell] |
|
ssh_test [Shell] |
|
stack_size [Procfs.Process.Limits.Fields] |
|
stack_size [Procfs.Process.Limits] |
|
start [Runtime_blockout_detector] |
start starts a thread that watches for blockouts where the OCaml
lock isn't released.
|
start [Core_service_command] |
|
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.Process.Stat.Fields] |
|
state [Procfs.Process.Stat] |
|
statfs [Extended_linux] |
|
statm [Procfs.Process.Fields] |
|
statm [Procfs.Process] |
|
status [Procfs.Process.Fields] |
|
status [Procfs.Process] |
|
status [Core_service_command] |
|
status_to_string [Shell.Process] |
|
statvfs [Unix] |
get file system statistics
|
statvfs_of_sexp [Unix] |
|
stdev [Bench.Result] |
|
step [Readline__input_loop] |
|
step [Fcommand] |
step allows you to transform the way parameters are applied.
|
step [Core_command.Spec] |
step f is a very useful combinator for modifying the behavior of other
command line specifications.
|
stime [Procfs.Process.Stat.Fields] |
|
stime [Procfs.Process.Stat] |
|
stop [Lazy_sequence] |
|
stop [Core_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 [Fcommand] |
|
string [Core_command.Spec] |
|
string [Command.Flag] |
|
string_acc [Command.Flag] |
|
string_mut [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] |
|
suid [Procfs.Process.Status.Fields] |
|
suid [Procfs.Process.Status] |
|
summarize [Sexp] |
Returns a smaller sexp by replacing sections with "...".
|
summary [Core_command.Deprecated] |
|
supported_filesystems [Procfs] |
|
swap_array [Cbuffer] |
swap_array buf len copies the contents of buf to a new array of length
len and places that new data into the buffer
|
swap_cached [Procfs.Meminfo.Fields] |
|
swap_cached [Procfs.Meminfo] |
|
swap_free [Procfs.Meminfo.Fields] |
|
swap_free [Procfs.Meminfo] |
|
swap_total [Procfs.Meminfo.Fields] |
|
swap_total [Procfs.Meminfo] |
|
syslog [Syslog] |
syslog ?fac ?lev str logs message str using syslog with faculty
fac at level lev .
|
syslog_printf [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 [Fcommand] |
|
t2 [Core_command.Spec] |
|
t3 [Fcommand] |
|
t3 [Core_command.Spec] |
|
t4 [Fcommand] |
|
t4 [Core_command.Spec] |
|
t_of_sexp [Trie.Key.Part] |
|
t_of_sexp [Selector.String_list_selector] |
|
t_of_sexp [Selector.String_selector.Regexp] |
|
t_of_sexp [Selector.String_selector] |
|
t_of_sexp [Selector.Date_selector] |
|
t_of_sexp [Procfs.Meminfo] |
|
t_of_sexp [Procfs.Process.Fd] |
|
t_of_sexp [Procfs.Process.Status] |
|
t_of_sexp [Procfs.Process.Statm] |
|
t_of_sexp [Procfs.Process.Stat] |
|
t_of_sexp [Procfs.Process.Limits.Rlimit] |
|
t_of_sexp [Procfs.Process.Limits] |
|
t_of_sexp [Procfs.Process.Inode] |
|
t_of_sexp [Procfs.Process] |
|
t_of_sexp [Sexp.Make_explicit_sexp_option] |
|
t_of_sexp [Int64.Filesize] |
|
t_of_sexp [Cbuffer] |
|
tail [Linebuf] |
Seeks to the end of the file and blocks until another line is available -- this new
line is not returned.
|
take_while [List] |
take_while xs f produces the longest prefix of xs on which f is always true.
|
tall_box [Ascii_table.Display] |
|
task_stats [Procfs.Process.Fields] |
|
task_stats [Procfs.Process] |
|
tcp_socket [Net_utils] |
Create a standard TCP/IP-socket
|
tee [Extended_linux.Splice] |
tee ?assume_fd_is_nonblocking ~fd_in ~fd_out len flags see man-page
for details.
|
ten [Procfs.Loadavg.Fields] |
|
ten [Procfs.Loadavg] |
|
test [Shell.Process] |
|
test [Shell] |
|
test_k [Shell.Process] |
|
text [Procfs.Process.Statm.Fields] |
|
text [Procfs.Process.Statm] |
|
text [Pp] |
The text function turns a string into a document.
|
time_span [Core_command.Spec] |
|
timestamp [Logger] |
Returns a timestamp as a string suitable for log files
|
to_alist [Fold_map.S2] |
|
to_alist [Fold_map.S] |
|
to_alist [Hashtbl.Access_control] |
|
to_array [Lazy_list] |
|
to_array [Iter] |
iterate a function and collect results to a array
|
to_array [Cbuffer] |
|
to_array_copy [Array.Access_control] |
|
to_array_opt [Iter] |
|
to_exec_env [Environment] |
|
to_file [Pp] |
|
to_flag [Command.Annotated_field] |
|
to_line [Bin_io_utils] |
|
to_list [Readline.History] |
|
to_list [Procfs.Mount.Fields] |
|
to_list [Procfs.Net.Route.Fields] |
|
to_list [Procfs.Net.Dev.Fields] |
|
to_list [Procfs.Loadavg.Fields] |
|
to_list [Procfs.Meminfo.Fields] |
|
to_list [Procfs.Process.Fields] |
|
to_list [Procfs.Process.Fd.Fields] |
|
to_list [Procfs.Process.Status.Fields] |
|
to_list [Procfs.Process.Statm.Fields] |
|
to_list [Procfs.Process.Stat.Fields] |
|
to_list [Procfs.Process.Limits.Fields] |
|
to_list [Procfs.Process.Limits.Rlimit.Fields] |
|
to_list [Lazy_list] |
|
to_list [Iter] |
iterate a function and collect results to a list
|
to_list [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_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 [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_hum [Time.Extended_span] |
Convert a time span to a human-readable string, e.g.
|
to_string_hum [Float] |
|
to_string_hum [Exn] |
This is also an ever so slight variation of to_string target more at user
than developers (Failure s is just printed as s )
|
to_string_hum' [Sexp] |
The ocaml pretty printer (used by sexplib) is a speed daemon but is,
sadly enough, produces wrong output (e.g it overflows in places where this
could have avoided).
|
to_string_noattr [Ascii_table] |
|
top_command [Procfs.Process.Fields] |
|
top_command [Procfs.Process] |
|
touch [Cache.Strategy] |
Marks an element as "fresh".
|
tpgid [Procfs.Process.Stat.Fields] |
|
tpgid [Procfs.Process.Stat] |
|
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] |
|
U |
uid [Procfs.Process.Status.Fields] |
|
uid [Procfs.Process.Status] |
|
uids_of_sexp [Extended_linux] |
|
unescaped [String] |
unescaped s is the inverse operation of escaped : it takes a string where
all the special characters are escaped following the lexical convention of
OCaml and returns an unescaped copy.
|
unescaped_res [String] |
Same as unescaped but instead of raising Failure _ returns an error
message with the position in the string in case of failure.
|
unfold [Lazy_list] |
|
unfold [Iter] |
|
unified [Patience_diff] |
unified hunks converts all Replace ranges in hunks to an Old range
followed by a New range.
|
unify [Lazy_list] |
|
unit [Cache] |
Returns memoized version of any function with argument unit.
|
uniter [Lazy_list] |
|
unsafe_tail [Linebuf] |
Same as tail except it may return before a new line is available on the file
i.e.
|
unsave_cursor [Console.Ansi] |
|
unused [Procfs.Process.Stat.Fields] |
|
unused [Procfs.Process.Stat] |
|
unwrap [Exn] |
unwrap e
|
update_exn [Sys_utils.Cpu_use] |
cpu_use gives an estimated CPU usage (between 0 and 1) in the time period between
the last 2 calls to update_exn .
|
upper [Number.Verified_std.Bounded_spec] |
|
uptime [Procfs] |
|
use [Procfs.Net.Route.Fields] |
|
use [Procfs.Net.Route] |
|
utime [Procfs.Process.Stat.Fields] |
|
utime [Procfs.Process.Stat] |
|
V |
value_of_sexp [Procfs.Process.Limits.Rlimit] |
|
value_of_sexp__ [Procfs.Process.Limits.Rlimit] |
|
verify [Number.S] |
|
vfstype [Procfs.Mount.Fields] |
|
vfstype [Procfs.Mount] |
|
vgrp [Pp] |
The vgrp operator creates a vertical group.
|
vlist [Pp] |
vlist [x1,..,xn] = vgrp [x1; break; x2; ...; break; xn)
|
vmalloc_chunk [Procfs.Meminfo.Fields] |
|
vmalloc_chunk [Procfs.Meminfo] |
|
vmalloc_total [Procfs.Meminfo.Fields] |
|
vmalloc_total [Procfs.Meminfo] |
|
vmalloc_used [Procfs.Meminfo.Fields] |
|
vmalloc_used [Procfs.Meminfo] |
|
vmsplice [Extended_linux.Splice] |
vmsplice ?assume_fd_is_nonblocking fd iovecs ?count flags
see man-page for details.
|
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] |
|
Z |
zero [Number.Verified_std_spec] |
|
zero [Number.S0] |
|
zero [Fcommand] |
|