Index of values


(=) [Versioned_typed_tcp.Mode]
(=) [Versioned_typed_tcp.Dont_care_about_mode]
__t_of_sexp__ [Versioned_typed_tcp.Client_msg.Control]
__t_of_sexp__ [Versioned_typed_tcp.Client_msg]
__t_of_sexp__ [Versioned_typed_tcp.Server_msg.Control]
__t_of_sexp__ [Versioned_typed_tcp.Read_result]
__t_of_sexp__ [Versioned_typed_tcp.Dont_care_about_mode]
__t_of_sexp__ [Log.Level]

A
abort [Rpc.State_rpc]
abort [Rpc.Pipe_rpc]
abort rpc connection id given an RPC and the id returned as part of a call to dispatch, abort requests that the other side of the connection stop sending updates.
add [Versioned_typed_tcp.Version]
add [Versioned_rpc.Menu]
add impls extends a list of rpc implementations with an additional rpc implementation for providing a Menu.t when one is requested via Menu.request.
after [Udp.Config.Fields]
after [Udp.Config]
arg [Dynamic_port_writer]
For use with Command.
async_basic [Command]
async_basic is exactly the same as Core.Command.basic, except that the function it wraps returns unit Deferred.t, instead of unit.

B
before [Udp.Config.Fields]
before [Udp.Config]
bigsubstring_allocator [Versioned_typed_tcp]
bin_error [Rpc.State_rpc]
bin_error [Rpc.Pipe_rpc]
bin_query [Rpc.State_rpc]
bin_query [Rpc.Pipe_rpc]
bin_query [Rpc.Rpc]
bin_read_t [Versioned_typed_tcp.Datumable_of_binable.T_bin]
bin_read_t [Versioned_typed_tcp.Client_msg.Control]
bin_read_t [Versioned_typed_tcp.Client_msg]
bin_read_t [Versioned_typed_tcp.Server_msg.Control]
bin_read_t [Versioned_typed_tcp.Read_result]
bin_read_t [Versioned_typed_tcp.Dont_care_about_mode]
bin_read_t [User_and_group]
bin_read_t [Tcp_file.Client.Message]
bin_read_t [Log.Message]
bin_read_t [Dynamic_port_writer]
bin_read_t_ [Versioned_typed_tcp.Datumable_of_binable.T_bin]
bin_read_t_ [Versioned_typed_tcp.Client_msg.Control]
bin_read_t_ [Versioned_typed_tcp.Client_msg]
bin_read_t_ [Versioned_typed_tcp.Server_msg.Control]
bin_read_t_ [Versioned_typed_tcp.Read_result]
bin_read_t_ [Versioned_typed_tcp.Dont_care_about_mode]
bin_read_t_ [User_and_group]
bin_read_t_ [Tcp_file.Client.Message]
bin_read_t_ [Log.Message]
bin_read_t_ [Dynamic_port_writer]
bin_read_t__ [Versioned_typed_tcp.Datumable_of_binable.T_bin]
bin_read_t__ [Versioned_typed_tcp.Client_msg.Control]
bin_read_t__ [Versioned_typed_tcp.Client_msg]
bin_read_t__ [Versioned_typed_tcp.Server_msg.Control]
bin_read_t__ [Versioned_typed_tcp.Read_result]
bin_read_t__ [Versioned_typed_tcp.Dont_care_about_mode]
bin_read_t__ [User_and_group]
bin_read_t__ [Tcp_file.Client.Message]
bin_read_t__ [Log.Message]
bin_read_t__ [Dynamic_port_writer]
bin_reader_t [Versioned_typed_tcp.Datumable_of_binable.T_bin]
bin_reader_t [Versioned_typed_tcp.Client_msg.Control]
bin_reader_t [Versioned_typed_tcp.Client_msg]
bin_reader_t [Versioned_typed_tcp.Server_msg.Control]
bin_reader_t [Versioned_typed_tcp.Read_result]
bin_reader_t [Versioned_typed_tcp.Dont_care_about_mode]
bin_reader_t [User_and_group]
bin_reader_t [Tcp_file.Client.Message]
bin_reader_t [Log.Message]
bin_reader_t [Dynamic_port_writer]
bin_response [Rpc.Pipe_rpc]
bin_response [Rpc.Rpc]
bin_size_t [Versioned_typed_tcp.Datumable_of_binable.T_bin]
bin_size_t [Versioned_typed_tcp.Client_msg.Control]
bin_size_t [Versioned_typed_tcp.Client_msg]
bin_size_t [Versioned_typed_tcp.Server_msg.Control]
bin_size_t [Versioned_typed_tcp.Read_result]
bin_size_t [Versioned_typed_tcp.Dont_care_about_mode]
bin_size_t [User_and_group]
bin_size_t [Tcp_file.Client.Message]
bin_size_t [Log.Message]
bin_size_t [Dynamic_port_writer]
bin_state [Rpc.State_rpc]
bin_t [Versioned_typed_tcp.Datumable_of_binable.T_bin]
bin_t [Versioned_typed_tcp.Client_msg.Control]
bin_t [Versioned_typed_tcp.Client_msg]
bin_t [Versioned_typed_tcp.Server_msg.Control]
bin_t [Versioned_typed_tcp.Read_result]
bin_t [Versioned_typed_tcp.Dont_care_about_mode]
bin_t [User_and_group]
bin_t [Tcp_file.Client.Message]
bin_t [Log.Message]
bin_t [Dynamic_port_writer]
bin_update [Rpc.State_rpc]
bin_write_t [Versioned_typed_tcp.Datumable_of_binable.T_bin]
bin_write_t [Versioned_typed_tcp.Client_msg.Control]
bin_write_t [Versioned_typed_tcp.Client_msg]
bin_write_t [Versioned_typed_tcp.Server_msg.Control]
bin_write_t [Versioned_typed_tcp.Read_result]
bin_write_t [Versioned_typed_tcp.Dont_care_about_mode]
bin_write_t [User_and_group]
bin_write_t [Tcp_file.Client.Message]
bin_write_t [Log.Message]
bin_write_t [Dynamic_port_writer]
bin_write_t_ [Versioned_typed_tcp.Datumable_of_binable.T_bin]
bin_write_t_ [Versioned_typed_tcp.Client_msg.Control]
bin_write_t_ [Versioned_typed_tcp.Client_msg]
bin_write_t_ [Versioned_typed_tcp.Server_msg.Control]
bin_write_t_ [Versioned_typed_tcp.Read_result]
bin_write_t_ [Versioned_typed_tcp.Dont_care_about_mode]
bin_write_t_ [User_and_group]
bin_write_t_ [Tcp_file.Client.Message]
bin_write_t_ [Log.Message]
bin_write_t_ [Dynamic_port_writer]
bin_writer_t [Versioned_typed_tcp.Datumable_of_binable.T_bin]
bin_writer_t [Versioned_typed_tcp.Client_msg.Control]
bin_writer_t [Versioned_typed_tcp.Client_msg]
bin_writer_t [Versioned_typed_tcp.Server_msg.Control]
bin_writer_t [Versioned_typed_tcp.Read_result]
bin_writer_t [Versioned_typed_tcp.Dont_care_about_mode]
bin_writer_t [User_and_group]
bin_writer_t [Tcp_file.Client.Message]
bin_writer_t [Log.Message]
bin_writer_t [Dynamic_port_writer]
bind [Udp]
bind_any [Udp]
bind_to_interface_exn [Udp]
bytes_to_write [Rpc_intf.Connection]
bytes_to_write [File_writer]
bytes_to_write () returns the sum over all async_file_writers of how many bytes they need to write.

