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