Index of values


A
absolute_file_name [Cash]
absolute_file_name ~dir:dir fname converts file-name fname into an absolute file name, relative to directory ~dir, which defaults to the current working directory.
accept_connection [Cash]
accept_connection receives a connection on a socket, returning a new socket that can be used for this connection and the remote socket address associated with the connection.
add_after [Cash]
These functions are for modifying search-path lists, where element order is significant.
add_before [Cash]
alist_compress [Cash]
Compresses alist by removing shadowed entries.
alist_delete [Cash]
alist_delete key alist deletes any entry labelled by value key.
alist_of_env [Cash]
The alist_of_env procedure converts the entire environment into an alist, e.g.
alist_update [Cash]
alist_update key val alist deletes key from alist, then cons on a (key, val) entry.
arg [Cash]
arg_star [Cash]
argv [Cash]
These procedures are useful for accessing arguments from argument lists.
autoreap_policy [Cash]
The Cash programmer can choose different policies for automatic process reaping.

B
become_session_leader [Cash]
This is the C setsid() call.
bind_listen_accept_loop_port [Cash]
bind_listen_accept_loop_service [Cash]
bind_listen_accept_loop_unix [Cash]
bind_socket [Cash]
bind_socket socket socket-address assigns a certain local socket-address to a socket.

C
call_terminally [Cash]
call_terminally calls its thunk.
call_with_fdes_fn [Cash]
call_with_... ..
call_with_fdes_in [Cash]
call_with_fdes_out [Cash]
call_with_fdes_... consumer channel calls consumer on the file descriptor underlying channel; takes care of revealed bookkeeping.
call_with_input_file [Cash]
call_with_output_file [Cash]
call_with_string_out_channel [Cash]
The first arg procedure value is called on a channel.
char_filter [Cash]
Returns a procedure that when called, repeatedly reads a character from the current stdin, applies its first argument filter to the character, and writes the result to the current stdout.
chdir [Cash]
close_fd [Cash]
If the fd arg to close_fd has a channel allocated to it, the channel is shifted to a new file descriptor created with {in,out}_channel_of_dup_fd fd before closing the fd.
close_fd_after [Cash]
close_in [Cash]
close_in_after [Cash]
close_out [Cash]
Closing a channel or file descriptor: the 3 procedures around return true if they closed an open channel/fd (this differs from Pervasives.close_{in,out}).
close_out_after [Cash]
close_..._after channel/fd consumer return (consumer channel/fd), but close the channel (or file descriptor) on return.
close_socket [Cash]
close_socket provides a convenient way to close a socket's channel.
command_line [Cash]
The list of strings command_line_arguments contains the arguments passed to the Cash process on the command line.
command_line_arguments [Cash]
connect_socket [Cash]
connect_socket socket socket-address sets up a connection from a socket to a remote socket-address.
control_tty_file_name [Cash]
Return the file-name of the process' control tty.
copy_tty_info [Cash]
These procedures make it possible to create new tty_info records.
cpu_ticks_per_sec [Cash]
Returns the resolution of the CPU timer in clock ticks per second.
create_directory [Cash]
create_fifo [Cash]
create_hard_link [Cash]
create_socket [Cash]
create_socket_pair [Cash]
New sockets are typically created with create_socket.
create_symlink [Cash]
These procedures create objects of various kinds in the file system.
create_temp_file [Cash]
create_temp_file () creates a new temporary file and return its name.
cwd [Cash]