C
capacity [Udp.Config.Fields]
capacity [Udp.Config]
client [Rpc_intf.Connection]
client ~host ~port () connects to the server at (host,port) and returns the connection or an Error if a connection could not be made.
client_addr_port [Typed_tcp_intf.S]
client_send_version [Versioned_typed_tcp.S.Server]
client_send_version [Versioned_typed_tcp.Make.Server]
close [Versioned_typed_tcp.S.Server]
close t client close connection to client if it exists.
close [Versioned_typed_tcp.Make.Server]
close [Typed_tcp_intf.Arg.Transport]
close [Typed_tcp_intf.S]
close [Tcp_file.Server]
close t closes the file t for writing.
close [Tcp.Server]
close t starts closing the listening socket, and returns a deferred that becomes determined after Fd.close_finished fd on the socket's fd.
close [Rpc_intf.Connection]
close [Log]
close closes a log so that further write attempts will raise an error.
close [File_writer]
close_connection [Versioned_typed_tcp.S.Client]
If a connection is currently established, close it.
close_connection [Versioned_typed_tcp.Make.Client]
close_finished [Tcp.Server]
close_finished [Rpc_intf.Connection]
connect [Versioned_typed_tcp.S.Client]
connect t If the connection is not currently established, initiate one.
connect [Versioned_typed_tcp.Make.Client]
connect [Tcp_file.Client]
connect ~host ~port connect to the server at (host,port)
connect [Tcp]
connect ~host ~port is a convenience wrapper around connect_sock that returns the socket, and a reader and writer for the socket.
connect_sock [Tcp]
connect_sock ~host ~port opens a TCP connection to the specified hostname and port, returning the socket.
connection [Versioned_rpc.Connection_with_menu]
create [Weak_hashtbl]
create [Versioned_typed_tcp.S.Client]
create a new (initially disconnected) client
create [Versioned_typed_tcp.S.Server]
create a new server, and start listening
create [Versioned_typed_tcp.Make.Client]
create [Versioned_typed_tcp.Make.Server]
create [Versioned_rpc.Connection_with_menu]
create [User_and_group]
create [Udp.Config.Fields]
create [Udp.Config]
create [Typed_tcp_intf.Arg.Transport]
create [Typed_tcp_intf.S]
create [Tcp.Server]
create where_to_listen handler starts a server listening to a socket as specified by where_to_listen.
create [Tcp.Where_to_listen]
create [Sequencer_table.Make]
create [Rpc_intf.Connection]
Initiate an Rpc connection on the given reader/writer pair.
create [Rpc.State_rpc]
create [Rpc.Pipe_rpc]
create [Rpc.Rpc]
create [Rpc.Implementations]
create ~implementations ~on_unknown_rpc creates a server capable of responding to the rpc's implemented in the implementation list.
create [Log.Blocking.Output]
create [Log.Output]
create f returns a t, given a function that actually performs the final output work.
create [Log]
create create a new log
create [Lock_file.Nfs]
create [Lock_file]
create ?message path tries to create a file at path containing the text message, pid if none provided.
create [File_writer]
create file opens file, creating it if it doesn't exist.
create [File_tail]
create file creates a File_tail.t that will immediately begin reading file, and then will start the stat-read loop.
create [Dynamic_port_writer]
create_exn [Rpc.Implementations]
create_exn [Lock_file.Nfs]
create_exn [Lock_file]
create_exn ?message path is like create except that it throws an exception on failure instead of returning a boolean value
critical_section [Lock_file.Nfs]
current [Versioned_typed_tcp.Mode]
current [Versioned_typed_tcp.Dont_care_about_mode]

