# Index of values

( * ) [Flang.Ordered_field] |
($) [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] |
(+) [Flang.Ordered_field] |
(++) [Deprecated_fcommand] | `spec1 ++ spec2` composes command-line specifications `spec1` and `spec2`.
(-) [Flang.Ordered_field] |
(/) [Flang.Ordered_field] |
(==>) [Lazy_sequence] |
(==>>) [Lazy_sequence] |
(>:) [Generic] |
(>>|) [Generic] |
(~%) [Printc] | alias for sprintf
(~:) [Printc] | alias for String.concat
__ [Generic] |
__bin_read_color__ [Color_print] |
__bin_read_elt__ [Packed_array.Basic] |
__bin_read_flag__ [Extended_linux.Splice] |
__bin_read_key__ [Packed_map.S] |
__bin_read_mallinfo__ [Malloc] |
__bin_read_opt__ [Malloc] |
__bin_read_statvfs__ [Extended_unix] |
__bin_read_t__ [Sys_utils.Lsb_release] |
__bin_read_t__ [Set_lang_intf.S_binable] |
__bin_read_t__ [Selector.Stable.String_list_selector.V1] |
__bin_read_t__ [Selector.Stable.String_selector.V1] |
__bin_read_t__ [Selector.Stable.String_selector.Regexp.V1] |
__bin_read_t__ [Selector.Stable.Date_selector.V1] |
__bin_read_t__ [Selector.String_list_selector] |
__bin_read_t__ [Selector.String_selector.Regexp] |
__bin_read_t__ [Selector.String_selector] |
__bin_read_t__ [Selector.Date_selector] |
__bin_read_t__ [Prod_or_test] |
__bin_read_t__ [Packed_map.Value] |
__bin_read_t__ [Packed_map.Key] |
__bin_read_t__ [Packed_map.S] |
__bin_read_t__ [Olang] |
__bin_read_t__ [Float_ref] |
__bin_read_t__ [Flang] |
__bin_read_t__ [Extended_unix.Mac_address] |
__bin_read_t__ [Extended_int64.Filesize] |
__bin_read_t__ [Bin_io_utils.Serialized.Make] |
__bin_read_t__ [Bin_io_utils.Serialized] |
__bin_read_uids__ [Extended_linux] |
__bin_read_value__ [Packed_map.S] |
__color_of_sexp__ [Color_print] |
__t_of_sexp__ [Prod_or_test] |
__t_of_sexp__ [Olang] |
__t_of_sexp__ [Interval_map_intf.Interval] |
__t_of_sexp__ [Flang] |
__value_of_sexp__ [Procfs.Process.Limits.Rlimit] |
A
abs [Flang] |
acquire_lock_exn [Service_command] | `acquire_lock_exn slot` locks `slot`.
active [Procfs.Meminfo.Fields] |
active [Procfs.Meminfo] |
add [Trie.S] |
add [Multi_map] |
add [Fold_map.S2] |
add [Fold_map.S] | `add m ~key ~data` adds the key to the value already bound to `key` in `m`.
add [Flang] |
add [Extended_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 [Hashtbl2_pair] |
add_exn [Hashtbl2] |
add_exn [Extended_hashtbl.Access_control] |
add_list [Flang] |
add_multi [Extended_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] |
age [Sys_utils.Cpu_use] |
agrp [Pp] | The automatic group `agrp` is the most versatile.
alist [Pp] |
all [Posix_clock] |
always [Quickcheck_deprecated] | generator that always returns given value
always [Interval_map_intf.M] | Create a sequence which has a single constant value across the whole sequence of keys.
always [Interval_map_intf.S] |
anon [Deprecated_fcommand] |
anon_pages [Procfs.Meminfo.Fields] |
anon_pages [Procfs.Meminfo] |
append [Lazy_sequence] |
append [Lazy_list] |
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 [Extended_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.
atoms [Flang] |
B
base [Set_lang_intf.S_lang] |
base [Set_lang] |
base [Flang] |
bash [Deprecated_command.Autocomplete] | `create actions command_line` gets the completion suggestions that bash's compgen would generate for the selected `actions` and the last word of the `command_line`.
bench [Deprecated_bench] |
bench_raw [Deprecated_bench] | `bench_raw` returns a list documenting the runtimes rather than printing to stdout.
bigint_of_sexp [Procfs] |
bin_color [Color_print] |
bin_elt [Packed_array.Basic] |
bin_flag [Extended_linux.Splice] |
bin_key [Packed_map.S] |
bin_mallinfo [Malloc] |
bin_opt [Malloc] | Malloc options
bin_read_color [Color_print] |
bin_read_elt [Packed_array.Basic] |
bin_read_flag [Extended_linux.Splice] |
bin_read_key [Packed_map.S] |
bin_read_mallinfo [Malloc] |
bin_read_opt [Malloc] |
bin_read_statvfs [Extended_unix] |
bin_read_t [Sys_utils.Lsb_release] |
bin_read_t [Set_lang_intf.S_binable] |
bin_read_t [Selector.Stable.String_list_selector.V1] |
bin_read_t [Selector.Stable.String_selector.V1] |
bin_read_t [Selector.Stable.String_selector.Regexp.V1] |
bin_read_t [Selector.Stable.Date_selector.V1] |
bin_read_t [Selector.String_list_selector] |
bin_read_t [Selector.String_selector.Regexp] |
bin_read_t [Selector.String_selector] |
bin_read_t [Selector.Date_selector] |
bin_read_t [Prod_or_test] |
bin_read_t [Packed_map.Value] |
bin_read_t [Packed_map.Key] |
bin_read_t [Packed_map.S] |
bin_read_t [Olang] |
bin_read_t [Float_ref] |
bin_read_t [Flang] |
bin_read_t [Extended_unix.Mac_address] |
bin_read_t [Extended_int64.Filesize] |
bin_read_t [Bin_io_utils.Serialized.Make] |
bin_read_t [Bin_io_utils.Serialized] |
bin_read_uids [Extended_linux] |
bin_read_value [Packed_map.S] |
bin_reader_color [Color_print] |
bin_reader_elt [Packed_array.Basic] |
bin_reader_flag [Extended_linux.Splice] |
bin_reader_key [Packed_map.S] |
bin_reader_mallinfo [Malloc] |
bin_reader_opt [Malloc] |
bin_reader_statvfs [Extended_unix] |
bin_reader_t [Sys_utils.Lsb_release] |
bin_reader_t [Set_lang_intf.S_binable] |
bin_reader_t [Selector.Stable.String_list_selector.V1] |
bin_reader_t [Selector.Stable.String_selector.V1] |
bin_reader_t [Selector.Stable.String_selector.Regexp.V1] |
bin_reader_t [Selector.Stable.Date_selector.V1] |
bin_reader_t [Selector.String_list_selector] |
bin_reader_t [Selector.String_selector.Regexp] |
bin_reader_t [Selector.String_selector] |
bin_reader_t [Selector.Date_selector] |
bin_reader_t [Prod_or_test] |
bin_reader_t [Packed_map.Value] |
bin_reader_t [Packed_map.Key] |
bin_reader_t [Packed_map.S] |
bin_reader_t [Olang] |
bin_reader_t [Float_ref] |
bin_reader_t [Flang] |
bin_reader_t [Extended_unix.Mac_address] |
bin_reader_t [Extended_int64.Filesize] |
bin_reader_t [Bin_io_utils.Serialized.Make] |
bin_reader_t [Bin_io_utils.Serialized] |
bin_reader_t_with_value [Bin_io_utils.Serialized.Make] |
bin_reader_t_with_value [Bin_io_utils.Serialized] | Deserializing requires actually constructing an `'a`, so this reader gives you access to that `'a`, rather than just throwing it away.
bin_reader_uids [Extended_linux] |
bin_reader_value [Packed_map.S] |
bin_size_color [Color_print] |
bin_size_elt [Packed_array.Basic] |
bin_size_flag [Extended_linux.Splice] |
bin_size_key [Packed_map.S] |
bin_size_mallinfo [Malloc] |
bin_size_opt [Malloc] |
bin_size_statvfs [Extended_unix] |
bin_size_t [Sys_utils.Lsb_release] |
bin_size_t [Set_lang_intf.S_binable] |
bin_size_t [Selector.Stable.String_list_selector.V1] |
bin_size_t [Selector.Stable.String_selector.V1] |
bin_size_t [Selector.Stable.String_selector.Regexp.V1] |
bin_size_t [Selector.Stable.Date_selector.V1] |
bin_size_t [Selector.String_list_selector] |
bin_size_t [Selector.String_selector.Regexp] |
bin_size_t [Selector.String_selector] |
bin_size_t [Selector.Date_selector] |
bin_size_t [Prod_or_test] |
bin_size_t [Packed_map.Value] |
bin_size_t [Packed_map.Key] |
bin_size_t [Packed_map.S] |
bin_size_t [Olang] |
bin_size_t [Float_ref] |
bin_size_t [Flang] |
bin_size_t [Extended_unix.Mac_address] |
bin_size_t [Extended_int64.Filesize] |
bin_size_t [Bin_io_utils.Serialized.Make] |
bin_size_t [Bin_io_utils.Serialized] |
bin_size_uids [Extended_linux] |
bin_size_value [Packed_map.S] |
bin_statvfs [Extended_unix] |
bin_t [Sys_utils.Lsb_release] |
bin_t [Set_lang_intf.S_binable] |
bin_t [Selector.Stable.String_list_selector.V1] |
bin_t [Selector.Stable.String_selector.V1] |
bin_t [Selector.Stable.String_selector.Regexp.V1] |
bin_t [Selector.Stable.Date_selector.V1] |
bin_t [Selector.String_list_selector] |
bin_t [Selector.String_selector.Regexp] |
bin_t [Selector.String_selector] |
bin_t [Selector.Date_selector] |
bin_t [Prod_or_test] |
bin_t [Packed_map.Value] |
bin_t [Packed_map.Key] |
bin_t [Packed_map.S] |
bin_t [Olang] |
bin_t [Float_ref] |
bin_t [Flang] |
bin_t [Extended_unix.Mac_address] |
bin_t [Extended_int64.Filesize] |
bin_t [Bin_io_utils.Serialized.Make] |
bin_t [Bin_io_utils.Serialized] |
bin_t_with_value [Bin_io_utils.Serialized.Make] |
bin_t_with_value [Bin_io_utils.Serialized] |
bin_uids [Extended_linux] |
bin_value [Packed_map.S] |
bin_write_color [Color_print] |
bin_write_elt [Packed_array.Basic] |
bin_write_flag [Extended_linux.Splice] |
bin_write_key [Packed_map.S] |
bin_write_mallinfo [Malloc] |
bin_write_opt [Malloc] |
bin_write_statvfs [Extended_unix] |
bin_write_t [Sys_utils.Lsb_release] |
bin_write_t [Set_lang_intf.S_binable] |
bin_write_t [Selector.Stable.String_list_selector.V1] |
bin_write_t [Selector.Stable.String_selector.V1] |
bin_write_t [Selector.Stable.String_selector.Regexp.V1] |
bin_write_t [Selector.Stable.Date_selector.V1] |
bin_write_t [Selector.String_list_selector] |
bin_write_t [Selector.String_selector.Regexp] |
bin_write_t [Selector.String_selector] |
bin_write_t [Selector.Date_selector] |
bin_write_t [Prod_or_test] |
bin_write_t [Packed_map.Value] |
bin_write_t [Packed_map.Key] |
bin_write_t [Packed_map.S] |
bin_write_t [Olang] |
bin_write_t [Float_ref] |
bin_write_t [Flang] |
bin_write_t [Extended_unix.Mac_address] |
bin_write_t [Extended_int64.Filesize] |
bin_write_t [Bin_io_utils.Serialized.Make] |
bin_write_t [Bin_io_utils.Serialized] |
bin_write_uids [Extended_linux] |
bin_write_value [Packed_map.S] |
bin_writer_color [Color_print] |
bin_writer_elt [Packed_array.Basic] |
bin_writer_flag [Extended_linux.Splice] |
bin_writer_key [Packed_map.S] |
bin_writer_mallinfo [Malloc] |
bin_writer_opt [Malloc] |
bin_writer_statvfs [Extended_unix] |
bin_writer_t [Sys_utils.Lsb_release] |
bin_writer_t [Set_lang_intf.S_binable] |
bin_writer_t [Selector.Stable.String_list_selector.V1] |
bin_writer_t [Selector.Stable.String_selector.V1] |
bin_writer_t [Selector.Stable.String_selector.Regexp.V1] |
bin_writer_t [Selector.Stable.Date_selector.V1] |
bin_writer_t [Selector.String_list_selector] |
bin_writer_t [Selector.String_selector.Regexp] |
bin_writer_t [Selector.String_selector] |
bin_writer_t [Selector.Date_selector] |
bin_writer_t [Prod_or_test] |
bin_writer_t [Packed_map.Value] |
bin_writer_t [Packed_map.Key] |
bin_writer_t [Packed_map.S] |
bin_writer_t [Olang] |
bin_writer_t [Float_ref] |
bin_writer_t [Flang] |
bin_writer_t [Extended_unix.Mac_address] |
bin_writer_t [Extended_int64.Filesize] |
bin_writer_t [Bin_io_utils.Serialized.Make] |
bin_writer_t [Bin_io_utils.Serialized] |
bin_writer_uids [Extended_linux] |
bin_writer_value [Packed_map.S] |
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] |
blue_sprintf [Color_print] |
blueprintf [Color_print] |
bold [Color_print] |
bold_sprintf [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 [Extended_unix.Quota] |
bytes_of_sexp [Extended_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] |
callback_with_stderr [Shell.Process] |
capture_remaining_command_line [Deprecated_fcommand] |
cartesian_product [Lazy_list] |
cb_compare [Cbuffer] | compare two buffer fragments
cg [Quickcheck_deprecated] | character generator
change [Interval_map_intf.M] | Insert a change point into the sequence of changes.
change [Interval_map_intf.S] |
change [Extended_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 [Extended_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 [Hashtbl2_pair] |
clear [Hashtbl2] |
clear [Extended_hashtbl.Access_control] |
clear [Deprecated_command.Annotated_field] |
clear [Deprecated_command.Flag] |
clear [Cache.S] |
clear [Cache.Store] | Remove all the values from the store.
clear [Cache.Strategy] | Inform the strategy that all the elements where dropped from the store.
clear [Cache.Keep_all] |
clear [Cache.Lru] |
clear [Bitarray] | `clear t` set the contents of every element to false O(n / (word_size - 2))
clear_filter [Logger] | removes the filter from a log
close [Linebuf] | Closes the line buffer (and the underlying file).
close [Lazy_sequence.Iterator] |
close [Find] | `close t` drops all the resources associated with t.
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 [Extended_string] | `collate s1 s2` sorts string in an order that's usaully more suited for human consumption by treating ints specially, e.g.
color [Color_print] |
color_of_sexp [Color_print] |
color_sprintf [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 [Extended_sexp] | Takes a string and returns the same string but commented according to sexp's syntax
commit_limit [Procfs.Meminfo.Fields] |
commit_limit [Procfs.Meminfo] |
committed_as [Procfs.Meminfo.Fields] |
committed_as [Procfs.Meminfo] |
compactions_occurred [Deprecated_bench.Result] |
compare [Trie.Key.Part] |
compare [Set_lang_intf.S_binable] |
compare [Set_lang_intf.S] |
compare [Set_lang.Raw] |
compare [Set_lang] |
compare [Prod_or_test] |
compare [Olang] |
compare [Left_boundary] |
compare [Interval_map_intf.M] | Comparison works lexicographically pointwise across the whole sequence (from -infty to +infty).
compare [Interval_map_intf.S_with_boundary.Left_boundary] |
compare [Interval_map_intf.S] |
compare [Interval_map_intf.Type_with_map_module.Map] |
compare [Interval_map_intf.Type_with_map_module] |
compare [Hashtbl2.Key] |
compare [Flang.Ordered_field] |
compare [Flang] |
compare [Extended_list] |
compare [Extended_filename] | Filename.compare is a comparison that normalizes filenames ("./a" = "a"), uses a more human ready algorithm based on `String.collate` ("rfc02.txt > rfc1.txt") and extenstions ("a.c" > "a.h").
concat [Packed_array.Of_packed_array] |
concat [Lazy_sequence] |
concat [Lazy_list] |
concat [Iter] | concatenate a list of iterators
concat_list [Lazy_list] |
concat_list_seq [Lazy_sequence] |
concat_map [Lazy_sequence] |
concat_seq_list [Lazy_sequence] |
confirm [Readline] | Prompts for an answer.
connect_tmout [Net_utils] | Connect a socket with a connect timeout
cons [Lazy_list] |
const [Deprecated_fcommand] |
constant_value [Set_lang_intf.S_lang] |
constant_value [Set_lang] |
construct_preimage [Interval_map_intf.M] | Construct a preimage of the sequence.
construct_preimage [Interval_map_intf.S] |
contains [Trie.S] |
contains [Interval_map_intf.S.Interval] |
contains [Interval_map_intf.Interval] |
content [Shell.Process] |
content_and_stderr [Shell.Process] |
contents [String_zipper] |
contents [Readline__input_loop] |
copy [Lazy_sequence.Iterator] |
copy [Extended_hashtbl.Access_control] |
copy_data [Cbuffer] | copies data from one array to another.
core_file_size [Procfs.Process.Limits.Fields] |
core_file_size [Procfs.Process.Limits] |
cp [Shell] |
cps_create [Cache.Store] | `cps_create` is given in CPS form to enable chaining.
cps_create [Cache.Strategy] | `cps_create ~f` is given in CPS form to enable chaining.
cpu_t_of_sexp [Procfs.Kstat] |
cpu_time [Procfs.Process.Limits.Fields] |
cpu_time [Procfs.Process.Limits] |
cpu_use [Sys_utils.Cpu_use] | `cpu_use` gives an estimated CPU usage (between 0 and 1) in the time period between the last 2 calls to `update_exn`.
create [Update_queue] |
create [Trie.S] |
create [Sys_utils.Lsb_release.Fields] |
create [String_zipper] |
create [Shell__line_buffer] | `create ~eol f` Create a new line buffer where f will be called once on every line.
create [Sampler] | `create dist` compiles a discrete probability distribution into a form supporting constant-time sampling.
create [Rw_mutex] | `create pref`
create [Readline__input_loop] |
create [Readline.History] |
create [Random_selection] | `create ~random_state desired_sample_size` creates an empty sample of `'a` values.
create [Procfs.Mount.Fields] |
create [Procfs.Net.Tcp.Fields] |
create [Procfs.Net.Route.Fields] |
create [Procfs.Net.Dev.Fields] |
create [Procfs.Loadavg.Fields] |
create [Procfs.Kstat.Fields_of_cpu_t] |
create [Procfs.Meminfo.Fields] |
create [Procfs.Process.Fields] |
create [Procfs.Process.Fd.Fields] |
create [Procfs.Process.Status.Fields] |
create [Procfs.Process.Statm.Fields] |
create [Procfs.Process.Stat.Fields] |
create [Procfs.Process.Limits.Fields] |
create [Procfs.Process.Limits.Rlimit.Fields] |

create [Logger]

- max_size - the maximum size of each log file (default 50Mb) mode - mode to open the files in, max_archives - maximum number of archives to keep (default 4), full_callback - called when the logger queue backs up so far that log items may have been lost. Defaults to doing nothing., filter - if set, then every message is passed to filter before actually being logged. If filter returns false the message is dropped., message_to_string - called to convert your message type to a string for logging

create [List_zipper] |
create [Linebuf] | Open a line buffer from the passed filename.
create [Lazy_sequence.Iterator] |
create [Lazy_list.Iterator] |
create [Interval_map_intf.M] | Create a sequence with a specified far-leftmost value, and sequence of change points.
create [Interval_map_intf.S] |
create [Hashtbl2_pair.Make] |
create [Hashtbl2.Make] |
create [Float_ref] | Create a `t` with the given initial value.
create [Find] | `create ?options dir` create a Find.t based in dir
create [Exception_check] | create should not be called more than once
create [Deprecated_command.Flags_ext] |
create [Deprecated_command.Flag] |
create [Deprecated_command] |
create [Deprecated_bench.Test] |
create [Cbuffer] |
create [Cache.S] |
create [Cache.Keep_all] |
create [Cache.Lru] |
create [Bitarray] | `create size` size must be less than ((word size - 2) * max array length)
create [Bin_io_utils.Serialized.Make] |
create [Bin_io_utils.Serialized] |
create0 [Deprecated_command] |
create_choice [Deprecated_command.Flags_ext] |
create_choice_optional [Deprecated_command.Flags_ext] |
create_default [Logger] | creates a log using the default message type and a filter that drops `Debug messages
create_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] |
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] |
cyan_sprintf [Color_print] |
cyanprintf [Color_print] |
D
data [Splay_tree.S] |
data [Procfs.Process.Statm.Fields] |
data [Procfs.Process.Statm] |
data [Fold_map.S2] |
data [Fold_map.S] |
data [Extended_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.
decons [Lazy_list] |
default [Readline.History] |
default [Procfs.Net.Route] |
default [Find.Options] |
default [Deprecated_command.Annotated_field] |
delete [Splay_tree.S] |
delete_after [Splay_tree.S] |
delete_before [Splay_tree.S] |
delete_max [Splay_tree.S] |
delete_min [Splay_tree.S] |
desired_sample_size [Random_selection] | the desired sample size
destination [Procfs.Net.Route.Fields] |
destination [Procfs.Net.Route] |
diff [Sys_utils] | `diff s1 s2` returns diff (1) output of the two strings.
diff [Set_lang_intf.S_lang] |
diff [Set_lang] |
diff [Posix_clock.Time_stamp_counter] |
directory [Extended_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] |
div [Flang] |
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 [Extended_unix.Mount_entry] |
E
edit [Sys_utils.Sexp_checked_edit] |
edit_distance [Extended_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] |
empty [Splay_tree.S] |
empty [Pp] | The empty document is pretty printed to the empty string.
empty [Packed_map.S] |
empty [Packed_array.S] |
empty [Multi_map] |
empty [Lazy_sequence] |
empty [Lazy_list] |
empty [Iter] | an iterator that halts immediately
empty [Fold_map.S2] |
empty [Fold_map.S] | A map containing no bindings
empty [Deprecated_fcommand] |
empty [Deprecated_bench.Result.Stat] |
empty [Crit_bit] |
endcode [Procfs.Process.Stat.Fields] |
endcode [Procfs.Process.Stat] |
enqueue [Update_queue] |
ensure_at_exit [Unix_utils] | `ensure_at_exit ()`: catch all signals, run at_exit functions, then re-deliver the signal to self to ensure the default behavior.
enumerate_from [Extended_list] | `enumerate_from n xs` returns a list of pairs constructed by pairing an incrementing counter, starting at `n`, with the elements of `xs`.
environ [Procfs.Process.Fields] |
environ [Procfs.Process] |
eprint [Printc] |
eprintl [Printc] |
equal [Extended_unix.Mac_address] |
equal [Extended_list] |
equal [Extended_hashtbl.Access_control] |
error [Generic] |
escape_field [Csv_writer] | Escape a CSV (even if doesn't have any characters that require escaping).
euid [Procfs.Process.Status.Fields] |
euid [Procfs.Process.Status] |
eval [Set_lang_intf.S_eval] |
eval [Set_lang.Make_monadic_eval] |
eval [Set_lang] |
eval [Selector.Selector] |
eval [Olang] |
eval [Flang.Eval] |
exe [Procfs.Process.Fields] |
exe [Procfs.Process] |
exists [Sys_utils.Lsb_release.Fields] |
exists [Procfs.Mount.Fields] |
exists [Procfs.Net.Tcp.Fields] |
exists [Procfs.Net.Route.Fields] |
exists [Procfs.Net.Dev.Fields] |
exists [Procfs.Loadavg.Fields] |
exists [Procfs.Kstat.Fields_of_cpu_t] |
exists [Procfs.Meminfo.Fields] |
exists [Procfs.Process.Fields] |
exists [Procfs.Process.Fd.Fields] |
exists [Procfs.Process.Status.Fields] |
exists [Procfs.Process.Statm.Fields] |
exists [Procfs.Process.Stat.Fields] |
exists [Procfs.Process.Limits.Fields] |
exists [Procfs.Process.Limits.Rlimit.Fields] |
exists [Iter] |
exists [Fold_map.S2] |
exists [Fold_map.S] |
exists [Extended_hashtbl.Access_control] |
existsi [Extended_hashtbl.Access_control] |
exit_signal [Procfs.Process.Stat.Fields] |
exit_signal [Procfs.Process.Stat] |
expand [Extended_filename] | `expand` Makes a path absolute and expands `~` `~username` to home directories.
expand [Cbuffer] | double the size of the buffer
explode [Extended_filename] | Splits a given path into a list of strings.
extra_path [Shell__core] |
extra_path [Shell] | variable used by dispatch command to find binaries not in the path.
extract_command [Procfs.Process.Stat] |
F
f [Fold_map.Foldable2] |
f [Fold_map.Foldable] | The folding function.
f2s [Printc] |
fd [Procfs.Process.Fd.Fields] |
fd [Procfs.Process.Fd] |
fd_stat [Procfs.Process.Fd.Fields] |
fd_stat [Procfs.Process.Fd] |
fd_stat_of_sexp [Procfs.Process.Fd] |
fds [Sys_utils.Cpu_use] |
fds [Procfs.Process.Fields] |
fds [Procfs.Process] |
fg [Quickcheck_deprecated] | float generator (no nan, inf, etc.)
fgrp [Pp] | The break policy inside an `agrp` is fixed for all breaks of the group.
fifteen [Procfs.Loadavg.Fields] |
fifteen [Procfs.Loadavg] |
file [Procfs.Mount.Fields] |
file [Procfs.Mount] |
file_kind [Extended_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 [Extended_sys] |
file_size_exn [Extended_sys] |
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 [Extended_hashtbl.Access_control] |
filter_fold_map [Lazy_sequence] |
filter_inplace [Extended_hashtbl.Access_control] |
filter_map [Lazy_sequence] |
filter_map [Lazy_list] |
filter_map [Extended_hashtbl.Access_control] |
filter_map_partial [Lazy_sequence] |
filter_mapi [Lazy_sequence] |
filter_mapi [Extended_hashtbl.Access_control] |
filter_opt [Lazy_list] |
filteri [Extended_hashtbl.Access_control] |
filteri_inplace [Extended_hashtbl.Access_control] |
find [Splay_tree.S] |
find [Packed_map.S] |
find [Multi_map] | `find m key` returns all the elements that where added to `key` in `m` in the reverse order in which they where added.
find [Lazy_list] |
find [Iter] | find an element that satisfies the predicate
find [Interval_map_intf.M] | Find the value associated with some point along the sequence of keys.
find [Interval_map_intf.S] |
find [Hashtbl2_pair] |
find [Hashtbl2] |
find [Fold_map.S2] |
find [Fold_map.S] |
find [Extended_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' [Interval_map_intf.S_with_boundary] | Finding the value for an unwrapped key in an interval map based on wrapped keys means searching for the value at the point `Inclusive k`, because the point `Exclusive k` should not apply for keys equal to `k`.
find1 [Hashtbl2_pair] |
find1 [Hashtbl2] |
find1_iter2 [Hashtbl2_pair] |
find2 [Hashtbl2_pair] |
find2_iter1 [Hashtbl2_pair] |
find_all [Find] | `find_all ?options dir` short for to_list (create ?options dir)
find_exn [Extended_hashtbl.Access_control] |
find_exn [Environment] |
find_or_add [Extended_hashtbl.Access_control] |
first [String_zipper] |
flag [Deprecated_fcommand] |
flag [Deprecated_command.Flags_ext] |
flag_of_sexp [Extended_linux.Splice] |
flags [Procfs.Net.Route.Fields] |
flags [Procfs.Net.Route] |
flags [Procfs.Process.Stat.Fields] |
flags [Procfs.Process.Stat] |
float [Deprecated_fcommand] |
float [Deprecated_command.Flag.Action] | an action for a flag that takes an additional float argument
float [Deprecated_command.Flag] |
float_acc [Deprecated_command.Flag] |
float_mut [Deprecated_command.Flag] |
flush [Shell__line_buffer] | `flush b` Flushes any pending output to the callback function.
flush [Readline.History] |
fold [Sys_utils.Lsb_release.Fields.Direct] |
fold [Sys_utils.Lsb_release.Fields] |
fold [Procfs.Mount.Fields.Direct] |
fold [Procfs.Mount.Fields] |
fold [Procfs.Net.Tcp.Fields.Direct] |
fold [Procfs.Net.Tcp.Fields] |
fold [Procfs.Net.Route.Fields.Direct] |
fold [Procfs.Net.Route.Fields] |
fold [Procfs.Net.Dev.Fields.Direct] |
fold [Procfs.Net.Dev.Fields] |
fold [Procfs.Loadavg.Fields.Direct] |
fold [Procfs.Loadavg.Fields] |
fold [Procfs.Kstat.Fields_of_cpu_t.Direct] |
fold [Procfs.Kstat.Fields_of_cpu_t] |
fold [Procfs.Meminfo.Fields.Direct] |
fold [Procfs.Meminfo.Fields] |
fold [Procfs.Process.Fields.Direct] |
fold [Procfs.Process.Fields] |
fold [Procfs.Process.Fd.Fields.Direct] |
fold [Procfs.Process.Fd.Fields] |
fold [Procfs.Process.Status.Fields.Direct] |
fold [Procfs.Process.Status.Fields] |
fold [Procfs.Process.Statm.Fields.Direct] |
fold [Procfs.Process.Statm.Fields] |
fold [Procfs.Process.Stat.Fields.Direct] |
fold [Procfs.Process.Stat.Fields] |
fold [Procfs.Process.Limits.Fields.Direct] |
fold [Procfs.Process.Limits.Fields] |
fold [Procfs.Process.Limits.Rlimit.Fields.Direct] |
fold [Procfs.Process.Limits.Rlimit.Fields] |
fold [Packed_map.S] |
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 [Extended_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 [Extended_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 [Extended_array] |
foldr [Lazy_list] |
for_all [Sys_utils.Lsb_release.Fields] |
for_all [Procfs.Mount.Fields] |
for_all [Procfs.Net.Tcp.Fields] |
for_all [Procfs.Net.Route.Fields] |
for_all [Procfs.Net.Dev.Fields] |
for_all [Procfs.Loadavg.Fields] |
for_all [Procfs.Kstat.Fields_of_cpu_t] |
for_all [Procfs.Meminfo.Fields] |
for_all [Procfs.Process.Fields] |
for_all [Procfs.Process.Fd.Fields] |
for_all [Procfs.Process.Status.Fields] |
for_all [Procfs.Process.Statm.Fields] |
for_all [Procfs.Process.Stat.Fields] |
for_all [Procfs.Process.Limits.Fields] |
for_all [Procfs.Process.Limits.Rlimit.Fields] |
for_all [Iter] | evaluate a predicate over the entire iterator
for_all [Fold_map.S2] |
for_all [Fold_map.S] |
force [Lazy_sequence] |
force [Lazy_m] | Force the lazy value.
fork_exec [Extended_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 [Extended_time.Extended_date] | Shortcut for calling Core_extended.Unix.strftime without having to create a Time.t and convert it to a Unix.tm.
format [Extended_sexp] |
format_failed [Shell.Process] |
fprint [Printc] |
fprintl [Printc] |
freq [Procfs.Mount.Fields] |
freq [Procfs.Mount] |
fsck_pass [Extended_unix.Mount_entry] |
fsgid [Procfs.Process.Status.Fields] |
fsgid [Procfs.Process.Status] |
fsname [Extended_unix.Mount_entry] |
fstype [Extended_unix.Mount_entry] |
fsuid [Procfs.Process.Status.Fields] |
fsuid [Procfs.Process.Status] |
full [Invocation] |
G
gateway [Procfs.Net.Route.Fields] |
gateway [Procfs.Net.Route] |
gcd [Extended_int] | Computes greatest common divisor for the given two integers, with convention that `gcd 0 0 = 0`.
gen [Deprecated_command.Flag] |
gen_acc [Deprecated_command.Flag] |
gen_mut [Deprecated_command.Flag] |
general_rec [Extended_memo] | A version of `Memo.general` more suitable for memoizing recursively-defined functions
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 [Float_ref] |
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_list [Deprecated_command.Annotated_field] |
get_num_open_fds [Fd_leak_check] |
get_opt [Deprecated_command.Annotated_field] |
get_pager [Sys_utils] | Analogous to `get_editor`, defaulting to a list including less and more.
get_ppids [Unix_utils] | `get_ppids pid` returns the list of parent pids, up to init (1) for pid.
getbyname_ip [Sys_utils] | `getbyname_ip ()` returns the IP of the current host by resolving the hostname.
getloadavg [Extended_unix] | get load averages
getres [Posix_clock] |
getresuid [Extended_linux] |
gettime [Posix_clock] |
gid [Procfs.Process.Status.Fields] |
gid [Procfs.Process.Status] |
gray [Color_print] |
gray_sprintf [Color_print] |
grayprintf [Color_print] |
green [Color_print] |
green_sprintf [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 [Extended_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] |
hash [Hashtbl2.Key] |
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 [Extended_sys] | Get the home of the effective user
hostname [Extended_sys] |
htonl [Extended_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 [Extended_filename] | dual to explode
import_from_sys [Environment] |
in_order [Search_foo] |
inactive [Procfs.Meminfo.Fields] |
inactive [Procfs.Meminfo] |
incr [Extended_hashtbl.Access_control] |
index_t_of_sexp [Procfs.Kstat] |
inet_addr_of_sockaddr [Net_utils] | Get inet_addr from sockaddr
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 [Deprecated_command.Annotated_field] |
initialize [Lazy_sequence] |
inode [Procfs.Net.Tcp.Fields] |
inode [Procfs.Net.Tcp] |
inodes [Extended_unix.Quota] |
inodes_of_sexp [Extended_unix.Quota] |
input_all_with_reused_buffer [Procfs] |
input_line [Readline] |
input_line_eof [Readline] |
insert_after [String_zipper] |
insert_after [List_zipper] |
insert_before [String_zipper] |
insert_before [List_zipper] |
int [Deprecated_fcommand] |
int [Deprecated_command.Flag.Action] | an action for a flag that takes an additional int argument
int [Deprecated_command.Flag] |
int_acc [Deprecated_command.Flag] |
int_mut [Deprecated_command.Flag] |
inter [Set_lang_intf.S_lang] |
inter [Set_lang] |
inter2 [Set_lang_intf.S_lang] |
inter2 [Set_lang] |
inter_list [Set_lang_intf.S_lang] |
inter_list [Set_lang] |
inter_list_exn [Set_lang_intf.S_lang] |
inter_list_exn [Set_lang] |
interfaces [Procfs.Net.Dev] |
invariant [Set_lang] |
invariant [Invariant.S3] |
invariant [Invariant.S2] |
invariant [Invariant.S1] |
inverse [Color_print] |
inverse_sprintf [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 [Extended_sexp] |
is_closed [Linebuf] | Returns whether or not the line buffer is closed
is_empty [Splay_tree.S] |
is_empty [Multi_map] |
is_empty [Lazy_list] |
is_empty [Interval_map_intf.S.Interval] |
is_empty [Interval_map_intf.Interval] |
is_empty [Fold_map.S2] |
is_empty [Fold_map.S] |
is_empty [Extended_hashtbl.Access_control] |
is_executable [Shell__core] |
is_full [Cbuffer] |
is_list [Extended_sexp] |
is_parent [Extended_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_deprecated [Extended_string] | Use Core.Std.String.is_substring instead of this function.
is_test [Prod_or_test] |
is_val [Lazy_m] | Returns true if the lazy value has been forced and did not throw an exception.
iter [Trie.Key] |
iter [Sys_utils.Lsb_release.Fields.Direct] |
iter [Sys_utils.Lsb_release.Fields] |
iter [Procfs.Mount.Fields.Direct] |
iter [Procfs.Mount.Fields] |
iter [Procfs.Net.Tcp.Fields.Direct] |
iter [Procfs.Net.Tcp.Fields] |
iter [Procfs.Net.Route.Fields.Direct] |
iter [Procfs.Net.Route.Fields] |
iter [Procfs.Net.Dev.Fields.Direct] |
iter [Procfs.Net.Dev.Fields] |
iter [Procfs.Loadavg.Fields.Direct] |
iter [Procfs.Loadavg.Fields] |
iter [Procfs.Kstat.Fields_of_cpu_t.Direct] |
iter [Procfs.Kstat.Fields_of_cpu_t] |
iter [Procfs.Meminfo.Fields.Direct] |
iter [Procfs.Meminfo.Fields] |
iter [Procfs.Process.Fields.Direct] |
iter [Procfs.Process.Fields] |
iter [Procfs.Process.Fd.Fields.Direct] |
iter [Procfs.Process.Fd.Fields] |
iter [Procfs.Process.Status.Fields.Direct] |
iter [Procfs.Process.Status.Fields] |
iter [Procfs.Process.Statm.Fields.Direct] |
iter [Procfs.Process.Statm.Fields] |
iter [Procfs.Process.Stat.Fields.Direct] |
iter [Procfs.Process.Stat.Fields] |
iter [Procfs.Process.Limits.Fields.Direct] |
iter [Procfs.Process.Limits.Fields] |
iter [Procfs.Process.Limits.Rlimit.Fields.Direct] |
iter [Procfs.Process.Limits.Rlimit.Fields] |
iter [Packed_map.S] |
iter [Packed_array.S] |
iter [Multi_map] |
iter [Lazy_sequence.Iterator] |
iter [Lazy_list.Iterator] |
iter [Lazy_list] |
iter [Hashtbl2_pair] |
iter [Hashtbl2] |
iter [Generic] |
iter [Fold_map.S2] |
iter [Fold_map.S] |
iter [Find] | `iter t ~f` calls f on every file in t
iter [Extended_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_key2 [Hashtbl2] | `iter_key2 t key1 ~f` is a no-op unless `mem1 t key1` *
iter_vals [Extended_hashtbl.Access_control] |
iteri [Lazy_sequence] |
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 [Splay_tree.S] |
key_of_sexp [Packed_map.S] |
keys [Splay_tree.S] |
keys [Multi_map] | Returns all the non-empty keys in `m`.
keys [Fold_map.S2] |
keys [Fold_map.S] |
keys [Extended_hashtbl.Access_control] |
kill [Process] | kills a process by sending `signal`; waiting for `wait_for` and then sending a `sigkill`.
kstkeip [Procfs.Process.Stat.Fields] |
kstkeip [Procfs.Process.Stat] |
kstkesp [Procfs.Process.Stat.Fields] |
kstkesp [Procfs.Process.Stat] |
L
last [String_zipper] |
last [Lazy_sequence] |
last_accessed [Extended_sys] | `last_accessed path` returns the time `path` was last accessed.
last_accessed_exn [Extended_sys] |
last_changed [Extended_sys] | `last_changed path` returns the time `path` last had its status changed.
last_changed_exn [Extended_sys] |
last_modified [Extended_sys] | `last_modify path` returns the time the file at `path` was last modified.
last_modified_exn [Extended_sys] |
laws [Quickcheck_deprecated] | `laws iter gen func` applies `func` repeatedly (`iter` times) on output of `gen`, and if `func` ever returns false, then the input that caused the failure is returned optionally.
laws_exn [Quickcheck_deprecated] | Like laws, but throws an exception instead of returning an option.
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 [Extended_list] | Find the longest common subsequence between two list.
left_contents [String_zipper] |
length [Splay_tree.S] |
length [Packed_array.Basic] |
length [Lazy_list] |
length [Generic] |
length [Fold_map.S2] |
length [Fold_map.S] |
length [Extended_hashtbl.Access_control] |
length [Cbuffer] |
length_bounded_by [Lazy_sequence] |
length_if_at_most [Lazy_sequence] |
lg [Quickcheck_deprecated] | list generator
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 [Extended_unix.Quota] |
limits [Procfs.Process.Fields] |
limits [Procfs.Process] |
line_break [Extended_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 [Extended_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 [Extended_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
look [Semaphore] | `look sem`
lower [Number.Verified_std.Bounded_spec] |
lpad [Printc] |
ls [Extended_sys] |
M
magenta [Color_print] |
magenta_sprintf [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 [Extended_filename] | `make_absolute src` Turn `src` into an absolute path expanded from the current working directory.
make_creator [Sys_utils.Lsb_release.Fields] |
make_creator [Procfs.Mount.Fields] |
make_creator [Procfs.Net.Tcp.Fields] |
make_creator [Procfs.Net.Route.Fields] |
make_creator [Procfs.Net.Dev.Fields] |
make_creator [Procfs.Loadavg.Fields] |
make_creator [Procfs.Kstat.Fields_of_cpu_t] |
make_creator [Procfs.Meminfo.Fields] |
make_creator [Procfs.Process.Fields] |
make_creator [Procfs.Process.Fd.Fields] |
make_creator [Procfs.Process.Status.Fields] |
make_creator [Procfs.Process.Statm.Fields] |
make_creator [Procfs.Process.Stat.Fields] |
make_creator [Procfs.Process.Limits.Fields] |
make_creator [Procfs.Process.Limits.Rlimit.Fields] |
make_flags [Extended_linux.Splice] | `make_flags ar`
make_relative [Extended_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 [Splay_tree.S] |
map [Set_lang_intf.S_eval] |
map [Set_lang.Make_monadic_eval] |
map [Set_lang] |
map [Procfs.Mount.Fields] |
map [Procfs.Net.Tcp.Fields] |
map [Procfs.Net.Route.Fields] |
map [Procfs.Net.Dev.Fields] |
map [Procfs.Loadavg.Fields] |
map [Procfs.Kstat.Fields_of_cpu_t] |
map [Procfs.Meminfo.Fields] |
map [Procfs.Process.Fields] |
map [Procfs.Process.Fd.Fields] |
map [Procfs.Process.Status.Fields] |
map [Procfs.Process.Statm.Fields] |
map [Procfs.Process.Stat.Fields] |
map [Procfs.Process.Limits.Fields] |
map [Procfs.Process.Limits.Rlimit.Fields] |
map [Multi_map] |
map [Lazy_sequence] |
map [Lazy_list] |
map [Iter] | transform the iterator
map [Interval_map_intf.M] | Apply a function to all values within the sequence.
map [Interval_map_intf.S] |
map [Generic] |
map [Extended_hashtbl.Access_control] |
map [Documented_match_statement] |
map [Deprecated_fcommand.Anons] |
map [Deprecated_fcommand.Flag] |
map [Crit_bit] |
map2 [Interval_map_intf.M] | Create a sequence whose value at all points is taken by applying a function to the values of two other sequences at that point.
map2 [Interval_map_intf.S] |
map_accum [Extended_list] | A combination of `map` and `fold`.
map_case [Documented_match_statement] |
map_cases [Documented_match_statement] |
map_monad [Extended_monad.S2] |
map_monad [Extended_monad.S] |
map_monad [Extended_monad.Make2] |
map_monad [Extended_monad.Make] |
map_monad_ignore [Extended_monad.S2] |
map_monad_ignore [Extended_monad.S] |
map_monad_ignore [Extended_monad.Make2] |
map_monad_ignore [Extended_monad.Make] |
map_pattern [Documented_match_statement] |
map_poly [Sys_utils.Lsb_release.Fields] |
map_poly [Procfs.Mount.Fields] |
map_poly [Procfs.Net.Tcp.Fields] |
map_poly [Procfs.Net.Route.Fields] |
map_poly [Procfs.Net.Dev.Fields] |
map_poly [Procfs.Loadavg.Fields] |
map_poly [Procfs.Kstat.Fields_of_cpu_t] |
map_poly [Procfs.Meminfo.Fields] |
map_poly [Procfs.Process.Fields] |
map_poly [Procfs.Process.Fd.Fields] |
map_poly [Procfs.Process.Status.Fields] |
map_poly [Procfs.Process.Statm.Fields] |
map_poly [Procfs.Process.Stat.Fields] |
map_poly [Procfs.Process.Limits.Fields] |
map_poly [Procfs.Process.Limits.Rlimit.Fields] |
map_range [Splay_tree.S] |
map_within [Interval_map_intf.M] | `map_within t interval ~f` modifies the sequence similarly to set_within, except that it applies a function to the range rather than a constant value (i.e.
map_within [Interval_map_intf.S] |
mapi [Multi_map] |
mapi [Lazy_sequence] |
mapi [Extended_hashtbl.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 [Flang] |
max [Extended_list] |
max [Deprecated_bench.Result] |
max_exn [Extended_list] |
max_len [Search_foo] |
maxf [Search_foo] |
maybe [Deprecated_fcommand] |
maybe_add [Random_selection] | `maybe_add t x` will randomly either add `x` to `t` or ignore it.
maybe_escape_field [Csv_writer] | Escape the a CSV field if need be.
maybe_log [Logger] | logs a message to Some log, returns silently if log is None
maybe_raise [Exception_check] | `maybe_raise name` if the exception associated with any name in `name` has been triggered, then raise it, otherwise do nothing.
maybe_with_default [Deprecated_fcommand] |
mean [Deprecated_bench.Result] |
mean_gettime_cost [Posix_clock] |
mem [Splay_tree.S] |
mem [Packed_map.S] |
mem [Multi_map] | `mem m key` returns true if `key` has at last one value associated to it in `m`
mem [Hashtbl2_pair] |
mem [Fold_map.S2] |
mem [Fold_map.S] |
mem [Extended_hashtbl.Access_control] |
mem [Environment] |
mem1 [Hashtbl2_pair] |
mem1 [Hashtbl2] | `mem1 t key1` is true iff \exists key2 s.t.
mem2 [Hashtbl2_pair] |
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 [Lazy_list] |
merge [Extended_hashtbl.Access_control] |
merge_into [Extended_hashtbl.Access_control] |
metric [Procfs.Net.Route.Fields] |
metric [Procfs.Net.Route] |
min [Flang] |
min [Extended_list] |
min [Deprecated_bench.Result] |
min_exn [Extended_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] |
mult [Flang] |
mult_list [Flang] |
multimerge [Extended_list__multimerge] |
multimerge [Extended_list] | Merges several list trying to keep the order in which the elements appear.
multimerge_unique [Extended_list__multimerge] |
multimerge_unique [Extended_list] |
mv [Shell] | Raises "Failed_command"
N
name [Number.Verified_std.Bounded_spec] |
name [Linebuf] |
name [Deprecated_command.Flag] |
name [Deprecated_bench.Test] |
names [Sys_utils.Lsb_release.Fields] |
names [Procfs.Mount.Fields] |
names [Procfs.Net.Tcp.Fields] |
names [Procfs.Net.Route.Fields] |
names [Procfs.Net.Dev.Fields] |
names [Procfs.Loadavg.Fields] |
names [Procfs.Kstat.Fields_of_cpu_t] |
names [Procfs.Meminfo.Fields] |
names [Procfs.Process.Fields] |
names [Procfs.Process.Fd.Fields] |
names [Procfs.Process.Status.Fields] |
names [Procfs.Process.Statm.Fields] |
names [Procfs.Process.Stat.Fields] |
names [Procfs.Process.Limits.Fields] |
names [Procfs.Process.Limits.Rlimit.Fields] |
nest [Pp] | When the pretty printer decides to represent a `break` as a newline it also prints some spaces after it to indent the following line.
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] |
nng [Quickcheck_deprecated] | natural number generator
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 [Extended_filename] | `normalize path` Removes as much "." and ".." from the path as possible.
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 [Extended_unix] | Network to host order long, like C.
null [Readline.History] | A value which is always empty
number [Extended_list__multimerge] |
number [Extended_list] |
O
obj_to_sexp [Low_level_debug] | Obtain a sexp representation of any type.
obj_to_string [Low_level_debug] | Obtain a string representation of any type.
of_aarray [Packed_map.S] |
of_alist [Packed_map.S] |
of_alist_exn [Hashtbl2_pair.Make] |
of_arg [Deprecated_command.Flag] |
of_array [Packed_array.Basic] |
of_array [Packed_array.S] |
of_array [Lazy_sequence] |
of_array [Lazy_list] |
of_array [Iter] | create an iterator that will go over array elements
of_array [Cbuffer] | initialize Cbuffer from array
of_channel [Iter] | create an iterator that will read from file using f
of_core_command [Deprecated_command] |
of_exec_env [Environment] |
of_exn [Extended_exn.Exn_string] |
of_fun [Lazy_m] | Create a lazy value of a function.
of_hashtbl [Packed_map.S] |
of_hashtbl [Extended_hashtbl.Access_control] |
of_int [Procfs.Net.Tcp_state] |
of_int [Extended_unix.Inet_port] |
of_int_exn [Extended_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_map [Fold_map.S2] |
of_map [Fold_map.S] |
of_opt [Iter] | create an iterator that may iterate over one value
of_option [Extended_list] | `of_option o` returns a list that is empty if `o` is None, otherwise it is a singleton list.
of_passwd_file [Extended_unix.Extended_passwd] | `of_passwd_file` parse a passwd-like file
of_passwd_file_exn [Extended_unix.Extended_passwd] | `of_passwd_file_exn` parse a passwd-like file
of_passwd_line [Extended_unix.Extended_passwd] | `of_passwd_line` parse a passwd-like line
of_passwd_line_exn [Extended_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_sexps [Extended_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 [Extended_unix.Mac_address] |
of_string [Extended_unix.Inet_port] |
of_string [Extended_int64.Filesize] |
of_string_exn [Extended_unix.Inet_port] |
of_test_bool [Prod_or_test] |
of_val [Lazy_m] | Create a lazy value of a non-lazy value.
ok [Generic] |
ok [Extended_result.Exn] | `ok t` returns `x` if `t = Ok x`, or raises `e` if `t = Error e`.
one [Procfs.Loadavg.Fields] |
one [Procfs.Loadavg] |
one [Extended_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] |
opt_of_sexp [Malloc] |
option [Generic] |
optional [Deprecated_fcommand] |
optional [Deprecated_command.Annotated_field] |
optional_with_default [Deprecated_fcommand] |
options [Extended_unix.Mount_entry] |
order_of_magnitude_difference [Extended_float] | `order_of_magnitude_difference a b` by how many orders of magnitude do `a` and `b` differ? The return value is non-negative.
output_lines [Csv_writer] | Prints a valid csv file to a given channel (note that line are ended "\r\n")
P
pad_left [Extended_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 [Extended_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 [Extended_filename] | `parent path` The parent of the root directory is the root directory
parse_date [English] | `parse_date s`: Convert a date in plain english (eg.
parse_int [English] | `parse_int s`: Like standard int_of_string, but try to convert the first twenty english numbers (eg.
parse_line [Extended_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.
pg [Quickcheck_deprecated] | pair generator
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' [Extended_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 [Extended_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 [Extended_sexp.Diff] |
print [Deprecated_bench] |
print_diff [Extended_sexp] |
print_version [Deprecated_command.Version] |
printl [Printc] |
priority [Procfs.Process.Stat.Fields] |
priority [Procfs.Process.Stat] |
process_age [Procfs] |
process_age' [Procfs] |
processes [Procfs.Process.Limits.Fields] |
processes [Procfs.Process.Limits] |
processor [Procfs.Process.Stat.Fields] |
processor [Procfs.Process.Stat] |
progress [Iter] | get the position in the iterator either None or Some x in `0;1`
progress_string [Iter] | convert the progress return value to a string: None->"", Some->" 33%"
protect [Lazy_sequence] |
Q
query [Sys_utils.Lsb_release] |
query [Sntp] | `query hostname` returns the difference between the clock on the local host and the clock on the host specified by `hostname`.
query [Extended_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 [Extended_float.Fraction] |
random_split [Extended_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 [Extended_array] |
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_only [Update_queue] |
realtime_priority [Procfs.Process.Limits.Fields] |
realtime_priority [Procfs.Process.Limits] |
red [Color_print] |
red_sprintf [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 [Extended_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 [Extended_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_all1 [Hashtbl2_pair] |
remove_all1 [Hashtbl2] |
remove_changes_within [Interval_map_intf.M] | `remove_changes_within t interval` removes any change points within the specified interval.
remove_changes_within [Interval_map_intf.S] |
remove_exn [Hashtbl2_pair] |
remove_exn [Hashtbl2] |
remove_one [Extended_hashtbl.Access_control] |
render_as_regexp [Trie.S] |
repeat [Quickcheck_deprecated] |
replace [Extended_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_on_exn exn` calls `Fd_leak_check.report_open_files` iff `exn` indicates a file descriptor leak (Unix error with code EMFILE or ENFILE).
report_open_files [Fd_leak_check] | `report_open_files ()` prints a dump of open file descriptors to `stderr` in two formats, one using the proc file system, the other by executing `/usr/sbin/lsof` in a child process.
required [Deprecated_fcommand] |
required [Deprecated_command.Annotated_field] |
reset [Linebuf] | reopens the file and seeks to the beginning.
resident [Procfs.Process.Statm.Fields] |
resident [Procfs.Process.Statm] |
resident_mem_use_in_kb [Sys_utils.Cpu_use] |
resident_set [Procfs.Process.Limits.Fields] |
resident_set [Procfs.Process.Limits] |
rest [Procfs.Net.Tcp.Fields] |
rest [Procfs.Net.Tcp] |
rest [Deprecated_command.Flag.Action] | `rest f`: an action for a flag that signals the end of flag processing.
rest_acc [Deprecated_command.Flag] |
rest_mut [Deprecated_command.Flag] |
restart [Service_command] |
retrnsmt [Procfs.Net.Tcp.Fields] |
retrnsmt [Procfs.Net.Tcp] |
rgb [Color_print] |
rgb_sprintf [Color_print] |
rgbprintf [Color_print] |
right_contents [String_zipper] |
rlim [Procfs.Process.Stat.Fields] |
rlim [Procfs.Process.Stat] |
rm [Shell] |
root [Procfs.Process.Fields] |
root [Procfs.Process] |
rpad [Printc] |
rss [Procfs.Process.Stat.Fields] |
rss [Procfs.Process.Stat] |
rt_priority [Procfs.Process.Stat.Fields] |
rt_priority [Procfs.Process.Stat] |
run [Timed_function] | Runs a function in a fork process to ensure a timeout.
run [Shell.Process] |
run [Shell] | Runs a command and discards its output.
run [Process] |
run [Deprecated_command] |
run_check_at_exit [Fd_leak_check] | Toggle to turn on/off checking for descriptor leaks at exit (default: off)
run_fold [Shell] | Fold over the lines in the stdout of a process; The `Continue/`Stop argument is there to allow early returning.
run_full [Shell] | Return the full command's output in one string.
run_k [Shell.Process] |
run_lines [Shell] | Runs a command and returns its output line separated.
run_main [Extended_common] |
run_one [Shell] | Returns the first line of the command's output.
run_one_exn [Shell] |
rx_bytes [Procfs.Net.Dev.Fields] |
rx_bytes [Procfs.Net.Dev] |
rx_compressed [Procfs.Net.Dev.Fields] |
rx_compressed [Procfs.Net.Dev] |
rx_drop [Procfs.Net.Dev.Fields] |
rx_drop [Procfs.Net.Dev] |
rx_errs [Procfs.Net.Dev.Fields] |
rx_errs [Procfs.Net.Dev] |
rx_fifo [Procfs.Net.Dev.Fields] |
rx_fifo [Procfs.Net.Dev] |
rx_frame [Procfs.Net.Dev.Fields] |
rx_frame [Procfs.Net.Dev] |
rx_multicast [Procfs.Net.Dev.Fields] |
rx_multicast [Procfs.Net.Dev] |
rx_packets [Procfs.Net.Dev.Fields] |
rx_packets [Procfs.Net.Dev] |
rx_queue [Procfs.Net.Tcp.Fields] |
rx_queue [Procfs.Net.Tcp] |
S
safe_create [Extended_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] |
scp [Shell] | `scp user host from to` copy local file from to to
scroll_lock [Extended_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 [Splay_tree.S] |
set [Set_lang_intf.S_lang] |
set [Set_lang] |
set [Multi_map] |
set [Hashtbl2_pair] |
set [Hashtbl2] |
set [Fold_map.S2] |
set [Fold_map.S] |
set [Float_ref] |
set [Extended_unix.Quota] |
set [Extended_hashtbl.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_all_mutable_fields [Sys_utils.Lsb_release.Fields.Direct] |
set_all_mutable_fields [Procfs.Mount.Fields.Direct] |
set_all_mutable_fields [Procfs.Net.Tcp.Fields.Direct] |
set_all_mutable_fields [Procfs.Net.Route.Fields.Direct] |
set_all_mutable_fields [Procfs.Net.Dev.Fields.Direct] |
set_all_mutable_fields [Procfs.Loadavg.Fields.Direct] |
set_all_mutable_fields [Procfs.Kstat.Fields_of_cpu_t.Direct] |
set_all_mutable_fields [Procfs.Meminfo.Fields.Direct] |
set_all_mutable_fields [Procfs.Process.Fields.Direct] |
set_all_mutable_fields [Procfs.Process.Fd.Fields.Direct] |
set_all_mutable_fields [Procfs.Process.Status.Fields.Direct] |
set_all_mutable_fields [Procfs.Process.Statm.Fields.Direct] |
set_all_mutable_fields [Procfs.Process.Stat.Fields.Direct] |
set_all_mutable_fields [Procfs.Process.Limits.Fields.Direct] |
set_all_mutable_fields [Procfs.Process.Limits.Rlimit.Fields.Direct] |
set_date [Deprecated_command.Flag] |
set_date_opt [Deprecated_command.Flag] |
set_defaults [Shell.Process] |
set_diff [Extended_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 [Extended_list] | `set_inter l1 l2` returns a list without duplicates of all elements of l1 that are in l2
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] |
set_within [Interval_map_intf.M] | `set_within t interval v` modifies the sequence so that all values within the specified interval are `v`, and values outside the interval are not modified.
set_within [Interval_map_intf.S] |
seteuid [Extended_unix] |
setresuid [Extended_linux] |
setreuid [Extended_unix] |
sexp [Deprecated_fcommand] |
sexp_of_bigint [Procfs] |
sexp_of_bytes [Extended_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_flag [Extended_linux.Splice] |
sexp_of_index_t [Procfs.Kstat] |
sexp_of_inodes [Extended_unix.Quota] |
sexp_of_key [Splay_tree.S] |
sexp_of_key [Packed_map.S] |
sexp_of_limit [Extended_unix.Quota] |
sexp_of_mallinfo [Malloc] |
sexp_of_opt [Malloc] | ???
sexp_of_statvfs [Extended_unix] |
sexp_of_t [Trie.Key.Part] |
sexp_of_t [Sys_utils.Lsb_release] |
sexp_of_t [Splay_tree.Key] |
sexp_of_t [Splay_tree.S] |
sexp_of_t [Set_lang_intf.S_binable] |
sexp_of_t [Set_lang_intf.S] |
sexp_of_t [Selector.Stable.String_list_selector.V1] |
sexp_of_t [Selector.Stable.String_selector.V1] |
sexp_of_t [Selector.Stable.String_selector.Regexp.V1] |
sexp_of_t [Selector.Stable.Date_selector.V1] |
sexp_of_t [Selector.String_list_selector] |
sexp_of_t [Selector.String_selector.Regexp] |
sexp_of_t [Selector.String_selector] |
sexp_of_t [Selector.Date_selector] |
sexp_of_t [Prod_or_test] |
sexp_of_t [Procfs.Meminfo] |
sexp_of_t [Procfs.Process.Fd] |
sexp_of_t [Procfs.Process.Status] |
sexp_of_t [Procfs.Process.Statm] |
sexp_of_t [Procfs.Process.Stat] |
sexp_of_t [Procfs.Process.Limits.Rlimit] |
sexp_of_t [Procfs.Process.Limits] |
sexp_of_t [Procfs.Process.Inode] |
sexp_of_t [Procfs.Process] |
sexp_of_t [Process.Status] |
sexp_of_t [Packed_map.Value] |
sexp_of_t [Packed_map.Key] |
sexp_of_t [Packed_map.S] |
sexp_of_t [Olang] |
sexp_of_t [Left_boundary] |
sexp_of_t [Interval_map_intf.S_with_boundary.Left_boundary] |
sexp_of_t [Interval_map_intf.S] |
sexp_of_t [Interval_map_intf.Type_with_map_module.Map] |
sexp_of_t [Interval_map_intf.Type_with_map_module] |
sexp_of_t [Interval_map_intf.Interval] |
sexp_of_t [Hashtbl2_pair.Make] |
sexp_of_t [Hashtbl2_pair] |
sexp_of_t [Hashtbl2.Key] |
sexp_of_t [Hashtbl2.Make] |
sexp_of_t [Hashtbl2] |
sexp_of_t [Float_ref] |
sexp_of_t [Flang.Ordered_field] |
sexp_of_t [Flang] |
sexp_of_t [Extended_unix.Mount_entry] |
sexp_of_t [Extended_unix.Mac_address] |
sexp_of_t [Extended_unix.Inet_port] |
sexp_of_t [Extended_sexp.Comprehension] |
sexp_of_t [Extended_sexp.Make_explicit_sexp_option] |
sexp_of_t [Extended_result.Exn] |
sexp_of_t [Extended_int64.Filesize] |
sexp_of_t [Cbuffer] |
sexp_of_uids [Extended_linux] |
sexp_of_value [Procfs.Process.Limits.Rlimit] |
sexp_of_value [Packed_map.S] |
sg [Quickcheck_deprecated] | string generator
sgid [Procfs.Process.Status.Fields] |
sgid [Procfs.Process.Status] |
sh [Shell] |
sh_full [Shell] |
sh_lines [Shell] |
sh_one [Shell] |
sh_one_exn [Shell] |
sh_test [Shell] |
share [Procfs.Process.Statm.Fields] |
share [Procfs.Process.Statm] |
shell [Shell.Process] |
shrink [Cbuffer] | half the size of the buffer
sigcatch [Procfs.Process.Stat.Fields] |
sigcatch [Procfs.Process.Stat] |
sigignore [Procfs.Process.Stat.Fields] |
sigignore [Procfs.Process.Stat] |
signal [Semaphore] | `signal sem v` allows one thread blocked in `Semaphore.wait` on semaphore `sem` to continue.
signal [Procfs.Process.Stat.Fields] |
signal [Procfs.Process.Stat] |
singleton [Multi_map] |
singleton [Fold_map.S2] |
singleton [Fold_map.S] |
size [Procfs.Process.Statm.Fields] |
size [Procfs.Process.Statm] |
size [Deprecated_bench.Test] |
sl [Procfs.Net.Tcp.Fields] |
sl [Procfs.Net.Tcp] |
slab [Procfs.Meminfo.Fields] |
slab [Procfs.Meminfo] |
slice [Packed_array.S] |
slot_spec [Service_command.T] |
snoc [Lazy_list] |
soft [Procfs.Process.Limits.Rlimit.Fields] |
soft [Procfs.Process.Limits.Rlimit] |
softirq [Procfs.Kstat.Fields_of_cpu_t] |
softirq [Procfs.Kstat] |
sort [Lazy_list] |
spec [Procfs.Mount.Fields] |
spec [Procfs.Mount] |
specialize [Set_lang_intf.S_eval] |
specialize [Set_lang.Make_monadic_eval] |
specialize [Set_lang] |
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 [Splay_tree.S] |
square [Extended_list] | Takes a list of ``key*`value lists` and returns a header * table_body body that is obtained by splitting the lists and re-ordering the terms (so that they all have the same header).
square_unique [Extended_list] |
squeeze [Extended_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 [Extended_unix] | get file system statistics
statvfs_of_sexp [Extended_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_sockaddr [Net_utils] | Get string from sockaddr
strptime [Extended_unix] |
sub [Lazy_sequence] |
sub [Flang] |
subst [Set_lang_intf.S_eval] |
subst [Set_lang.Make_monadic_eval] |
subst [Set_lang] |
suid [Procfs.Process.Status.Fields] |
suid [Procfs.Process.Status] |
summarize [Extended_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] |
T
t [Iter] | create an iterator from an iterating function
t2 [Deprecated_fcommand] |
t3 [Deprecated_fcommand] |
t4 [Deprecated_fcommand] |
t_of_sexp [Trie.Key.Part] |
t_of_sexp [Sys_utils.Lsb_release] |
t_of_sexp [Splay_tree.Key] |
t_of_sexp [Splay_tree.S] |
t_of_sexp [Set_lang_intf.S_binable] |
t_of_sexp [Set_lang_intf.S] |
t_of_sexp [Selector.Stable.String_list_selector.V1] |
t_of_sexp [Selector.Stable.String_selector.V1] |
t_of_sexp [Selector.Stable.String_selector.Regexp.V1] |
t_of_sexp [Selector.Stable.Date_selector.V1] |
t_of_sexp [Selector.String_list_selector] |
t_of_sexp [Selector.String_selector.Regexp] |
t_of_sexp [Selector.String_selector] |
t_of_sexp [Selector.Date_selector] |
t_of_sexp [Prod_or_test] |
t_of_sexp [Procfs.Meminfo] |
t_of_sexp [Procfs.Process.Fd] |
t_of_sexp [Procfs.Process.Status] |
t_of_sexp [Procfs.Process.Statm] |
t_of_sexp [Procfs.Process.Stat] |
t_of_sexp [Procfs.Process.Limits.Rlimit] |
t_of_sexp [Procfs.Process.Limits] |
t_of_sexp [Procfs.Process.Inode] |
t_of_sexp [Procfs.Process] |
t_of_sexp [Packed_map.Value] |
t_of_sexp [Packed_map.Key] |
t_of_sexp [Packed_map.S] |
t_of_sexp [Olang] |
t_of_sexp [Left_boundary] |
t_of_sexp [Interval_map_intf.S_with_boundary.Left_boundary] |
t_of_sexp [Interval_map_intf.S] |
t_of_sexp [Interval_map_intf.Type_with_map_module.Map] |
t_of_sexp [Interval_map_intf.Type_with_map_module] |
t_of_sexp [Interval_map_intf.Interval] |
t_of_sexp [Float_ref] |
t_of_sexp [Flang.Ordered_field] |
t_of_sexp [Flang] |
t_of_sexp [Extended_unix.Mount_entry] |
t_of_sexp [Extended_unix.Mac_address] |
t_of_sexp [Extended_unix.Inet_port] |
t_of_sexp [Extended_sexp.Comprehension] |
t_of_sexp [Extended_sexp.Make_explicit_sexp_option] |
t_of_sexp [Extended_int64.Filesize] |
t_of_sexp [Cbuffer] |
tail [Linebuf] | Seeks to the end of the file and blocks until another line is available -- this new line is not returned.
take [Lazy_sequence] |
task_stats [Procfs.Process.Fields] |
task_stats [Procfs.Process] |
tcp_socket [Net_utils] | Create a standard TCP/IP-socket
tee [Extended_linux.Splice] | `tee ?assume_fd_is_nonblocking ~fd_in ~fd_out len flags` see man-page for details.
ten [Procfs.Loadavg.Fields] |
ten [Procfs.Loadavg] |
terminal_width [Extended_unix] |
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.
tg [Quickcheck_deprecated] | triple generator
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 [Splay_tree.S] |
to_alist [Packed_map.S] |
to_alist [Fold_map.S2] |
to_alist [Fold_map.S] |
to_alist [Extended_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_opt [Iter] |
to_buffer [Extended_sexp.Diff] |
to_exec_env [Environment] |
to_file [Pp] |
to_flag [Deprecated_command.Annotated_field] |
to_int [Procfs.Net.Tcp_state] |
to_int [Extended_unix.Inet_port] |
to_line [Bin_io_utils] |
to_list [Sys_utils.Lsb_release.Fields] |
to_list [Readline.History] |
to_list [Random_selection] | the current selection from values previously seen by `t`.
to_list [Procfs.Mount.Fields] |
to_list [Procfs.Net.Tcp.Fields] |
to_list [Procfs.Net.Route.Fields] |
to_list [Procfs.Net.Dev.Fields] |
to_list [Procfs.Loadavg.Fields] |
to_list [Procfs.Kstat.Fields_of_cpu_t] |
to_list [Procfs.Meminfo.Fields] |
to_list [Procfs.Process.Fields] |
to_list [Procfs.Process.Fd.Fields] |
to_list [Procfs.Process.Status.Fields] |
to_list [Procfs.Process.Statm.Fields] |
to_list [Procfs.Process.Stat.Fields] |
to_list [Procfs.Process.Limits.Fields] |
to_list [Procfs.Process.Limits.Rlimit.Fields] |
to_list [Packed_array.S] |
to_list [Lazy_list] |
to_list [Iter] | iterate a function and collect results to a list
to_list [Generic] |
to_list [Find] | `to_list t` returns all of the remaining files in t as a list in the order they would have been returned by subsequent calls to next
to_list_opt [Iter] |
to_map [Fold_map.S2] |
to_map [Fold_map.S] |
to_regexp [Selector.String_selector.Regexp] |
to_rev_list [Lazy_list] |
to_spec [Deprecated_command.Flag] |
to_spec_unit [Deprecated_command.Flag] |
to_spec_units [Deprecated_command.Flag] |
to_string [Shell.Process] |
to_string [Selector.String_selector.Regexp] |
to_string [Procfs.Process.Inode] |
to_string [Process.Status] |
to_string [Pp] |
to_string [Posix_clock] |
to_string [Extended_unix.Mac_address] |
to_string [Extended_unix.Inet_port] |
to_string [Extended_sexp.Diff] |
to_string [Extended_int64.Filesize] |
to_string [Extended_exn] | The `to_string` function is slightly tweaked to avoid escaping the string content of `Failure`.
to_string_cisco [Extended_unix.Mac_address] |
to_string_hum [Extended_time.Extended_span] | Convert a time span to a human-readable string, e.g.
to_string_hum [Extended_float] |
to_string_hum [Extended_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' [Extended_sexp] | The ocaml pretty printer (used by sexplib) is a speed daemon but is, sadly enough, produces wrong output (e.g it overflows in places where this could have avoided).
top_command [Procfs.Process.Fields] |
top_command [Procfs.Process] |
touch [Cache.Strategy] | Marks an element as "fresh".
tpgid [Procfs.Process.Stat.Fields] |
tpgid [Procfs.Process.Stat] |
tr [Procfs.Net.Tcp.Fields] |
tr [Procfs.Net.Tcp] |
try_r_lock [Rw_mutex] | `try_r_lock mtx` tries to lock `mtx` for a reader without blocking.
try_read [Linebuf] | Tries to read a line from the file.
try_read_lnum [Linebuf] | `try_read_lnum` is like `try_read` except also provides the line number of the read line.
try_read_lnum_verbose [Linebuf] | Like try_read, except that it returns more verbose errors
try_w_lock [Rw_mutex] | `try_w_lock mtx` tries to lock `mtx` for a writer without blocking.
try_wrap_r_lock [Rw_mutex] | `try_wrap_r_lock mtx f` tries to lock `mtx` for a reader without blocking, executes `f` and unlocks the mutex again.
try_wrap_w_lock [Rw_mutex] | `try_wrap_w_lock mtx f` tries to lock `mtx` for a writer without blocking, executes `f` and unlocks the mutex again.
tty_nr [Procfs.Process.Stat.Fields] |
tty_nr [Procfs.Process.Stat] |
tx_bytes [Procfs.Net.Dev.Fields] |
tx_bytes [Procfs.Net.Dev] |
tx_carrier [Procfs.Net.Dev.Fields] |
tx_carrier [Procfs.Net.Dev] |
tx_colls [Procfs.Net.Dev.Fields] |
tx_colls [Procfs.Net.Dev] |
tx_compressed [Procfs.Net.Dev.Fields] |
tx_compressed [Procfs.Net.Dev] |
tx_drop [Procfs.Net.Dev.Fields] |
tx_drop [Procfs.Net.Dev] |
tx_errs [Procfs.Net.Dev.Fields] |
tx_errs [Procfs.Net.Dev] |
tx_fifo [Procfs.Net.Dev.Fields] |
tx_fifo [Procfs.Net.Dev] |
tx_packets [Procfs.Net.Dev.Fields] |
tx_packets [Procfs.Net.Dev] |
tx_queue [Procfs.Net.Tcp.Fields] |
tx_queue [Procfs.Net.Tcp] |
U
uid [Procfs.Net.Tcp.Fields] |
uid [Procfs.Net.Tcp] |
uid [Procfs.Process.Status.Fields] |
uid [Procfs.Process.Status] |
uids_of_sexp [Extended_linux] |
uig [Quickcheck_deprecated] | unsigned int generator (uniform random in range min_int, max_int)
underline [Color_print] |
underline_sprintf [Color_print] |
underlineprintf [Color_print] |
unescaped [Extended_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 [Extended_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] |
unify [Lazy_list] |
union [Set_lang_intf.S_lang] |
union [Set_lang] |
union2 [Set_lang_intf.S_lang] |
union2 [Set_lang] |
union_list [Set_lang] |
union_list_exn [Set_lang] |
unit [Cache] | Returns memoized version of any function with argument unit.
uniter [Lazy_list] |
unsafe_get [Packed_array.Basic] |
unsafe_slice [Packed_array.Basic] |
unsafe_tail [Linebuf] | Same as `tail` except it may return before a new line is available on the file i.e.
unused [Procfs.Process.Stat.Fields] |
unused [Procfs.Process.Stat] |
unwrap [Extended_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 [Bin_io_utils.Serialized.Make] |
value [Bin_io_utils.Serialized] |
value_of_sexp [Procfs.Process.Limits.Rlimit] |
value_of_sexp [Packed_map.S] |
value_raise [Extended_option] |
values [Set_lang_intf.S_lang] |
values [Set_lang] |
verify [Number.S] |
vfstype [Procfs.Mount.Fields] |
vfstype [Procfs.Mount] |
vgrp [Pp] | The `vgrp` operator creates a vertical group.
visible_filesystem [Extended_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.
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.
window [Procfs.Net.Route.Fields] |
window [Procfs.Net.Route] |
with_connection [Tcp] |
with_open_temp_file [Extended_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 [Extended_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 [Extended_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 [Extended_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] |
yellow_sprintf [Color_print] |
yellowprintf [Color_print] |
Z
zero [Number.Verified_std_spec] |
zero [Number.S0] |
zero [Flang.Ordered_field] |
zero [Deprecated_fcommand] |
zip_exn [Packed_array.Tuple2] |
zip_full [Lazy_sequence] |