D
date [Cash]
date_of_time [Cash]
Simple date () returns the current date, in the local time zone.
default_field_matcher [Cash]
The default value of ~field arg to field_splitter: "\S+" (non-white-space).
default_field_parser [Cash]
The default value of the ~field_parser argument to field_reader: it is field_splitter (), a parser that picks out sequences of non-white-space strings.
default_infix_matcher [Cash]
The default value of ~delim arg to infix_splitter: "\s+" (white space)
default_suffix_matcher [Cash]
The default value of ~delim arg to suffix_splitter and sloppy_suffix_splitter: "\s+|\z" (white space or eos)
delete_directory [Cash]
delete_file [Cash]
delete_filesys_object [Cash]
These procedures delete objects from the file system.
directory_as_file_name [Cash]
Convert a directory to a simple file-name.
directory_files [Cash]
directory_files dir return the list of files in directory dir.
disable_tty_char [Cash]
To disable a given control-character function, set its corresponding entry in the control_chars string to the special character disable_tty_char (and then use a set_tty_info_... procedure to update the terminal's state).
drain_tty_fd [Cash]
drain_tty_fn [Cash]
The fd/channel/string parameter is an integer file descriptor or Caml channel opened on a terminal device, or a file-name for a terminal device.
drain_tty_in [Cash]
drain_tty_out [Cash]
dup_fd [Cash]
dup_in [Cash]
dup_out [Cash]
These procedures use the Unix dup() syscall to replicate their fd/channel last argument.

E
errno_error [Cash]
Raises a Unix error exception for Unix.error argument.
exec [Cash]
exec_path [Cash]
exec_path_list [Cash]
exec_path_search [Cash]
The low_exec procedure is the low-level interface to the system call.
exec_path_with_env [Cash]
The ..._with_env variants take an optional environment as 2d argument.
exec_with_env [Cash]
exit [Cash]
expand_file_name [Cash]
Resolve and simplify the file-name.

F
fd_of_in_channel [Cash]
fd_of_out_channel [Cash]
These increment the channel's revealed count.
fdes_flags_fd [Cash]
fdes_flags_in [Cash]
fdes_flags_out [Cash]
fdes_of_dup_in [Cash]
fdes_of_dup_out [Cash]
fdes_status_fd [Cash]
fdes_status_in [Cash]
fdes_status_out [Cash]
field_reader [Cash]
This utility returns a procedure that reads records with field structure from a channel.
field_splitter [Cash]
file_group_fd [Cash]
file_group_fn [Cash]
file_group_in [Cash]
file_group_out [Cash]
Return the group id of fn/fd/channel.
file_info_fd [Cash]
file_info_fn [Cash]
file_info_in [Cash]
file_info_out [Cash]
The file_info_... procedures return a record structure containing everything there is to know about a file.
file_inode_fd [Cash]
file_inode_fn [Cash]
file_inode_in [Cash]
file_inode_out [Cash]
Return the inode of fn/fd/channel.
file_last_access_fd [Cash]
file_last_access_fn [Cash]
file_last_access_in [Cash]
file_last_access_out [Cash]
Return the time of last access of fn/fd/channel.
file_last_mod_fd [Cash]
file_last_mod_fn [Cash]
file_last_mod_in [Cash]
file_last_mod_out [Cash]
Return the time of last modification of fn/fd/channel.
file_last_status_change_fd [Cash]
file_last_status_change_fn [Cash]
file_last_status_change_in [Cash]
file_last_status_change_out [Cash]
Return the time of last status change of fn/fd/channel.
file_match [Cash]
file_match root [pat1; pat2; ...] provides a more powerful file-matching service, at the expense of a less convenient notation.
file_mode_fd [Cash]
file_mode_fn [Cash]
file_mode_in [Cash]
file_mode_out [Cash]
Return the mode bits (permissions, setuid, setgid) of fn/fd/channel.
file_name_as_directory [Cash]
Convert a file-name to directory form.
file_name_directory [Cash]
Return the directory component of fname in directory form.
file_name_extension [Cash]
Return the file-name's extension.
file_name_nondirectory [Cash]
Return non-directory component of fname.
file_name_of_path_list [Cash]
Inverse of split_file_name.
file_name_sans_extension [Cash]
Return everything but the extension.
file_nlinks_fd [Cash]
file_nlinks_fn [Cash]
file_nlinks_in [Cash]
file_nlinks_out [Cash]
Return the number of hard links to this fn/fd/channel.
file_not_exists_fd [Cash]
file_not_exists_fn [Cash]
file_not_exists_in [Cash]
file_not_exists_out [Cash]
file_owner_fd [Cash]
file_owner_fn [Cash]
file_owner_in [Cash]
file_owner_out [Cash]
Return the owner of fn/fd/channel.
file_size_fd [Cash]
file_size_fn [Cash]
file_size_in [Cash]
file_size_out [Cash]
Return the size in bytes of fn/fd/channel.
file_type_fd [Cash]
file_type_fn [Cash]
file_type_in [Cash]
file_type_out [Cash]
Return the type of fn/fd/channel.
flush_all_chans [Cash]
This procedure flushes all open output channels with buffered data.
flush_tty_both_fd [Cash]
flush_tty_both_fn [Cash]
The fd/channel/string parameter is an integer file descriptor or Caml channel opened on a terminal device, or a file-name for a terminal device.
flush_tty_both_in [Cash]
flush_tty_both_out [Cash]
flush_tty_input_fd [Cash]
flush_tty_input_fn [Cash]
flush_tty_input_in [Cash]
flush_tty_input_out [Cash]
flush_tty_output_fd [Cash]
flush_tty_output_fn [Cash]
flush_tty_output_in [Cash]
flush_tty_output_out [Cash]
fold_directory [Cash]
fold_directory folds the file names of a directory in the same way as fold_input, except `.' and `..'.
fold_in_channel [Cash]
fold_in_channel ichan reader op seed can be used to perform a variety of iterative operations over an input stream.
fold_input [Cash]
fold_input f init reader source is a folder in the sort of List.fold_left, but instead of folding a 'a list, you give it a reader function (such as read_line), and a source (as stdin).
force_output [Cash]
This procedure flushes buffered output, and raises a write-error exception on error.
fork [Cash]
fork_child [Cash]
fork_child_with_pipe [Cash]
fork_child_with_pipe_plus [Cash]
fork_pty_session [Cash]
fork_pty_session thunk gives a convenient high-level interface to pseudo-terminals.
fork_with_pipe [Cash]
fork_with_pipe_plus [Cash]
format_date [Cash]
string_of_date formats the date as a 24-character string of the form:
    Sun Sep 16 01:03:52 1973

G
gen_field_reader [Cash]
Although the record reader typically returns a string, and the field-parser typically takes a string argument, this is not required.
getenv [Cash]
gid_to_groupname [Cash]
These two procedures convert integer gid's and group names to the other form.
glob [Cash]
glob [patterns] glob each pattern against the filesystem and return the sorted list.
glob_quote [Cash]
glob_quote str returns a constant glob pattern that exactly matches str.
group_info [Cash]
group_info_name [Cash]
Return a group_info record for this group: an integer gid (for group_info), or a string group-name (for group_info_name).
groupname_to_gid [Cash]

H
home_dir [Cash]
Returns ~user's home directory.
home_directory [Cash]
Cash accesses $HOME at start-up time, and stores the value in the global variable home_directory.
home_file [Cash]
Returns file-name fname relative to ~user's home directory; ~user defaults to the current user.
host_info_addr [Cash]
host_info_... allow a program to look up a host entry based on either its string name or socket_address.
host_info_name [Cash]

I
in_channel_of_dup_fd [Cash]
in_channel_of_dup_out [Cash]
in_channel_of_fd [Cash]
in_channel_revealed [Cash]
index [Cash]
This is like String.index and String.index_from altogether (~from defaults to 0), but it never raises Not_found: instead, it packages their result in an option type; (note: you can use Env_3_11.internal_index to get -1 if the char is not found).
inet_addr_any [Cash]
inet_addr_broadcast [Cash]
The use of inet_addr_any is described below in bind_socket.
inet_addr_loopback [Cash]
infix_splitter [Cash]
internet_address_of_socket_address [Cash]
These routines return the address-family-specific addresses.
is_alphabetic [Cash]
== is_letter_or_digit.
is_alphanumeric [Cash]
== is_letter_or_digit.
is_ascii [Cash]
is_blank [Cash]
is_digit [Cash]
is_file_directory_fd [Cash]
is_file_directory_fn [Cash]
is_file_directory_in [Cash]
is_file_directory_out [Cash]
is_file_executable_fd [Cash]
is_file_executable_fn [Cash]
is_file_executable_in [Cash]
is_file_executable_out [Cash]
is_file_existing_fd [Cash]
is_file_existing_fn [Cash]
is_file_existing_in [Cash]
is_file_existing_out [Cash]
is_file_fifo_fd [Cash]
is_file_fifo_fn [Cash]
is_file_fifo_in [Cash]
is_file_fifo_out [Cash]
is_file_name_absolute [Cash]
Does fname begin with a root or ~ component? (Recognising ~ as a home-directory specification is an extension of Posix rules.)
   is_file_name_absolute "/usr/shivers"         => true
   is_file_name_absolute "src/des"              => false
   is_file_name_absolute "~/src/des"            => true 
Non-obvious case:
   is_file_name_absolute ""                     => true (* i.e., root *) 
is_file_name_directory [Cash]
is_file_name_non_directory [Cash]
These predicates return true if the string is in directory form, or file-name form (see the above discussion of these two forms).
is_file_not_executable_fd [Cash]
is_file_not_executable_fn [Cash]
is_file_not_executable_in [Cash]
is_file_not_executable_out [Cash]
is_file_not_readable_fd [Cash]
is_file_not_readable_fn [Cash]
is_file_not_readable_in [Cash]
is_file_not_readable_out [Cash]
is_file_not_writable_fd [Cash]
is_file_not_writable_fn [Cash]
is_file_not_writable_in [Cash]
is_file_not_writable_out [Cash]
is_file_readable_fd [Cash]
is_file_readable_fn [Cash]
is_file_readable_in [Cash]
is_file_readable_out [Cash]
is_file_regular_fd [Cash]
is_file_regular_fn [Cash]
is_file_regular_in [Cash]
is_file_regular_out [Cash]
is_file_socket_fd [Cash]
is_file_socket_fn [Cash]
is_file_socket_in [Cash]
is_file_socket_out [Cash]
is_file_special_fd [Cash]
is_file_special_fn [Cash]
is_file_special_in [Cash]
is_file_special_out [Cash]
is_file_symlink_fd [Cash]
is_file_symlink_fn [Cash]
is_file_symlink_in [Cash]
is_file_symlink_out [Cash]
is_file_writable_fd [Cash]
is_file_writable_fn [Cash]
is_file_writable_in [Cash]
is_file_writable_out [Cash]
is_graphic [Cash]
is_hex_digit [Cash]
is_iso_control [Cash]
is_letter [Cash]
is_letter_or_digit [Cash]
is_lower_case [Cash]
is_numeric [Cash]
== is_digit.
is_printing [Cash]
is_punctuation [Cash]
is_title_case [Cash]
is_tty_fd [Cash]
is_tty_in [Cash]
is_tty_out [Cash]
Return true if the argument is a tty.
is_upper_case [Cash]
is_whitespace [Cash]
itimer [Cash]
This is a straighforward interface to Unix.getitimer (if no newstat) and Unix.setitimer.

L
list_of_in_channel [Cash]
Generalises these two procedures.
listen_socket [Cash]
listen_socket socket backlog allows a stream socket to start receiving connections, allowing a queue of up to backlog connection requests.
low_exec [Cash]
low_exit [Cash]
These procedures terminate the current process with a given exit status.
low_fork [Cash]
fork () is like C fork().
low_fork_with_pipe [Cash]
Like fork, fork_child and low_fork, but the parent and child communicate via a pipe connecting the parent's stdin to the child's stdout.
low_fork_with_pipe_plus [Cash]
Like fork_with_pipe et al.
low_read_delimited_bang [Cash]
This low-level delimited reader uses an alternate interface.

M
make_command_line_arguments [Cash]
Usage: insert the following code in front of your script:
  let command_line_arguments = ref (make_command_line_arguments ()) 
(suppress ref if you don't intend to modify it.) Then you get the intended command_line_arguments.
make_date [Cash]
When making a date record, the last five elements of the record are optional; the first three default (tzn, tzs, summ) to None, the last two (wday, yday) to 0.
make_pty_generator [Cash]
make_pty_generator () returns a generator of candidate pty names.
make_string_in_channel [Cash]
Returns a channel that reads characters from the supplied string.
make_string_out_channel [Cash]
A string output channel is a channel that collects the characters given to it into a string (well, a temp file, in fact).
make_tty_info [Cash]
move_fd_to_fdes [Cash]
move_in_channel_to_fdes [Cash]
move_out_channel_to_fdes [Cash]
move_{in,out}_channel_to_fdes channel target-fd: channel is shifted to target-fd, by duping its underlying file-descriptor if necessary.

N
network_info_addr [Cash]
network_info_... allow a program to look up a network entry based on either its string name or socket_address.
network_info_name [Cash]
nice [Cash]
nice_pid [Cash]
These procedures manipulate nice values of processes.

O
open_control_tty_in [Cash]
open_control_tty_out [Cash]
This procedure opens terminal device tty_name as the process' control terminal (see the termios man page for more information on control terminals).
open_fdes [Cash]
Same as open_file_{in,out}, but returns a file descriptor.
open_file_in [Cash]
open_file_... ~perms fname flags: perms defaults to 0o666.
open_file_out [Cash]
open_input_file [Cash]
open_output_file [Cash]
These are equivalent to open_file_..., after adding the read/write mode to the flags argument to O_RDONLY or O_WRONLY, respectively (so don't use them).
open_pty [Cash]
This procedure finds a free pty/tty pair, and opens the pty device with read/write access.
openfile [Cash]
For Cash proper operation, you must use this openfile in place of the Unix one; ours calls Unix.set_close_on_exec on the returned file_descr, to make all the channel-mapping machinery work smoothly.
out_channel_of_dup_fd [Cash]
out_channel_of_dup_in [Cash]
out_channel_of_fd [Cash]
out_channel_revealed [Cash]
Return the channel's revealed count.

P
parent_pid [Cash]
parse_file_name [Cash]
Let f be file_name_nondirectory fname.
pause_until_interrupt [Cash]
The name says it all.
pid [Cash]
pid_of_proc [Cash]
Extract the process id out of a proc object.
pipe [Cash]
Returns two channels, the read and write end-points of a Unix pipe.
priority [Cash]
priority_pid [Cash]
proc_of_pid [Cash]
This procedure maps integer Unix process ids to Cash process objects.
process_group [Cash]
process_times [Cash]
Get the process_times of the current process.
protocol_info_name [Cash]
protocol_info_port [Cash]
protocol_info_... allow a program to look up a protocol entry based on either its string name or integer port.
pty_name_of_tty_name [Cash]
These two procedures map between corresponding terminal and pty controller names.

R
read_delimited [Cash]
read_delimited_bang [Cash]
read_delimited_bang_split [Cash]
Side-effecting variants of read_delimited.
read_delimited_split [Cash]
Read until we encounter one of the chars in charset or eof.
read_line [Cash]
Reads and returns one line of text; on eof, raises End_of_file.
read_line_split [Cash]
Same as read_line, but returns separately the line and the delimiter (maybe Eof).
read_paragraph [Cash]
read_paragraph_split [Cash]
These procedures skip blank lines, then read text from a channel until a blank line or eof is found.
read_string [Cash]
read_string_bang [Cash]
read_string_bang_in [Cash]
These calls read exactly as much data as you requested, unless there is not enough data (eof).
read_string_bang_partial [Cash]
read_string_bang_partial_in [Cash]
These are atomic best-effort/forward-progress calls.
read_string_in [Cash]
read_string_partial [Cash]
read_string_partial_in [Cash]
read_symlink [Cash]
Return the filename referenced by symbolic link fname.
reap_zombies [Cash]
This procedure reaps all outstanding exited child processes into Cash.
receive_message [Cash]
receive_message_bang [Cash]
receive_message_bang_partial [Cash]
receive_message_partial [Cash]
record_reader [Cash]
record_reader_split [Cash]
record_reader ~delims ~elide_delims ~handle_delim () returns a procedure that reads records from a channel.
release_in_channel_handle [Cash]
release_out_channel_handle [Cash]
Decrement the channel's revealed count.
rename_file [Cash]
When using rename_file old_fname new_fname, if you override an existing object, then old_fname and new_fname must type-match --- either both directories, or both non-directories.
replace_extension [Cash]
replace_extension fname ext replaces fname's extension with ext.
resolve_file_name [Cash]
Do ~ expansion., If ~dir is given, convert a relative file-name to an absolute file-name, relative to directory ~dir.
rindex [Cash]
Same with rindex (and Env_3_11.internal_rindex); ~from defaults to the length of the string.
run_with_collecting [Cash]
Run processes that produce multiple output streams and return channels open on these streams.
run_with_file [Cash]
Value is name of a temp file containing process's output.
run_with_in_channel [Cash]
Value is an in_channel open on process's stdout.
run_with_inchan_plus_proc [Cash]
This procedure can be used if the programmer also wishes access to the process' pid, exit status, or other information.
run_with_out_channel [Cash]
Value is an out_channel open on process's stdin.
run_with_outchan_plus_proc [Cash]
This procedure is the dual of the preceding: the program has to write to the child's stdin.
run_with_sexp [Cash]
Reads a single object from process' stdout with Sexp.read.
run_with_sexps [Cash]
Repeatedly reads objects from process' stdout with Sexp.read.
run_with_string [Cash]
Value is a string containing process' output.
run_with_strings [Cash]
Splits process' output into a list of newline-delimited strings.

S
seek_fd [Cash]
seek_in [Cash]
seek_out [Cash]
Reposition the I/O cursor for a file descriptor or channel.
select [Cash]
The select procedure allows a process to block and wait for events on multiple I/O channels.
select_bang [Cash]
send_message [Cash]
send_message_partial [Cash]
send_tty_break_fd [Cash]
send_tty_break_fn [Cash]
The fd/channel/string parameter is an integer file descriptor or Caml channel opened on a terminal device, or a file-name for a terminal device.
send_tty_break_in [Cash]
send_tty_break_out [Cash]
service_info_name [Cash]
service_info_port [Cash]
service_info_... allow a program to look up a service entry based on either its string name or integer port.
set_chan_buffering_in [Cash]
set_chan_buffering_out [Cash]
set_chan_buffering_... channel ~size:size policy allows the programmer to assign a particular I/O buffering policy to a channel, and to choose the size of the associated buffer.
set_exec_path_list [Cash]
set_fdes_flags_fd [Cash]
set_fdes_flags_in [Cash]
set_fdes_flags_out [Cash]
These procedures allow reading and writing of an open file's flags.
set_fdes_status_fd [Cash]
set_fdes_status_in [Cash]
set_fdes_status_out [Cash]
These procedures allow reading and writing of an open file's status flags (see table below).
set_file_group_fd [Cash]
set_file_group_fn [Cash]
set_file_group_in [Cash]
set_file_group_out [Cash]
These procedures set the permission bits, owner id, and group id of a file, respectively.
set_file_mode_fd [Cash]
set_file_mode_fn [Cash]
set_file_mode_in [Cash]
set_file_mode_out [Cash]
set_file_owner_fd [Cash]
set_file_owner_fn [Cash]
set_file_owner_in [Cash]
set_file_owner_out [Cash]
set_file_times [Cash]
This procedure sets the access and modified times for the file to the supplied values (see around date for the Cash representation of time).
set_gid [Cash]
These routines get and set the effective and real user and group ids.
set_priority [Cash]
set_priority_pid [Cash]
set_process_group [Cash]
set_process_group_pid [Cash]
pid and parent_pid retrieve the process id for the current process and its parent.
set_socket_option_bool [Cash]
set_socket_option_float [Cash]
set_socket_option_int [Cash]
set_socket_option_optint [Cash]
set_stderr [Cash]
These procedures set the standard I/O channels to new values, the old ones being abandoned in the great bit bucket --- no flush, no close.
set_stdin [Cash]
set_stdout [Cash]
set_temp_file_template [Cash]
set_tty_info_drain_fd [Cash]
set_tty_info_drain_fn [Cash]
set_tty_info_drain_in [Cash]
set_tty_info_drain_out [Cash]
set_tty_info_flush_fd [Cash]
set_tty_info_flush_fn [Cash]
The fd/channel/string parameter is an integer file descriptor or Caml channel opened on a terminal device, or a file-name for a terminal device.
set_tty_info_flush_in [Cash]
set_tty_info_flush_out [Cash]
set_tty_info_now_fd [Cash]
set_tty_info_now_fn [Cash]
set_tty_info_now_in [Cash]
set_tty_info_now_out [Cash]
set_tty_process_group_fd [Cash]
set_tty_process_group_fn [Cash]
These eight procedures get and set the process group of a given terminal.
set_tty_process_group_in [Cash]
set_tty_process_group_out [Cash]
set_uid [Cash]
set_umask [Cash]
setenv [Cash]
These functions get and set the process environment, stored in the external C variable char **environ.
setenv_from_alist [Cash]
The alist argument is installed as the current Unix environment (i.e.
sexp_list_of_in_channel [Cash]
Repeatedly reads data from the channel until eof, then returns the accumulated list of items in a schemeish form.
shutdown_socket [Cash]
shutdown_socket how_to shuts down part of a full-duplex socket.
signal_process [Cash]
signal_process_group [Cash]
signal_process_group_pgrp [Cash]
These two pair of procedures send signals to a specific process, and all the processes in a specific process group, respectively.
signal_process_pid [Cash]
simplify_file_name [Cash]
Removes leading and internal occurrences of dot.
skip_char_set [Cash]
skip_char_set skip_chars skips characters occurring in the set skip_chars, and returns the number of characters skipped.
sleep [Cash]
sleep_until [Cash]
The sleep procedure causes the process to sleep for secs seconds.
sloppy_suffix_splitter [Cash]
These functions return a parser function that can be used as follows:
    parser ~start string            => string list 
sockaddr_of_host_and_port [Cash]
sockaddr_of_host_and_service [Cash]
At a slightly higher level of interface, you can also give an host name and a port number (or service name) to one of these two procedures, which resolve the given name(s) to make an Internet socket address.
socket_address_of_internet_address [Cash]
socket_address_of_internet_address host_address service_port returns a socket_address based on an host_address and an integer service_port.
socket_address_of_unix_address [Cash]
socket_address_of_unix_address pathname returns a socket-address based on the string pathname.
socket_connect [Cash]
socket_connect socket_address socket_type is intended for creating client applications.
socket_local_address [Cash]
socket_option_bool [Cash]
socket_option_float [Cash]
socket_option_int [Cash]
socket_option_optint [Cash]
socket_remote_address [Cash]
Sockets can be associated with a local address or a remote address or both.
split_file_name [Cash]
Split a file-name into its components.
start_tty_input_fd [Cash]
start_tty_input_fn [Cash]
start_tty_input_in [Cash]
start_tty_input_out [Cash]
start_tty_output_fd [Cash]
start_tty_output_fn [Cash]
start_tty_output_in [Cash]
start_tty_output_out [Cash]
stdchans_to_stdio [Cash]
This causes the standard I/O file descriptors (0, 1, and 2) to take their values from the current standard I/O channels.
stdio_to_stdchans [Cash]
This causes the bindings of the current standard I/O channels to be changed to channels constructed over the standard I/O file descriptors.
stop_tty_input_fd [Cash]
stop_tty_input_fn [Cash]
These procedures can be used to control a terminal's input and output flow.
stop_tty_input_in [Cash]
stop_tty_input_out [Cash]
stop_tty_output_fd [Cash]
stop_tty_output_fn [Cash]
stop_tty_output_in [Cash]
stop_tty_output_out [Cash]
string_filter [Cash]
Returns a procedure that when called, repeatedly reads a string from the current stdin, applies its first argument filter to the string, and writes the result to the current stdout.
string_list_of_in_channel [Cash]
Repeatedly reads newline-terminated strings from the channel until eof, then returns the accumulated list of strings.
string_of_date [Cash]
string_of_in_channel [Cash]
Reads the channel until eof, then returns the accumulated string.
string_out_channel_output [Cash]
The accumulated string is retrieved by applying string_out_channel_output to the channel.
substitute_env_vars [Cash]
Replace occurrences of environment variables with their values.
substring [Cash]
This is like String.sub but uses two indices in the string, instead of the start position and the length to search.
suffix_splitter [Cash]
suspend [Cash]
Suspend the current process with a SIGSTOP signal.
sync_file_fd [Cash]
sync_file_out [Cash]
sync_file_system [Cash]
Calling sync_file_... causes Unix to update the disk data structures for a given file.
system_name [Cash]
Returns the name of the host on which we are executing.

T
tell_fd [Cash]
tell_in [Cash]
tell_out [Cash]
Return the position of the I/O cursor in the the I/O stream.
temp_file_channel [Cash]
This procedure can be used to provide an interprocess communications channel with arbitrary-sized buffering.
temp_file_iterate [Cash]
This procedure can be used to perform certain atomic transactions on the file system involving filenames.
ticks_per_sec [Cash]
The current time, with sub-second resolution.
time [Cash]
time_of_date [Cash]
Simple time () returns the current time.
time_plus_ticks [Cash]
truncate_file_fd [Cash]
truncate_file_fn [Cash]
truncate_file_in [Cash]
truncate_file_out [Cash]
truncate_file_... fname/file descriptor/channel len truncates the specified file is to len bytes in length.
tty_file_name_fd [Cash]
tty_file_name_in [Cash]
tty_file_name_out [Cash]
The argument must be a file descriptor or channel open on a tty.
tty_info_fd [Cash]
tty_info_fn [Cash]
The fd/channel/string parameter is an integer file descriptor, Caml channel opened on a terminal device, or a file-name for a terminal device.
tty_info_in [Cash]
tty_info_out [Cash]
tty_name_of_pty_name [Cash]
tty_process_group_fd [Cash]
tty_process_group_fn [Cash]
tty_process_group_in [Cash]
tty_process_group_out [Cash]
ttyc [Cash]
Control-flags.
ttychar [Cash]
ttyin [Cash]
These are the named flags for the tty_info record's input_flags field.
ttyl [Cash]
Local-flags.
ttyout [Cash]
Output-flags (before bs_delay).

U
uid_to_username [Cash]
These two procedures convert integer uid's and user names to the other form.
umask [Cash]
unix_address_of_socket_address [Cash]
unwind_protect [Cash]
unwind_protect thunk protect ed, named after a similar functionality of Lisp, calls thunk, then, before returning its result (be it a value or an exception), ensures that protect is applied to ed.
user_effective_gid [Cash]
user_effective_uid [Cash]
user_gid [Cash]
user_info [Cash]
user_info_name [Cash]
Return a user_info record for this user: an integer uid (for user_info), or a string user-name (for user_info_name).
user_login_name [Cash]
user_supplementary_gids [Cash]
user_uid [Cash]
username_to_uid [Cash]

V
version [Cash]

W
wait [Cash]
wait_any [Cash]
The optional flags argument is as for wait.
wait_pid [Cash]
These procedures wait until a child process exits, and returns its exit code.
wait_process_group [Cash]
wait_process_group_pgrp [Cash]
These procedures wait for any child whose process group is proc (a process object, for wait_process_group) or pgrp (an integer process group id, for wait_process_group_pgrp).
with_cwd [Cash]
with_env [Cash]
with_errors_to_file [Cash]
The file named by the first argument is opened for input or output, an input or output channel connected to it is made into stdin, stdout or stderr (see with_std... in Channel manipulation and standard channels) and the thunk is called.
with_exec_path_list [Cash]
Cash accesses $PATH at start-up time, colon-splits the path list, and stores the value in an unexported variable, accessible by exec_path_list ().
with_input_from_file [Cash]
with_output_to_file [Cash]
with_stderr [Cash]
These procedures install the given channel as the stdin, stdout, and stderr channel, respectively, for the duration of a call to their 2d argument.
with_stdin [Cash]
with_stdio_chans [Cash]
Binds the standard channels stdin, stdout, and stderr to be channels on file descriptors 0, 1, 2, and then calls its 1st argument.
with_stdout [Cash]
with_temp_file_template [Cash]
The actual default prefix used by create_temp_file and template for temp_file_iterate can be overridden for increased security, and is controlled by these two procs, which modify it permanently (set_temp_file_template) or temporarily (with_temp_file_template).
with_total_env [Cash]
These procedures call their last argument thunk in the context of an altered environment.
with_umask [Cash]
The process' current umask is retrieved with umask, and set with set_umask perms.
write_string [Cash]
write_string_out [Cash]
These procedures write all the data requested.
write_string_partial [Cash]
write_string_partial_out [Cash]
These routines are the atomic best-effort/forward-progress analog to write_string....

X
xsubstring [Cash]
This eXtended substring accepts negative indices, meaning to count from the end of the string: -1 is the last char, so xsubstring s (-2) (-1) extracts the last char.