D
debug [Log.Global_intf]
debug [Log.Blocking]
error printf like logging at the `Info log level
debug [Log]
debug printf like logging at the `Debug log level
debug_snapshot [Tcp_file.Server]
debug_snapshot () returns an s-expression containing details of the current state of the Tcp_file server.
default_capacity [Udp]
The default buffer capacity for UDP-oriented buffers is 1472, determined as the typical Ethernet MTU (1500 octets) less the typical UDP header length (28).
deprecated_dispatch_multi [Versioned_rpc.Caller_converts.Pipe_rpc.S]
deprecated_dispatch_multi [Versioned_rpc.Caller_converts.Rpc.S]
description [Rpc.Implementation]
disconnect [Tcp_file.Client]
disconnect t disconnect from t.
dispatch [Rpc.State_rpc]
dispatch [Rpc.Pipe_rpc]
This has (..., 'error) Result.t as its return type to represent the possibility of the call itself being somehow erroneous (but understood - the outer Or_error.t encompasses failures of that nature).
dispatch [Rpc.Rpc]
dispatch_exn [Rpc.Pipe_rpc]
dispatch_exn [Rpc.Rpc]
dispatch_multi [Versioned_rpc.Both_convert.Plain.S]
multi-version dispatch
dispatch_multi [Versioned_rpc.Caller_converts.Pipe_rpc.S]
dispatch_multi [Versioned_rpc.Caller_converts.Rpc.S]
multi-version dispatch

E
enqueue [Sequencer_table.Make]
enqueue t ~key f enqueues f for key.
error [Log.Global_intf]
error [Log.Blocking]
error printf like logging at the `Info log level
error [Log]
error printf like logging at the `Error log level
exists [Udp.Config.Fields]

F
file [Log.Output]
find [Weak_hashtbl]
find_or_add [Weak_hashtbl]
find_state [Sequencer_table.Make]
flag [Dynamic_port_writer]
One can pass a t from parent to child by including flag_args t in the command-line arguments and using flag in the Command.t in the child.
flag_args [Dynamic_port_writer]
flushed [Versioned_typed_tcp.S.Client]
flushed [Versioned_typed_tcp.S.Server]
flushed [Versioned_typed_tcp.Make.Client]
flushed [Versioned_typed_tcp.Make.Server]
flushed [Tcp_file.Server]
flushed t becomes determined only once all messages written to t have been written to disk.
flushed [Log.Global_intf]
flushed [Log]
flushed returns a Deferred.t that is fulfilled when the last message delivered to t before the call to flushed is out the door.
flushed [File_writer]
flushed_time [Typed_tcp_intf.Arg.Transport]
flushed_time [Typed_tcp_intf.S]
fold [Udp.Config.Fields.Direct]
fold [Udp.Config.Fields]
fold [Sequencer_table.Make]
Fold over keys with states or pending/running jobs.
for_all [Udp.Config.Fields]
for_this_process [User_and_group]
for_this_process_exn [User_and_group]

G
get_hostname_and_pid [Lock_file.Nfs]
get_message [Lock_file.Nfs]
group [User_and_group]

H
has_client_id [Typed_tcp_intf.S]

I
implement [Rpc.State_rpc]
implement [Rpc.Pipe_rpc]
implement [Rpc.Rpc]
implement_multi [Versioned_rpc.Both_convert.Plain.S]
implement multiple versions at once
implement_multi [Versioned_rpc.Callee_converts.Pipe_rpc.S]
implement multiple versions at once
implement_multi [Versioned_rpc.Callee_converts.Rpc.S]
implement multiple versions at once
info [Log.Global_intf]
info [Log.Blocking]
info printf like logging at the `Info log level
info [Log]
info printf like logging at the `Info log level
init [Udp.Config.Fields]
init [Udp.Config]
invariant [Versioned_typed_tcp.Make.Server]
invariant [Tcp.Server]
is_closed [Tcp.Server]
is_closed [Rpc_intf.Connection]
is_locked [Lock_file]
is_locked path returns true when the file at path exists and is locked, false otherwise.
iter [Udp.Config.Fields.Direct]
iter [Udp.Config.Fields]

L
last_connect_error [Versioned_typed_tcp.S.Client]
last_connect_error t returns the error (if any) that happened on the last connection attempt.
last_connect_error [Versioned_typed_tcp.Make.Client]
length [Tcp_file.Client.Message]
None is returned in cases where the message cannot fit into a string (original message was a very large Bigstring
level [Log.Message]
lift [Rpc.Implementation]
We may want to use an 'a t implementation (perhaps provided by someone else) in a 'b t context.
listen [Versioned_typed_tcp.S.Client]
listen t
listen [Versioned_typed_tcp.S.Server]
listen t listen to the stream of messages and errors coming from clients
listen [Versioned_typed_tcp.Make.Client]
listen [Versioned_typed_tcp.Make.Server]
listen [Typed_tcp_intf.S]
listen_ignore_errors [Versioned_typed_tcp.S.Client]
listen_ignore_errors t like listen, but with no errors or meta data.
listen_ignore_errors [Versioned_typed_tcp.S.Server]
listen_ignore_errors t like listen, but omit error conditions and metadata.
listen_ignore_errors [Versioned_typed_tcp.Make.Client]
listen_ignore_errors [Versioned_typed_tcp.Make.Server]
listen_ignore_errors [Typed_tcp_intf.S]
listening_on [Tcp.Server]
load [Persistent_singleton.S]
load [Persistent_singleton.Make]
log [Log.Global_intf]
lookup_marshal_fun [Versioned_typed_tcp.Datumable]
lookup_marshal_fun v This function takes a version v, and returns a function that will downgrade (if necessary) the current version to v and then write it to a bigsubstring.
lookup_marshal_fun [Versioned_typed_tcp.Datumable_of_binable.Make_datumable5]
lookup_unmarshal_fun [Versioned_typed_tcp.Datumable]
lookup_unmarshal_fun v This function takes a version v, and returns a function that unmarshals a message and upgrades it, returning zero or more messages as a result of the upgrade.
lookup_unmarshal_fun [Versioned_typed_tcp.Datumable_of_binable.Make_datumable5]
low_version [Versioned_typed_tcp.Versions]
low_version [Versioned_typed_tcp.Datumable_of_binable.Pre_versions]

M
make_creator [Udp.Config.Fields]
map [Udp.Config.Fields]
map_poly [Udp.Config.Fields]
mem [Sequencer_table.Make]
mem t key returns true if there is state or an pending/running job
menu [Versioned_rpc.Connection_with_menu]
message [Log.Global_intf]
message [Log.Message]
message [Log]
monitor [File_writer]

N
name [Rpc.State_rpc]
name [Rpc.Pipe_rpc]
name [Rpc.Rpc]
the same values as were passed to create.
names [Udp.Config.Fields]
null [Rpc_intf.Connection.Client_implementations]
null [Rpc.Implementations]
a server that can handle no queries
num_unfinished_jobs [Sequencer_table.Make]
num_unfinished_jobs t key returns the number of jobs for key including including pending and running.

O
of_lazy [Log.Global_intf]
of_lazy [Log]
of_lazy logging of lazy values.
of_v [Versioned_typed_tcp.Datumable_of_binable.V.S]
on_file [Tcp]
on_port [Tcp]
on_port_chosen_by_os [Tcp]
open_file [Tcp_file.Server]
open_file filename open a file for writing.

P
pipe [Log.Reader]
pipe format filename returns a pipe of all the messages in the log.
port [Versioned_typed_tcp.S.Server]
get the port that the server is listening on
port [Versioned_typed_tcp.Make.Server]
printf [Log.Global_intf]
printf [Log]
printf generalized printf style logging
prod_version [Versioned_typed_tcp.Versions]
prod_version [Versioned_typed_tcp.Datumable_of_binable.Pre_versions]
protocol_version [Versioned_typed_tcp]

R
raw [Log.Global_intf]
logging functions as the functions that operate on a given log.
raw [Log.Blocking]
raw printf like logging for raw (no level) messages.
raw [Log]
raw printf like logging for raw (no level) messages.
read [Typed_tcp_intf.Arg.Transport]
read [Tcp_file.Client]
read t filename provides a pipe that will be filled with messages from filename starting from the beginning, and continuing until the server calls unlink or close.
read_loop [Udp]
read_loop_with_buffer_replacement [Udp]
recvfrom_loop [Udp]
recvfrom_loop_with_buffer_replacement callback calls callback synchronously on each message received.
recvfrom_loop_with_buffer_replacement [Udp]
recvmmsg_loop [Udp]
recvmmsg_loop ~socket callback iteratively receives up to max_count packets at a time on socket and passes them to callback.
remove [Weak_hashtbl]
replace [Weak_hashtbl]
request [Versioned_rpc.Menu]
request an rpc version menu from an rpc connection
rotating_file [Log.Output]
rpc [Versioned_rpc.Callee_converts.Pipe_rpc.Make.Register]
rpc [Versioned_rpc.Callee_converts.Rpc.Make.Register]
rpc [Versioned_rpc.Caller_converts.Pipe_rpc.Make.Register]
rpc [Versioned_rpc.Caller_converts.Rpc.Make.Register]

S
save [Persistent_singleton.S]
save [Persistent_singleton.Make]
schedule_bigstring [File_writer]
schedule_message [Tcp_file.Server]
schedule_message t msg is write, but the message is taken from the provided bigstring.
send [Versioned_typed_tcp.S.Client]
send t msg send a message to the server.
send [Versioned_typed_tcp.S.Server]
send t client msg send msg to client.
send [Versioned_typed_tcp.Make.Client]
send [Versioned_typed_tcp.Make.Server]
send [Typed_tcp_intf.S]
send_ignore_errors [Versioned_typed_tcp.S.Client]
send_ignore_errors t exactly like send but with no error reporting.
send_ignore_errors [Versioned_typed_tcp.S.Server]
send_ignore_errors t client msg Just like send, but does not report results.
send_ignore_errors [Versioned_typed_tcp.Make.Client]
send_ignore_errors [Versioned_typed_tcp.Make.Server]
send_ignore_errors [Typed_tcp_intf.S]
send_to_all [Versioned_typed_tcp.S.Server]
send_to_all t msg send the same message to all connected clients.
send_to_all [Versioned_typed_tcp.Make.Server]
send_to_all [Typed_tcp_intf.S]
send_to_all_ignore_errors [Versioned_typed_tcp.S.Server]
send_to_all_ignore_errors t msg Just like send_to_all but with no error reporting.
send_to_all_ignore_errors [Versioned_typed_tcp.Make.Server]
send_to_some [Versioned_typed_tcp.S.Server]
send_to_some t msg names send the same message to multiple connected clients.
send_to_some [Versioned_typed_tcp.Make.Server]
send_to_some_ignore_errors [Versioned_typed_tcp.S.Server]
send_to_some_ignore_errors t msg Just like send_to_some but with no error reporting.
send_to_some_ignore_errors [Versioned_typed_tcp.Make.Server]
sendto [Udp]
sendto_sync [Udp]
sendto_sync sock buf addr does not try again if sock is not ready to write.
serve [Tcp_file.Server]
serve ~port () must be called before clients will be able to connect.
serve [Rpc_intf.Connection]
serve implementations ~port ?on_handshake_error () starts a server with the given implementation on port.
serve_existing_static_file [Tcp_file.Server]
serve_existing_static_file filename adds filename to the list of files that can be accessed via the Client module.
server_with_close [Rpc_intf.Connection]
set_level [Log.Global_intf]
set_level [Log.Blocking]
set_level [Log]
set_level sets the level of the given log.
set_output [Log.Global_intf]
set_output [Log.Blocking]
set_output [Log]
set_output changes the output type of the log, which can be useful when daemonizing.
set_state [Sequencer_table.Make]
set_state t key state_opt sets the state for key immediately.
sexp [Log.Global_intf]
sexp [Log]
sexp logging of values without first converting them to a string.
sexp_of_t [Versioned_typed_tcp.Client_msg.Control]
sexp_of_t [Versioned_typed_tcp.Client_msg]
sexp_of_t [Versioned_typed_tcp.Server_msg.Control]
sexp_of_t [Versioned_typed_tcp.Read_result]
sexp_of_t [Versioned_typed_tcp.Dont_care_about_mode]
sexp_of_t [User_and_group]
sexp_of_t [Unpack_sequence.Result]
sexp_of_t [Tcp_file.Client.Error]
sexp_of_t [Rpc.Implementation.Description]
sexp_of_t [Log.Rotation]
sexp_of_t [Log.Message]
sexp_of_t [Log.Level]
sexp_of_t [File_writer]
sexp_of_t [File_tail.Update]
sexp_of_t [File_tail.Warning]
sexp_of_t [File_tail.Error]
sexp_of_t [Dynamic_port_writer]
shutdown [Versioned_typed_tcp.S.Server]
shutdown [Versioned_typed_tcp.Make.Server]
state [Versioned_typed_tcp.S.Client]
state t
state [Versioned_typed_tcp.Make.Client]
stderr [Log.Blocking.Output]
stderr [Log.Output]
see Async_extended.Syslog for syslog output.
stdout [Log.Blocking.Output]
stdout [Log.Output]
stop [Udp.Config.Fields]
stop [Udp.Config]
stop_serving [Tcp_file.Server]
stop_serving t stops serving the file t to clients.
supported_rpcs [Versioned_rpc.Menu]
find what rpcs are supported
supported_versions [Versioned_rpc.Menu]
find what versions of a particular rpc are supported

T
t_of_sexp [Versioned_typed_tcp.Client_msg.Control]
t_of_sexp [Versioned_typed_tcp.Client_msg]
t_of_sexp [Versioned_typed_tcp.Server_msg.Control]
t_of_sexp [Versioned_typed_tcp.Read_result]
t_of_sexp [Versioned_typed_tcp.Dont_care_about_mode]
t_of_sexp [User_and_group]
t_of_sexp [Tcp_file.Client.Error]
t_of_sexp [Rpc.Implementation.Description]
t_of_sexp [Log.Rotation]
t_of_sexp [Log.Message]
t_of_sexp [Log.Level]
t_of_sexp [Dynamic_port_writer]
tags [Log.Message]
tail [Tcp_file.Client]
tail t filename same as read, but delivers messages starting at some unspecified point near the current end of the file and continuing until the server calls unlink or close.
test_version [Versioned_typed_tcp.Versions]
time [Log.Message]
to_bigstring [Tcp_file.Client.Message]
to_error [Unpack_sequence.Result]
to_file [Tcp]
to_host_and_port [Tcp]
to_list [Udp.Config.Fields]
to_string [Tcp_file.Client.Message]
to_string [Tcp_file.Client.Error]
to_string_exn [Tcp_file.Client.Message]
to_string_hum [File_tail.Update]
to_string_hum [File_tail.Warning]
to_string_hum [File_tail.Error]
to_v [Versioned_typed_tcp.Datumable_of_binable.V.S]

U
unlock_safely [Lock_file.Nfs]
unpack_bin_prot_from_reader [Unpack_sequence]
unpack_from_reader [Unpack_sequence]
unpack_from_string_pipe [Unpack_sequence]
unpack_from_string_pipe unpack_buffer input returns (output, result), and uses unpack_buffer to unpack values from input until input is closed.
user [User_and_group]

V
version [Rpc.State_rpc]
version [Rpc.Pipe_rpc]
version [Rpc.Rpc]
versions [Versioned_rpc.Both_convert.Plain.S]
all supported versions.
versions [Versioned_rpc.Callee_converts.Pipe_rpc.S]
all versions supported by dispatch_multi.
versions [Versioned_rpc.Callee_converts.Rpc.S]
all versions implemented by implement_multi (useful for computing which old versions may be pruned)
versions [Versioned_rpc.Caller_converts.Pipe_rpc.S]
all versions supported by dispatch_multi.
versions [Versioned_rpc.Caller_converts.Rpc.S]
all versions supported by dispatch_multi.

W
waiting_create [Lock_file.Nfs]
waiting_create [Lock_file]
wait_create ~path ~message becomes determined when the file at path gets locked.
where_to_listen [Dynamic_port_writer]
with_client [Rpc_intf.Connection]
with_client ~host ~port f connects to the server at (host,port) and runs f until an exception is thrown or until the returned Deferred is fulfilled.
with_close [Rpc_intf.Connection]
with_close tries to create a t using the given reader and writer.
with_connection [Tcp]
with_connection ~host ~port f looks up host from a string (using DNS as needed), connects, then calls f, passing the connected socket and a reader and writer for it.
with_file [Tcp_file.Server]
with_file filename ~f opens filename and runs f, passing the resultant t.
write [Typed_tcp_intf.Arg.Transport]
write [File_writer]
write t s writes s to the file.
write_bigsubstring [File_writer]
write_bin_prot [File_writer]
write_message [Tcp_file.Server]
write_message t msg write msg to t.
write_sexp [Tcp_file.Server]
write_sexp t sexp writes a Sexp.t as a single message
write_sexp [File_writer]
write_substring [File_writer]
writer [Log.Output]
writer_monitor [Tcp_file.Server]
monitor t returns a monitor which will listen to errors arising from the internal writer used by t.