Index of values


($) [Pp.Infix]
($) [Pp]
The infix operator x $ y concatenates two documents x and y into a larger one.
($) [Function]
($/) [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.
(++) [Dispatch_arg.Spec.Infix]
(++) [Dispatch_arg.Spec]
(-->) [Dispatch_arg.Spec.Infix]
(-->) [Dispatch_arg.Spec]
(^/) [Shell]
Concat and normalize

A
add [Rmap.S]
add [Rmap]
add [Int_set]
add t i adds i to the t, or does nothing if i is in t
add [Hashtree.S]
add [Hashtree]
add t ~key ~data add a new binding of key to data to the table.
add [Fold_table.Fold_map]
add [Fold_map.Fold_map]
add [Extended_linux.Epoll]
create n
add [Cbuffer]
add_range [Int_set]
add_range t ~lo ~hi adds all the integers in the range lo, hi.
agrp [Pp]
The automatic group agrp is the most versatile.
alert [Loggers.LOGGER]
all_levs [Syslog]
all_levs array of all logging levels sorted in ascending order.
all_str_levs [Syslog]
all_str_levs array of all logging levels as strings sorted in ascending order.
arg [Command.Flag.Action]
an action for a flag that takes an additional string argument
atom [Extended_sexp]

B
big_string [Dispatch_arg.Spec.Result]
bin_file [Extended_linux.Open_fds]
bin_flag [Extended_linux.Epoll]
bin_kind [Extended_linux.Open_fds]
bin_mallinfo [Malloc]
bin_opt [Malloc]
bin_read_file [Extended_linux.Open_fds]
bin_read_file_ [Extended_linux.Open_fds]
bin_read_file__ [Extended_linux.Open_fds]
bin_read_flag [Extended_linux.Epoll]
bin_read_flag_ [Extended_linux.Epoll]
bin_read_flag__ [Extended_linux.Epoll]
bin_read_kind [Extended_linux.Open_fds]
bin_read_kind_ [Extended_linux.Open_fds]
bin_read_kind__ [Extended_linux.Open_fds]
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_t [Res_array]
bin_read_t [Extended_linux.Open_fds]
bin_read_t_ [Res_array]
bin_read_t_ [Extended_linux.Open_fds]
bin_read_t__ [Res_array]
bin_read_t__ [Extended_linux.Open_fds]
bin_reader_file [Extended_linux.Open_fds]
bin_reader_flag [Extended_linux.Epoll]
bin_reader_kind [Extended_linux.Open_fds]
bin_reader_mallinfo [Malloc]
bin_reader_opt [Malloc]
bin_reader_t [Res_array]
bin_reader_t [Extended_linux.Open_fds]
bin_size_file [Extended_linux.Open_fds]
bin_size_flag [Extended_linux.Epoll]
bin_size_kind [Extended_linux.Open_fds]
bin_size_mallinfo [Malloc]
bin_size_opt [Malloc]
bin_size_t [Res_array]
bin_size_t [Extended_linux.Open_fds]
bin_t [Res_array]
bin_t [Extended_linux.Open_fds]
bin_write_file [Extended_linux.Open_fds]
bin_write_file_ [Extended_linux.Open_fds]
bin_write_flag [Extended_linux.Epoll]
bin_write_flag_ [Extended_linux.Epoll]
bin_write_kind [Extended_linux.Open_fds]
bin_write_kind_ [Extended_linux.Open_fds]
bin_write_mallinfo [Malloc]
bin_write_mallinfo_ [Malloc]
bin_write_opt [Malloc]
bin_write_opt_ [Malloc]
bin_write_t [Res_array]
bin_write_t [Extended_linux.Open_fds]
bin_write_t_ [Res_array]
bin_write_t_ [Extended_linux.Open_fds]
bin_writer_file [Extended_linux.Open_fds]
bin_writer_flag [Extended_linux.Epoll]
bin_writer_kind [Extended_linux.Open_fds]
bin_writer_mallinfo [Malloc]
bin_writer_opt [Malloc]
bin_writer_t [Res_array]
bin_writer_t [Extended_linux.Open_fds]
block [Pp]
A block contains objects xs formatted by f and enclosed by curly braces.
bool [Dispatch_arg.Spec.Result]
bool [Command.Flag.Type]
break [Pp]
The important points in a document are so-called breaks.
break_null [Pp]
break_null behaves like break except it does not insert anything when no newline is inserted.
break_with [Pp]
The space character used by break my be not always appropriate.
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.

C
cardinal [Fold_table.Fold_map]
cardinal [Fold_map.Fold_map]
cb_compare [Cbuffer]
compare two buffer fragments
change_size [Lru]
change the maximum size of the LRU list.
channel [Iter]
call f on channel until End_of_file
channel_progress [Iter]
create a progress function for an input channel
check_index [Cbuffer]
choice [Dispatch_arg.Spec]
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 [Lru]
clears out the entire lru, calling the destructor in each element
clear_filter [Logger]
removes the filter from a log
close [Find]
close t drops all the resources associated with t.
closelog [Syslog]
closelog () closes the connection to the syslog daemon.
cmd [Shell.Process]
collate [Extended_string]
collate s1 s2 sorts string in an order that's is usaully more suited for human consumption by treating ints specificaly: (e.g.
commalist [Pp]
command [Command.Version]
Provides a "version" subcommand.
comment [Extended_sexp]
compare [Rmap.Key]
compare [Hashtree.Key]
compare [Extended_filename]
with_open_temp_file prefix suffix ~f runs f on the output_channel pointing to the temporary file and returns the name of the file.
compare_lev [Syslog]
compare_lev lev1 lev2 compares logging levels lev1 and lev2.
concat [Iter]
concatenate a list of iterators
confirm [Prompt]
confirm display true_answer prints display and returns false unless user types true_answer
connect_tmout [Net_utils]
Connect a socket with a connect timeout
content [Shell.Process]
copy_data [Cbuffer]
copies data from one array to another.
copy_file [Shell]
cp [Shell]
Raises "Failed_command"
create [Union_find]
create v returns a new object in its own equivalence class that has value v.
create [Rw_mutex]
create pref
create [Rmap.S]
create [Rmap]
create [Readline.History]
create [Lru]
create size destructor creates a new lru list that stores at most size elements, and calls destructor on any element before it's kicked out of the list
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 [Int_set]
create ?log2_degree () returns an empty set.
create [Hashtree.S]
create [Hashtree]
create i create a new table with initial size i.
create [Find]
create ?options dir create a Find.t based in dir
create [Extended_linux.Epoll]
Epoll functions
create [Exception_check]
create should not be called more than once
create [Dispatch_arg.Spec.Result]
create [Dispatch_arg.Spec]
Create a new atomic type The option should have no side effect!!!
create [Container_extended]
create [Command.Flag.Type]
create [Command]
create constructs a base command from the following data: 'a a mutable accumulator type for gathering arguments , 'b a composite argument type for the command, build from 'a , summary a short description of what the command does , usage_arg an abbreviation of the arguments it expects , init a function that creates an mutable accumulator of type 'accum , flags a list of command line flags together with their associated accumulator-mutating actions , anon a function that runs on all anonymous arguments after we scan through all the flags , final a function that constructs the final argument structure of type 'args from the accumulated arguments. The second argument to the function is a function which returns the help for the command, which you can use when failing. This function should raise an exception with some explanation if it doesn't find all the arguments it expects. , main the main function, parameterized by the argument structure
create [Cbuffer]
create_default [Logger]
creates a log using the default message type and a filter that drops `Debug messages
crit [Loggers.LOGGER]

D
data [Fold_table.Fold_map]
data [Fold_map.Fold_map]
debug [Loggers.LOGGER]
declare [Dispatch_arg]
Manual declaration; should be kept only for advanced uses
default [Find.Options]
default_shell [Dispatch_arg]
del [Extended_linux.Epoll]
modify ~epfd ~fd flags modifies file descriptor fd controlled by epoll file descriptor epfd using event flags flags.
diff [Extended_list]
diff l1 l2 returns a list of all elements of l1 that are not in l2
discard [Shell.Process]
discover [Extended_linux.Open_fds]
drop_from [Cbuffer]
drop_last [Cbuffer]
drop_old [Cbuffer]
drop stuff from the end.

E
echo [Shell]
email [Shell]
embed [Dispatch_arg]
emerg [Loggers.LOGGER]
empty [Vector]
empty [Pp]
The empty document is pretty printed to the empty string.
empty [Iter]
an iterator that halts immediately
empty [Fold_table.Fold_map]
empty [Fold_map.Fold_map]
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.
eprintf [Shell.Ansi]
err [Loggers.LOGGER]
escape [Escaping]
escape escapeworthy escape_char s is escape_gen ~escapeworthy_map:(List.combine escapeworthy escapeworthy) ~escape_char.
escape_gen [Escaping]
escape_gen escapeworthy_map escape_char s returns an escaped string based on s as follows: if (c1,c2) is in escapeworthy_map, then all occurences of c1 are replaced by escape_char concatenated to c2.
escape_one_orig [Escaping]
escape_one_orig ~escapeworthy ~escape_char s escapes character escapeworthy with escape_char in string s.
escape_two_orig [Escaping]
escape_two_orig ~escapeworthy1 ~escapeworthy2 ~escape_char s escapes characters escapeworthy1 and escapeworthy2 with escape_char in string s.
esyslog [Syslog]
esyslog ?fac ?lev str same as Syslog.syslog, but also prints to stderr.
esyslog_printf [Syslog]
esyslog_printf ?fac ?lev fmt same as Syslog.syslog_printf, but also prints to stderr.
exists [Iter]
exists [Fold_table.Fold_map]
exists [Fold_map.Fold_map]
expand [Cbuffer]
half the size of the buffer

F
f [Fold_map.Fold]
fgrp [Pp]
The break policy inside an agrp is fixed for all breaks of the group.
file_exists [Shell]
Returns true if the file exists
file_kind [Shell]
file_of_sexp [Extended_linux.Open_fds]
filter [Logger]
Sets the filter for a log
filter [Iter]
iterate over elements that satisfy the predicate
filter [Fold_table.Fold_map]
filter [Fold_map.Fold_map]
find [Rmap.S]
find [Rmap]
find [Iter]
find an element that satisfies the predicate
find [Hashtree.S]
find [Hashtree]
find t key look up the binding of key, if no binding exists return None
find [Fold_table.Fold_map]
find [Fold_map.Fold_map]
find_all [Find]
find_all ?options dir short for to_list (create ?options dir)
flag_of_sexp [Extended_linux.Epoll]
flag_to_string [Extended_linux.Epoll]
has_oneshot flags
float [Command.Flag.Type]
flush [Readline.History]
fold [Rmap.S]
fold [Rmap]
fold [Iter]
fold is the same as reduce
fold [Hashtree.S]
fold [Hashtree]
fold t ~init:z ~f fold through the table.
fold [Fold_table.Fold_map]
fold [Fold_map.Fold_map]
fold [Find]
fold t ~init ~f folds f over the files in t
fold_left_term [Extended_list]
fold_left_term is like fold_left, except that you can halt early.
foldi [Extended_array]
for_all [Iter]
evaluate a predicate over the entire iterator
for_all [Fold_table.Fold_map]
for_all [Fold_map.Fold_map]
format [Extended_sexp]
format_failed [Shell.Process]

G
generic [Loggers.LOGGER]
get [Vector]
get [Union_find]
get t returns the value of the class of t.
get [Semaphore]
get sem
get [Cbuffer]
get_all_procs [Procfs]
get_all_procs returns a process list
get_editor [Shell]
Get an installed editor.
get_flags [Extended_linux.Epoll]
make_flags ar
get_group_names [Shell]
Get the names of the groups the user belongs to
get_lev [Loggers.LOGGER]
Get minimum log level
group [Command]
group ~summary [...; (name_i, t_i); ...] is an aggregate command that dispatches to one of the named sub-commands.

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
has_err [Extended_linux.Epoll]
has_pri flags
has_et [Extended_linux.Epoll]
has_hup flags
has_hup [Extended_linux.Epoll]
has_err flags
has_in [Extended_linux.Epoll]
get_flags flags
has_oneshot [Extended_linux.Epoll]
has_et flags
has_out [Extended_linux.Epoll]
has_in flags
has_pri [Extended_linux.Epoll]
has_out flags
hash [Hashtree.Key]
head [Shell.Process]
hertz [Procfs]
hertz is the number of jiffies per second
hgrp [Pp]
A group operator takes a document and let it become a group.
home [Shell]
Get the home of the effective user
hostname [Shell]

I
i [Iter]
iterate over the iterator: call f on each element
iff [Extended_option]
ignore_errors [Find.Options]
in_cache [Lru]
tells you whether a given value is cached or not
in_group [Shell]
Test if the user is in the given group
inet_addr_of_sockaddr [Net_utils]
Get inet_addr from sockaddr
info [Loggers.LOGGER]
init [Semaphore]
init v initializes a semaphore with an optional value v.
init [Fold_map.Fold]
input_line [Readline]
int [Dispatch_arg.Spec.Result]
int [Dispatch_arg.Spec]
Same as string but attempts to perform an int_to_string conversion
int [Command.Flag.Type]
inter [Extended_list]
inter l1 l2 returns a list without duplicates of all elements of l1 that are in l2
intersperse [Extended_list]
intersperse returns a list with the given element placed between every two original elements.
invariant [Rmap.S]
invariant [Rmap]
invariant [Int_set]
is_atom [Extended_sexp]
is_color_tty [Shell.Ansi]
is_directory [Shell]
Returns true if the file exists and is a directory
is_empty [Int_set]
is_empty [Fold_table.Fold_map]
is_empty [Fold_map.Fold_map]
is_file [Shell]
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_substring [Extended_string]
is_substring ~substring t returns true if substring is a substring of t.
iter [Rmap.S]
iter [Rmap]
iter [Fold_table.Fold_map]
iter [Fold_map.Fold_map]
iter [Find]
iter t ~f calls f on every file in t
iter [Cbuffer]
iter buf ~f calls func on each buffer element starting with 0 like this: (func pos element)
iterr [Cbuffer]
iterr buf ~f calls func on each buffer element starting with end like this: (func pos element)

K
keys [Fold_table.Fold_map]
keys [Fold_map.Fold_map]
kind_of_sexp [Extended_linux.Open_fds]

L
length [Int_set]
Container functions.
length [Hashtree.S]
length [Hashtree]
length t return the number of bindings in the table.
length [Cbuffer]
lev_of_string [Syslog]
lev_of_string str converts string str to a level.
lines [Shell.Process]
list [Pp]
A list of objects which are seperated by some seperator is very common.
list [Extended_sexp]
list [Dispatch_arg.Spec.Result]
list [Dispatch_arg.Spec]
log [Logger]
logs a message to log
logger [Loggers.SPEC]
look [Semaphore]
look sem
ls [Shell]

M
make_flags [Extended_linux.Epoll]
Type of Epoll event flags
mallinfo [Malloc]
mallinfo ()
mallinfo_of_sexp [Malloc]
top-most, releasable (via malloc_trim) space
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.
map [Iter]
transform the iterator
map1 [Dispatch_arg.Spec]
map2 [Dispatch_arg.Spec]
map3 [Dispatch_arg.Spec]
max [Extended_list]
max_element [Int_set]
max_exn [Extended_list]
may_log [Loggers.LOGGER]
Test whether a log level may be logged.
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.
mem [Int_set]
mem t i checks if i is in t.
mem [Fold_table.Fold_map]
mem [Fold_map.Fold_map]
memoize [Lru]
Returns lru list and memoized version of function.
memtotal [Procfs]
memtotal is the amount of physical memory in the system, in kB
min [Extended_list]
min_element [Int_set]
{min,max}_element t return the smallest and largest elements in t.
min_exn [Extended_list]
mkdir_p [Shell]
modify [Extended_linux.Epoll]
add ~epfd ~fd flags add file descriptor fd to epoll file descriptor epfd using event flags flags.

N
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 [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]
noarg [Command.Flag.Action]
an action for a flag that takes no additional argument
notice [Loggers.LOGGER]
np_pref [Rw_mutex]
np_pref no preference for readers or writers.

O
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_list [Readline.History]
of_list [Iter]
create an iterator that will go over list elements
of_list [Fold_map.Fold_map]
of_map [Fold_map.Fold_map]
of_opt [Iter]
create an iterator that may iterate over one value
of_type [Command.Flag.Action]
an action taking an argument of some parsable type 'a
ok [Dispatch_arg.Spec.Result]
open_connection_tmout [Net_utils]
Open a connection with timeouts
open_fd_connection_tmout [Net_utils]
Create a socket with timeouts
openlog [Syslog]
openlog ?id ?opt ?fac () opens a connection to the system logger (possibly delayed) using prefixed identifier id, options opt, and faculty fac.
opt_of_sexp [Malloc]
???
option [Dispatch_arg.Spec]

P
password [Prompt]
password display like prompt but turns off echo for user's response; None is returned on input error
phys_length [Cbuffer]
physical_ram [Unix_utils]
physical_ram ()
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.
pretty [Extended_float]
pretty-print a float using no more than four characters, using abberviations k, m, g, t.
print_diff [Extended_sexp]
printf [Shell.Ansi]
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%"
prompt [Prompt]
prompt display prints display and returns one-line response from user

Q
quote [Shell]

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_split [Extended_array]
random_sub [Extended_array]
reduce [Iter]
fold over the iterator: call f on each element and return the accumulator
remote [Shell.Process]
remove [Rmap.S]
remove [Rmap]
remove [Hashtree.S]
remove [Hashtree]
remove t key remove the binding of key from the table, if no binding exists do nothing.
remove [Fold_table.Fold_map]
remove [Fold_map.Fold_map]
rest [Command.Flag.Action]
rest f: an action for a flag that signals the end of flag processing.
rm [Shell]
run [Shell.Process]
run [Shell]
Runs a command and discards its output.
run [Process]
run [Dispatch_arg]
Run a command If args is not specified then defaults to the command line arguments
run [Command]
Run the command against Sys.argv.
run_full [Shell]
Return the full command's output in one string.
run_gen [Dispatch_arg]
run_highlighted [Extended_common]
Like Exn.handle_uncaught but colors stderr in red.
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 [Ocaml_utils]
running_byte_code ()

S
same_class [Union_find]
same_class t1 t2 returns true iff t1 and t2 are in the same equivalence class.
scp [Shell]
scp user host from to copy local file from to to
send [Sendmail]
set [Vector]
set [Union_find]
set t v sets the value of the class of t to v.
set [Fold_table.Fold_map]
set [Fold_map.Fold_map]
set [Cbuffer]
set_in_channel_timeout [Net_utils]
Set a timeout for a socket associated with an in_channel
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
setlogmask [Syslog]
setlogmask ?levs ?from_lev ?to_lev () sets the log mask.
sexp_of_file [Extended_linux.Open_fds]
sexp_of_flag [Extended_linux.Epoll]
sexp_of_kind [Extended_linux.Open_fds]
sexp_of_mallinfo [Malloc]
sexp_of_opt [Malloc]
sexp_of_t [Extended_linux.Open_fds]
sexp_of_t [Cbuffer]
sh [Shell]
sh_full [Shell]
sh_lines [Shell]
sh_one [Shell]
sh_test [Shell]
shell [Shell.Process]
shell [Dispatch_arg]
Dispatch a new shell.
shrink [Cbuffer]
half the size of the buffer
signal [Semaphore]
signal sem v allows one thread blocked in Semaphore.wait on semaphore sem to continue.
singleton [Fold_table.Fold_map]
singleton [Fold_map.Fold_map]
size [Lru]
returns current size of lru
snoc [Vector]
split_while [Extended_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.
squeeze [Extended_string]
ssh [Shell]
ssh user host command run command via ssh
status_to_string [Shell.Process]
string [Dispatch_arg.Spec.Result]
string [Dispatch_arg.Spec]
Reads an argument from the argument list and passes it verbatim to the underlying function.
string_of_lev [Syslog]
string_of_lev lev converts a level lev to a string.
string_of_sockaddr [Net_utils]
Get string from sockaddr
summarize [Extended_sexp]
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
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
t_of_sexp [Extended_linux.Open_fds]
t_of_sexp [Cbuffer]
take_while [Extended_list]
take_while xs f produces the longest prefix of xs on which f is always true.
tcp_socket [Net_utils]
Create a standard TCP/IP-socket
test [Shell.Process]
test [Shell]
text [Pp]
The text function turns a string into a document.
timestamp [Logger]
Returns a timestamp as a string suitable for log files
to_alist [Fold_table.Fold_map]
to_alist [Fold_map.Fold_map]
to_array [Iter]
iterate a function and collect results to a array
to_array [Cbuffer]
to_array_opt [Iter]
to_file [Pp]
to_file_width [Pp]
Same as to_file but the number of columns is specified as an argument
to_list [Readline.History]
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.Fold_map]
to_string [Shell.Process]
to_string [Pp]
to_string [Int_set]
to_string [Extended_exn]
The to_string function is slightly tweaked to avoid escaping the string content of Failure.
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).
to_string_width [Pp]
Same as to_string but the number of columns is specified as an argument
touch [Lru]
touch marks an element as being recently used, and updates the LRU accordingly.
try_r_lock [Rw_mutex]
try_r_lock mtx tries to lock mtx for a reader without blocking.
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.

U
unescape [Escaping]
unescape escape_char s is unescape_gen ~map:[] ~escape_char str
unescape_gen [Escaping]
unescape_gen is the inverse operation of escape_gen, assuming an inverse map is given.
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 [Iter]
union [Union_find]
union t1 t2 makes the class of t1 and the class of t2 be the same (if they are already equal, then nothing changes).
unit [Dispatch_arg.Spec.Result]
unit [Dispatch_arg.Spec]
Produces a unit; reads nothing from the command line
unsafe_create_process [Extended_unix]
unsafe_create_process ~prog ~args ~stdin ~stdout ~stderr forks a new process that executes the program in file prog, with arguments args.

V
vgrp [Pp]
The vgrp operator creates a vertical group.

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.
wait [Extended_linux.Epoll]
del ~epfd ~fd removes file descriptor fd from epoll file descriptor epfd.
warnf [Shell]
warning [Loggers.LOGGER]
which [Shell]
whoami [Shell]
Get the username.
with_open_temp_file [Extended_filename]
with_open_temp_file prefix suffix ~f runs f on the output_channel pointing to the temporary file and returns the name of the file.
with_pid [Procfs]
with_pid pid returns a single process that matches pid
with_temp_dir [Extended_filename]
with_uid [Procfs]
with_uid uid returns all processes which belong to uid
with_username [Procfs]
with_username 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.
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_script [Command.Tab_completion]
write_script t argv0 dest generates a tab-completion bash script for t, using argv0 as the command name to tab complete on, writing the script file to dest