A |
accept [Unix_syscalls.Socket] |
|
accept_interruptible [Unix_syscalls.Socket] |
|
acceptconn [Unix_syscalls.Socket.Opt] |
|
access [Unix_syscalls] |
|
access_exn [Unix_syscalls] |
|
add [Raw_signal_manager.Handlers] |
|
add_exn [Fd_by_descr] |
add_exn t fd fails if the file descriptor for fd is already in t .
|
add_finalizer [Raw_scheduler] |
|
add_finalizer [Async_gc] |
add_finalizer f x is like Gc.finalise f x , except that the finalizer is guaranteed
to run as an Async job (i.e.
|
addr [Unix_syscalls.Socket.Address.Inet] |
|
am_holding_async_lock [Thread_safe] |
am_holding_async_lock () returns true if the currently running thread is holding the
async lock.
|
am_holding_lock [Raw_scheduler] |
|
any_of_sexp [Read_write] |
|
argv [Async_sys] |
|
at_shutdown [Shutdown] |
at_shutdown f causes f () to be run when shutdown is called, and for shutdown
to wait until the returned deferred finishes.
|
atime [Unix_syscalls.Stats.Fields] |
|
atime [Unix_syscalls.Stats] |
|
B |
be_the_scheduler [Raw_scheduler] |
|
bin_buffer_age_limit [Writer] |
|
bin_read_buffer_age_limit [Writer] |
|
bin_read_buffer_age_limit_ [Writer] |
|
bin_read_buffer_age_limit__ [Writer] |
|
bin_read_t [Unix_syscalls.Inet_addr] |
|
bin_read_t [Unix_syscalls.Socket.Address.Inet] |
|
bin_read_t [Unix_syscalls.Socket.Address.Unix] |
|
bin_read_t [Unix_syscalls.Socket.Address] |
|
bin_read_t [Reader.Read_result] |
|
bin_read_t_ [Unix_syscalls.Inet_addr] |
|
bin_read_t_ [Unix_syscalls.Socket.Address.Inet] |
|
bin_read_t_ [Unix_syscalls.Socket.Address.Unix] |
|
bin_read_t_ [Unix_syscalls.Socket.Address] |
|
bin_read_t_ [Reader.Read_result] |
|
bin_read_t__ [Unix_syscalls.Inet_addr] |
|
bin_read_t__ [Unix_syscalls.Socket.Address.Inet] |
|
bin_read_t__ [Unix_syscalls.Socket.Address.Unix] |
|
bin_read_t__ [Unix_syscalls.Socket.Address] |
|
bin_read_t__ [Reader.Read_result] |
|
bin_reader_buffer_age_limit [Writer] |
|
bin_reader_t [Unix_syscalls.Inet_addr] |
|
bin_reader_t [Unix_syscalls.Socket.Address.Inet] |
|
bin_reader_t [Unix_syscalls.Socket.Address.Unix] |
|
bin_reader_t [Unix_syscalls.Socket.Address] |
|
bin_reader_t [Reader.Read_result] |
|
bin_size_buffer_age_limit [Writer] |
|
bin_size_t [Unix_syscalls.Inet_addr] |
|
bin_size_t [Unix_syscalls.Socket.Address.Inet] |
|
bin_size_t [Unix_syscalls.Socket.Address.Unix] |
|
bin_size_t [Unix_syscalls.Socket.Address] |
|
bin_size_t [Reader.Read_result] |
|
bin_t [Unix_syscalls.Inet_addr] |
|
bin_t [Unix_syscalls.Socket.Address.Inet] |
|
bin_t [Unix_syscalls.Socket.Address.Unix] |
|
bin_t [Unix_syscalls.Socket.Address] |
|
bin_t [Reader.Read_result] |
|
bin_write_buffer_age_limit [Writer] |
|
bin_write_buffer_age_limit_ [Writer] |
|
bin_write_t [Unix_syscalls.Inet_addr] |
|
bin_write_t [Unix_syscalls.Socket.Address.Inet] |
|
bin_write_t [Unix_syscalls.Socket.Address.Unix] |
|
bin_write_t [Unix_syscalls.Socket.Address] |
|
bin_write_t [Reader.Read_result] |
|
bin_write_t_ [Unix_syscalls.Inet_addr] |
|
bin_write_t_ [Unix_syscalls.Socket.Address.Inet] |
|
bin_write_t_ [Unix_syscalls.Socket.Address.Unix] |
|
bin_write_t_ [Unix_syscalls.Socket.Address] |
|
bin_write_t_ [Reader.Read_result] |
|
bin_writer_buffer_age_limit [Writer] |
|
bin_writer_t [Unix_syscalls.Inet_addr] |
|
bin_writer_t [Unix_syscalls.Socket.Address.Inet] |
|
bin_writer_t [Unix_syscalls.Socket.Address.Unix] |
|
bin_writer_t [Unix_syscalls.Socket.Address] |
|
bin_writer_t [Reader.Read_result] |
|
bind [Unix_syscalls.Socket] |
|
bind_any [Unix_syscalls.Inet_addr] |
|
bind_any_inet6 [Unix_syscalls.Inet_addr] |
|
block_on_async [Thread_safe] |
block_on_async f runs f () in the async world and blocks until the result becomes
determined.
|
block_on_async_exn [Thread_safe] |
|
broadcast [Unix_syscalls.Socket.Opt] |
|
buffer_age_limit_of_sexp [Writer] |
create ?buf_len ?syscall ?buffer_age_limit fd creates a new writer.
|
buffer_age_limit_of_sexp__ [Writer] |
|
bytes_to_write [Writer] |
bytes_to_write t returns how many bytes have been requested to write but have not
yet been written.
|
bytes_written [Writer] |
bytes_written t returns how many bytes have been written.
|
C |
chdir [Unix_syscalls] |
|
chdir [Async_sys] |
|
chmod [Unix_syscalls] |
|
chown [Unix_syscalls] |
|
chroot [Unix_syscalls] |
|
clear [Interruptor] |
clear t causes read_fd t to become not ready for reading.
|
clear_close_on_exec [Unix_syscalls] |
|
close [Unix_syscalls] |
close fd closes the file descriptor fd , and raises an exception if fd has
already been closed.
|
close [Writer] |
close ?force_close t waits for the writer to be flushed, and then calls Unix.close
on the underlying file descriptor.
|
close [Reader] |
close t prevents further use of t and closes t 's underlying file descriptor.
|
close [Fd] |
close t prevents further use of t , and closes the underlying file descriptor once
all the current uses are finished.
|
close_finished [Writer] |
|
close_finished [Reader] |
|
close_finished [Raw_fd.T.Fields] |
|
close_finished [Raw_fd.T] |
|
close_finished [Fd] |
|
closedir [Unix_syscalls] |
|
command [Async_sys] |
|
compare [Unix_syscalls.Inet_addr] |
|
compare [Unix_syscalls.Socket.Address.Unix] |
|
connect [Unix_syscalls.Socket] |
|
connect_interruptible [Unix_syscalls.Socket] |
|
consumer_left [Writer] |
consumer_left t returns a deferred that becomes determined when t attempts to
write to a pipe that broke because the consumer on the other side left.
|
contents [Reader] |
contents t returns the string corresponding to the full contents (up to EOF) of the
reader.
|
copy [Read_write] |
|
core_scheduler [Raw_scheduler.Fields] |
|
core_scheduler [Raw_scheduler] |
|
cores [Unix_syscalls] |
cores () Returns the number of cores
|
create [Unix_syscalls.Group.Fields] |
|
create [Unix_syscalls.Passwd.Fields] |
|
create [Unix_syscalls.Stats.Fields] |
|
create [Writer] |
|
create [Work_group] |
|
create [Unix_syscalls.Socket.Address.Inet] |
|
create [Unix_syscalls.Socket.Address.Unix] |
|
create [Unix_syscalls.Socket] |
|
create [Signal_manager] |
create creates and returns a signal manager t .
|
create [Read_write] |
|
create [Reader] |
create ~buf_len fd creates a new reader that is reading from fd .
|
create [Raw_signal_manager.Handlers] |
|
create [Raw_signal_manager] |
|
create [Raw_scheduler.Fields] |
|
create [Raw_scheduler] |
|
create [Raw_fd.T.Fields] |
|
create [Raw_fd] |
|
create [Io_stats] |
|
create [In_thread.Helper_thread] |
|
create [Interruptor] |
|
create [File_descr_watcher_intf.S] |
create ~num_file_descrs creates a new file-descr-watcher that is able to watch
file descriptors in [0, num_file_descrs)
.
|
create [Fd_by_descr] |
|
create [Fd] |
create kind file_descr creates a new t of the underlying kind and file
descriptor.
|
create_bind_any [Unix_syscalls.Socket.Address.Inet] |
|
create_both [Read_write] |
|
create_fd [Raw_scheduler] |
|
create_fn [Read_write] |
|
create_with [Read_write] |
|
createi [Read_write] |
|
ctime [Unix_syscalls.Stats.Fields] |
|
ctime [Unix_syscalls.Stats] |
|
current_execution_context [Raw_scheduler] |
|
current_thread_id [Raw_scheduler] |
|
cycle_count [Scheduler] |
cycle_count () returns the total number of async cycles that have happened.
|
cycle_count [Raw_scheduler] |
|
cycle_start [Scheduler] |
cycle_start () returns the result of Time.now () called at the beginning of
cycle.
|
cycle_start [Raw_scheduler] |
|
cycle_times [Scheduler] |
cycle_times () returns a stream that will have one element for each cycle that Async
runs, with the amount of time that the cycle took (as determined by calls to Time.now
at the beginning and end of the cycle).
|
cycle_times [Raw_scheduler] |
|
D |
debug [Unix_syscalls.Socket.Opt] |
|
debug [Raw_scheduler] |
|
debug [Raw_fd] |
|
dec_num_active_syscalls_fd [Raw_scheduler] |
|
deferred [Thread_safe] |
deferred () returns (d, fill) where d is a deferred that will become determined
with value v once fill v is called.
|
deliver [Raw_signal_manager.Handlers] |
|
dev [Unix_syscalls.Stats.Fields] |
|
dev [Unix_syscalls.Stats] |
|
dir [Unix_syscalls.Passwd.Fields] |
|
dir [Unix_syscalls.Passwd] |
|
dontroute [Unix_syscalls.Socket.Opt] |
|
E |
empty [File_descr_watcher_intf.Post] |
|
environment [Unix_syscalls] |
|
eprintf [Async_print] |
|
equal [Raw_fd] |
|
error [Unix_syscalls.Socket.Opt] |
|
error_of_sexp [Unix_syscalls] |
|
executable_name [Async_sys] |
|
exists [Unix_syscalls.Group.Fields] |
|
exists [Unix_syscalls.Passwd.Fields] |
|
exists [Unix_syscalls.Stats.Fields] |
|
exists [Read_write] |
|
exists [Raw_scheduler.Fields] |
|
exists [Raw_fd.T.Fields] |
|
exit [Std] |
|
F |
fchmod [Unix_syscalls] |
|
fchown [Unix_syscalls] |
|
fd [Writer] |
fd t
|
fd [Unix_syscalls.Socket] |
|
fd [Reader] |
fd t
|
fd_by_descr [Raw_scheduler.Fields] |
|
fd_by_descr [Raw_scheduler] |
|
fdatasync [Unix_syscalls] |
|
fdatasync [Writer] |
|
fds_whose_watching_has_changed [Raw_scheduler.Fields] |
|
fds_whose_watching_has_changed [Raw_scheduler] |
|
file_contents [Reader] |
file_contents file returns the string with the full contents of the file
|
file_descr [Raw_fd.T.Fields] |
|
file_descr [Raw_fd.T] |
|
file_descr_exn [Fd] |
file_descr_exn t returns the file descriptor underlying t , unless is_closed t ,
in which case it raises.
|
file_descr_watcher [Raw_scheduler.Fields] |
|
file_descr_watcher [Raw_scheduler] |
|
file_exists [Async_sys] |
|
file_exists_exn [Async_sys] |
|
finalise [Async_gc] |
finalise is rebound to avoid accidental use in Async programs.
|
finalizer_jobs [Raw_scheduler.Fields] |
|
finalizer_jobs [Raw_scheduler] |
|
find [Fd_by_descr] |
|
flip [Read_write.Key] |
|
flushed [Writer] |
flushed t returns a deferred that will become determined when all prior writes
complete (i.e.
|
flushed_time [Writer] |
|
fold [Unix_syscalls.Group.Fields.Direct] |
|
fold [Unix_syscalls.Group.Fields] |
|
fold [Unix_syscalls.Passwd.Fields.Direct] |
|
fold [Unix_syscalls.Passwd.Fields] |
|
fold [Unix_syscalls.Stats.Fields.Direct] |
|
fold [Unix_syscalls.Stats.Fields] |
|
fold [Read_write] |
|
fold [Raw_scheduler.Fields.Direct] |
|
fold [Raw_scheduler.Fields] |
|
fold [Raw_fd.T.Fields.Direct] |
|
fold [Raw_fd.T.Fields] |
|
fold [Fd_by_descr] |
|
foldi [Read_write] |
|
for_all [Unix_syscalls.Group.Fields] |
|
for_all [Unix_syscalls.Passwd.Fields] |
|
for_all [Unix_syscalls.Stats.Fields] |
|
for_all [Read_write] |
|
for_all [Raw_scheduler.Fields] |
|
for_all [Raw_fd.T.Fields] |
|
fork_exec [Unix_syscalls] |
fork_exec ~prog ~args ?path ?env forks and execs prog with args , and returns the
child pid.
|
fprintf [Async_print] |
|
fstat [Unix_syscalls] |
|
fsync [Unix_syscalls] |
|
fsync [Writer] |
|
ftruncate [Unix_syscalls] |
|
G |
gecos [Unix_syscalls.Passwd.Fields] |
|
gecos [Unix_syscalls.Passwd] |
|
get [Read_write] |
|
get [Io_stats] |
|
get_handlers [Raw_signal_manager] |
|
getbyaddr [Unix_syscalls.Host] |
|
getbyaddr_exn [Unix_syscalls.Host] |
|
getbygid [Unix_syscalls.Group] |
|
getbygid_exn [Unix_syscalls.Group] |
|
getbyname [Unix_syscalls.Group] |
|
getbyname [Unix_syscalls.Passwd] |
|
getbyname [Unix_syscalls.Host] |
|
getbyname_exn [Unix_syscalls.Group] |
|
getbyname_exn [Unix_syscalls.Passwd] |
|
getbyname_exn [Unix_syscalls.Host] |
|
getbyuid [Unix_syscalls.Passwd] |
|
getbyuid_exn [Unix_syscalls.Passwd] |
|
getcwd [Unix_syscalls] |
|
getcwd [Async_sys] |
|
getegid [Unix_syscalls] |
|
getenv [Unix_syscalls] |
|
getenv_exn [Unix_syscalls] |
|
geteuid [Unix_syscalls] |
|
getgid [Unix_syscalls] |
|
gethostname [Unix_syscalls] |
|
getlogin [Unix_syscalls] |
Return the login name of the user executing the process.
|
getopt [Unix_syscalls.Socket] |
|
getpeername [Unix_syscalls.Socket] |
|
getpid [Unix_syscalls] |
|
getppid [Unix_syscalls] |
|
getppid_exn [Unix_syscalls] |
|
getsockname [Unix_syscalls.Socket] |
|
gettimeofday [Unix_syscalls] |
|
getuid [Unix_syscalls] |
|
gid [Unix_syscalls.Group.Fields] |
|
gid [Unix_syscalls.Group] |
|
gid [Unix_syscalls.Passwd.Fields] |
|
gid [Unix_syscalls.Passwd] |
|
gid [Unix_syscalls.Stats.Fields] |
|
gid [Unix_syscalls.Stats] |
|
gmtime [Unix_syscalls] |
|
go [Scheduler] |
go ?raise_unhandled_exn () passes control to Async, at which point Async starts
running handlers, one by one without interruption, until there are no more handlers to
run.
|
go [Raw_scheduler] |
|
go_main [Scheduler] |
go_main is like go , except that one supplies a main function that will be run to
initialize the async computation, and that go_main will fail if any async has been
used prior to go_main being called.
|
go_main [Raw_scheduler] |
|
H |
handle [Signal] |
handle ?stop signals ~f arranges so that whenever a signal in signals is
delivered, f is called on that signal.
|
handle_default [Signal] |
We override values from Core.Signal that we don't want people to use with
Async.
|
handle_delivered [Signal_manager] |
handle_delivered t runs all signal handlers on the signals that have been
delivered but not yet handled.
|
handle_delivered [Raw_signal_manager] |
|
handle_signal [Signal_manager] |
handle_signal t signal causes t to manage handling of signal , so that it will
record all future deliveries of that signal.
|
handle_signal [Raw_signal_manager] |
|
have_address_in_common [Unix_syscalls.Host] |
|
have_lock_do_cycle [Raw_scheduler] |
|
have_set_nonblock [Raw_fd.T.Fields] |
|
have_set_nonblock [Raw_fd.T] |
|
I |
i_am_the_scheduler [Raw_scheduler] |
|
id [Writer] |
id t
|
id [Reader] |
id t
|
ignore [Signal] |
|
inc_num_active_syscalls [Raw_fd] |
|
inet [Unix_syscalls.Socket.Family] |
|
infer_using_stat [Fd.Kind] |
|
info [Raw_fd.T.Fields] |
|
info [Raw_fd.T] |
|
info [Fd] |
|
init [Raw_scheduler] |
|
ino [Unix_syscalls.Stats.Fields] |
|
ino [Unix_syscalls.Stats] |
|
install_handler [Signal_manager] |
|
install_handler [Raw_signal_manager] |
|
interactive [Async_sys] |
|
interruptor [Raw_scheduler.Fields] |
|
interruptor [Raw_scheduler] |
|
invariant [Writer] |
invariant t raises an exception if the writer is in a bad state
|
invariant [Signal_manager] |
|
invariant [Reader] |
|
invariant [Raw_signal_manager] |
|
invariant [Raw_scheduler] |
|
invariant [Raw_fd.Watching] |
|
invariant [Raw_fd] |
|
invariant [Interruptor] |
|
invariant [File_descr_watcher_intf.S] |
|
invariant [Fd_by_descr] |
|
io_stats [Writer] |
io_stats Overall IO statistics for all writers
|
io_stats [Reader] |
io_stats Overall IO statistics for all readers
|
is_closed [Writer] |
|
is_closed [Reader] |
|
is_closed [Raw_fd] |
|
is_closed [Fd] |
|
is_directory [Async_sys] |
|
is_file [Async_sys] |
|
is_main_thread [Raw_scheduler] |
|
is_open [Writer] |
|
is_open [Raw_fd.State] |
|
is_open [Raw_fd] |
|
is_open [Fd] |
is_open t is not (is_closed t )
|
is_ready_to_initialize [Scheduler] |
|
is_ready_to_initialize [Raw_scheduler] |
|
is_running [Scheduler] |
is_running () returns true if the scheduler has been started.
|
is_running [Raw_scheduler.Fields] |
|
is_running [Raw_scheduler] |
|
iter [Unix_syscalls.Group.Fields.Direct] |
|
iter [Unix_syscalls.Group.Fields] |
|
iter [Unix_syscalls.Passwd.Fields.Direct] |
|
iter [Unix_syscalls.Passwd.Fields] |
|
iter [Unix_syscalls.Stats.Fields.Direct] |
|
iter [Unix_syscalls.Stats.Fields] |
|
iter [Read_write] |
|
iter [Raw_scheduler.Fields.Direct] |
|
iter [Raw_scheduler.Fields] |
|
iter [Raw_fd.T.Fields.Direct] |
|
iter [Raw_fd.T.Fields] |
|
iter [File_descr_watcher_intf.S] |
iter t ~f iterates over every file descriptor in the map, apply f to it once
for each of {`Read,`Write} that it is being watched for.
|
iter [Fd_by_descr] |
|
iteri [Read_write] |
|
K |
keepalive [Unix_syscalls.Socket.Opt] |
|
kind [Unix_syscalls.Stats.Fields] |
|
kind [Unix_syscalls.Stats] |
|
kind [Raw_fd.T.Fields] |
|
kind [Raw_fd.T] |
|
kind [Fd] |
kind t returns the kind of file descriptor that t is.
|
L |
last_read_time [Reader] |
last_read_time t returns time of the most recent read system call that
returned data.
|
lines [Reader] |
lines t reads all the lines from t and puts them in the pipe, one line per pipe
element.
|
linger [Unix_syscalls.Socket.Opt] |
|
link [Unix_syscalls] |
|
listen [Unix_syscalls.Socket] |
|
load_sexp [Reader] |
load_sexp ?exclusive file ~f loads and convert the S-expression in a given file
using f , and returns the deferred conversion result as a variant of either Ok res
or Error exn otherwise.
|
load_sexp_exn [Reader] |
|
load_sexps [Reader] |
load_sexps file ~f load and convert the S-expressions in a given file using f ,
and return the deferred list of conversion results as variants of either Ok res or
Error exn otherwise.
|
load_sexps_exn [Reader] |
|
localhost [Unix_syscalls.Inet_addr] |
|
localhost_inet6 [Unix_syscalls.Inet_addr] |
|
localtime [Unix_syscalls] |
|
lock [Raw_scheduler] |
|
lockf [Unix_syscalls] |
lockf fd read_or_write ?len exclusively locks for reading/writing the section of the
open file fd specified by the current file position and len (see man lockf).
|
lseek [Unix_syscalls] |
|
lstat [Unix_syscalls] |
|
M |
make_creator [Unix_syscalls.Group.Fields] |
|
make_creator [Unix_syscalls.Passwd.Fields] |
|
make_creator [Unix_syscalls.Stats.Fields] |
|
make_creator [Raw_scheduler.Fields] |
|
make_creator [Raw_fd.T.Fields] |
|
map [Unix_syscalls.Group.Fields] |
|
map [Unix_syscalls.Passwd.Fields] |
|
map [Unix_syscalls.Stats.Fields] |
|
map [Read_write] |
|
map [Raw_scheduler.Fields] |
|
map [Raw_fd.T.Fields] |
|
map_poly [Unix_syscalls.Group.Fields] |
|
map_poly [Unix_syscalls.Passwd.Fields] |
|
map_poly [Unix_syscalls.Stats.Fields] |
|
map_poly [Raw_scheduler.Fields] |
|
map_poly [Raw_fd.T.Fields] |
|
mapi [Read_write] |
|
maybe_start_closing_fd [Raw_scheduler] |
|
mem [Unix_syscalls.Group.Fields] |
|
mem [Unix_syscalls.Group] |
|
mkdir [Unix_syscalls] |
|
mkdtemp [Unix_syscalls] |
|
mkstemp [Unix_syscalls] |
|
mktime [Unix_syscalls] |
|
monitor [Writer] |
monitor t returns the writer's monitor.
|
mtime [Unix_syscalls.Stats.Fields] |
|
mtime [Unix_syscalls.Stats] |
|
mutex [Raw_scheduler.Fields] |
|
mutex [Raw_scheduler] |
|
mutex_for_initializing_the_one_and_only_ref [Raw_scheduler] |
|
N |
name [Unix_syscalls.Group.Fields] |
|
name [Unix_syscalls.Group] |
|
name [Unix_syscalls.Passwd.Fields] |
|
name [Unix_syscalls.Passwd] |
|
names [Unix_syscalls.Group.Fields] |
|
names [Unix_syscalls.Passwd.Fields] |
|
names [Unix_syscalls.Stats.Fields] |
|
names [Raw_scheduler.Fields] |
|
names [Raw_fd.T.Fields] |
|
newline [Writer] |
|
nice [Unix_syscalls] |
|
nlink [Unix_syscalls.Stats.Fields] |
|
nlink [Unix_syscalls.Stats] |
|
nodelay [Unix_syscalls.Socket.Opt] |
|
num_active_syscalls [Raw_fd.T.Fields] |
|
num_active_syscalls [Raw_fd.T] |
|
O |
of_fd [Unix_syscalls.Socket] |
|
of_in_channel [Reader] |
|
of_in_channel [Fd] |
of_in_channel and of_out_channel create an fd from their underlying file
descriptor.
|
of_in_channel_auto [Fd] |
of_in_channel_auto ic is just like of_in_channel, but uses fstat to determine the
kind.
|
of_out_channel [Writer] |
|
of_out_channel [Fd] |
|
of_out_channel_auto [Fd] |
of_out_channel_auto ic is just like of_out_channel, but uses fstat to determine
the kind.
|
of_string [Unix_syscalls.Inet_addr] |
|
of_string_or_getbyname [Unix_syscalls.Inet_addr] |
of_string_or_getbyname hostname does a DNS lookup of hostname and returns the
resulting IP address.
|
oobinline [Unix_syscalls.Socket.Opt] |
|
open_file [Writer] |
open_file ?append file opens file for writing and returns a writer for it.
|
open_file [Reader] |
open_file file opens file for reading and returns a reader reading from it.
|
opendir [Unix_syscalls] |
|
openfile [Unix_syscalls] |
|
os_type [Async_sys] |
|
ounit_tests [Unix_syscalls] |
|
ounit_tests [Syscall] |
|
ounit_tests [Writer] |
|
ounit_tests [Work_group] |
|
ounit_tests [Thread_safe] |
|
ounit_tests [Std] |
|
ounit_tests [Signal_manager] |
|
ounit_tests [Signal] |
|
ounit_tests [Shutdown] |
|
ounit_tests [Select_file_descr_watcher] |
|
ounit_tests [Scheduler] |
|
ounit_tests [Read_write] |
|
ounit_tests [Reader] |
|
ounit_tests [Raw_signal_manager] |
|
ounit_tests [Raw_scheduler] |
|
ounit_tests [Raw_fd] |
|
ounit_tests [Io_stats] |
|
ounit_tests [In_thread] |
|
ounit_tests [Interruptor] |
|
ounit_tests [Inline_tests] |
|
ounit_tests [Import] |
|
ounit_tests [File_descr_watcher_intf] |
|
ounit_tests [Fd_by_descr] |
|
ounit_tests [Fd] |
|
ounit_tests [Epoll_file_descr_watcher] |
|
ounit_tests [Async_sys] |
|
ounit_tests [Async_print] |
|
ounit_tests [Async_gc] |
|
P |
passwd [Unix_syscalls.Group.Fields] |
|
passwd [Unix_syscalls.Group] |
|
passwd [Unix_syscalls.Passwd.Fields] |
|
passwd [Unix_syscalls.Passwd] |
|
perm [Unix_syscalls.Stats.Fields] |
|
perm [Unix_syscalls.Stats] |
|
pipe [Unix_syscalls] |
The info supplied to pipe is debugging information that will be included in the
returned Fd s.
|
pipe [Writer] |
pipe t returns the writing end of a pipe attached to t that pushes back when t
cannot keep up with the data being pushed in.
|
pipe [Thread_safe] |
pipe () returns (reader, write, close) , where reader receives all of the values
supplied to write and is closed when close is called.
|
pipe [Reader] |
pipe t returns the reader end of a pipe that will continually be filled with chunks
of data from the underlying Reader.t.
|
pipe_of_squeue [In_thread] |
pipe_of_squeue squeue returns a pipe p and consumes the contents squeue , placing
them in p .
|
port [Unix_syscalls.Socket.Address.Inet] |
|
post_check [File_descr_watcher_intf.S] |
post_check t check_result returns the file descriptors available for read and
write.
|
pre_check [File_descr_watcher_intf.S] |
|
prerr_char [Async_print] |
|
prerr_endline [Async_print] |
|
prerr_float [Async_print] |
|
prerr_int [Async_print] |
|
prerr_newline [Async_print] |
|
prerr_string [Async_print] |
|
print_char [Async_print] |
|
print_endline [Async_print] |
|
print_float [Async_print] |
|
print_int [Async_print] |
|
print_newline [Async_print] |
|
print_string [Async_print] |
|
printf [Async_print] |
|
putenv [Unix_syscalls] |
|
R |
rcvbuf [Unix_syscalls.Socket.Opt] |
|
rcvlowat [Unix_syscalls.Socket.Opt] |
|
rcvtimeo [Unix_syscalls.Socket.Opt] |
|
rdev [Unix_syscalls.Stats.Fields] |
|
rdev [Unix_syscalls.Stats] |
|
read [Reader] |
read t ?pos ?len buf reads up to len bytes into buf, blocking
until some data is available or end-of-input is reached.
|
read_all [Reader] |
read_all t read_one returns a pipe that receives all values read from t by
repeatedly using read_one t .
|
read_bigsubstring [Reader] |
|
read_bin_prot [Reader] |
read_bin_prot ?max_len t bp_reader reads the next binary protocol message using
binary protocol reader bp_reader .
|
read_char [Reader] |
|
read_fd [Interruptor] |
|
read_line [Reader] |
read_line t reads up to, and including the next newline (\n) character and returns a
freshly-allocated string containing everything up to but not including the newline
character.
|
read_marshal [Reader] |
Like read_marshal_raw, but unmarshal the value after reading it
|
read_marshal_raw [Reader] |
Read and return a buffer containing one marshaled value, but don't unmarshal it.
|
read_one_chunk_at_a_time_until_eof [Reader] |
read_one_chunk_at_a_time_until_eof t ~handle_chunk reads into t 's internal
buffer, and whenever bytes are available, applies handle_chunk to them.
|
read_sexp [Reader] |
read_sexp t reads the next sexp.
|
read_sexps [Reader] |
read_sexps t reads all the sexps and returns them as a pipe.
|
read_substring [Reader] |
read_substring t ss reads up to Substring.length ss bytes into ss ,
blocking until some data is available or Eof is reched.
|
read_until [Reader] |
read_until t pred ~keep_delim reads until it hits a delimiter c such that:
|
read_until_max [Reader] |
just like read_until , except you have the option of specifiying a maximum number of
chars to read.
|
readdir [Unix_syscalls] |
|
readdir [Async_sys] |
|
readlink [Unix_syscalls] |
|
ready_to [Fd] |
ready_to t read_write is like ready_to_interruptible , but without the possibility
of interruption.
|
ready_to_interruptible [Fd] |
ready_to_interruptible t read_write ~interrupt returns a deferred that will become
determined when the file descriptor underlying t can be read from or written to
without blocking, or when interrupt becomes determined.
|
really_read [Reader] |
really_read t buf ?pos ?len reads until it fills len bytes of buf
starting at pos or runs out of input.
|
really_read_bigsubstring [Reader] |
|
really_read_line [Reader] |
really_read_line ~wait_time t reads up to, and including the next
newline (\n) character and returns an optional, freshly-allocated string
containing everything up to but not including the newline character.
|
really_read_substring [Reader] |
|
recv [Reader] |
recv t returns a string that was written with Writer.send
|
remove [Raw_signal_manager.Handlers] |
|
remove [Fd_by_descr] |
|
remove [Async_sys] |
|
remove_fd [Raw_scheduler] |
|
remove_handler [Signal_manager] |
remove_handler handler causes the particular handler to no longer handle the
signals it was registered to handle.
|
remove_handler [Raw_signal_manager] |
|
rename [Unix_syscalls] |
|
rename [Async_sys] |
|
replace [Read_write] |
|
replace [Fd] |
replace t kind is for internal use only, by Unix_syscalls .
|
replace_all [Read_write] |
|
report_long_cycle_times [Scheduler] |
report_long_cycle_times ?cutoff () sets up something that will print a warning to
stderr whenever there is an async cycle that is too long, as specified by cutoff ,
whose default is 1s.
|
report_long_cycle_times [Raw_scheduler] |
|
request_start_watching [Raw_scheduler] |
|
request_stop_watching [Raw_scheduler] |
|
reset_in_forked_process [Scheduler] |
If a process that has already created, but not started, the async scheduler would like
to fork, and would like the child to have a clean async, i.e.
|
reset_in_forked_process [Raw_scheduler] |
|
reuseaddr [Unix_syscalls.Socket.Opt] |
|
rewinddir [Unix_syscalls] |
|
rmdir [Unix_syscalls] |
|
run [In_thread] |
run ?thread ?name f runs f() in another thread and returns the result as a
Deferred in the Async world.
|
run [Inline_tests] |
|
run_in_async [Thread_safe] |
run_in_async f acquires the async lock and runs f () and an async cycle while
holding the lock.
|
run_in_async_exn [Thread_safe] |
|
run_in_async_wait [Thread_safe] |
run_in_async_wait f is like block_on_async f , except that it will raise an
exception if it is called from the main thread as well as from within async.
|
run_in_async_wait_exn [Thread_safe] |
|
run_in_async_with_optional_cycle [Thread_safe] |
run_in_async_with_optional_cycle f acquires the async lock and runs f () while
holding the lock.
|
S |
save [Writer] |
|
save_sexp [Writer] |
|
schedule [Std] |
|
schedule [Scheduler] |
Just like schedule', but doesn't require thunk to return a deferred.
|
schedule' [Std] |
|
schedule' [Scheduler] |
Just like within' , but instead of running thunk right now, adds
it to the async queue to be run with other async jobs.
|
schedule_bigstring [Writer] |
schedule_bigstring t bstr schedules a write of bigstring bstr .
|
schedule_iovec [Writer] |
schedule_iovec t iovec schedules a write of I/O-vector iovec .
|
schedule_iovecs [Writer] |
schedule_iovecs t iovecs like Writer.schedule_iovec , but takes a whole queue iovecs of
I/O-vectors as argument.
|
scheduler_thread_id [Raw_scheduler.Fields] |
|
scheduler_thread_id [Raw_scheduler] |
|
send [Writer] |
send t s writes a string to the channel that can be read back
using Reader.recv
|
set [Signal] |
|
set [Read_write] |
|
set [File_descr_watcher_intf.S] |
set alters the map of file descriptors being watched.
|
set_close_on_exec [Unix_syscalls] |
|
set_fd [Writer] |
set_fd t fd sets the fd used by t for its underlying system calls.
|
set_fd_desired_watching [Raw_scheduler] |
|
set_fds_whose_watching_has_changed [Raw_scheduler] |
|
set_have_set_nonblock [Raw_fd.T] |
|
set_info [Raw_fd.T] |
|
set_is_running [Raw_scheduler] |
|
set_kind [Raw_fd.T] |
|
set_max_num_jobs_per_priority_per_cycle [Scheduler] |
set_max_num_jobs_per_priority_per_cycle int sets the maximum number of jobs that
will be done at each priority within each async cycle.
|
set_max_num_jobs_per_priority_per_cycle [Raw_scheduler] |
|
set_nonblock_if_necessary [Raw_fd] |
|
set_num_active_syscalls [Raw_fd.T] |
|
set_raise_when_consumer_leaves [Writer] |
set_raise_when_consumer_leaves t bool sets the raise_when_consumer_leaves flag of
t , which determies how t responds to a write system call raising EPIPE and
ECONNRESET (see create ).
|
set_scheduler_thread_id [Raw_scheduler] |
|
set_state [Raw_fd.T] |
|
set_state [Raw_fd] |
|
set_watching_has_changed [Raw_fd.T] |
|
setopt [Unix_syscalls.Socket] |
|
setuid [Unix_syscalls] |
|
sexp_of_any [Read_write] |
|
sexp_of_buffer_age_limit [Writer] |
|
sexp_of_error [Unix_syscalls] |
|
sexp_of_ready_to_result [Raw_fd] |
|
sexp_of_t [Unix_syscalls.Group] |
|
sexp_of_t [Unix_syscalls.Passwd] |
|
sexp_of_t [Unix_syscalls.Inet_addr] |
|
sexp_of_t [Unix_syscalls.Stats] |
|
sexp_of_t [Writer] |
|
sexp_of_t [Unix_syscalls.Socket.Address.Inet] |
|
sexp_of_t [Unix_syscalls.Socket.Address.Unix] |
|
sexp_of_t [Unix_syscalls.Socket.Address] |
|
sexp_of_t [Unix_syscalls.Socket] |
|
sexp_of_t [Signal_manager] |
|
sexp_of_t [Read_write.Mutable] |
|
sexp_of_t [Read_write.Read_only] |
|
sexp_of_t [Read_write.Immutable] |
|
sexp_of_t [Read_write.Key] |
|
sexp_of_t [Read_write] |
|
sexp_of_t [Reader.Read_result] |
|
sexp_of_t [Reader] |
|
sexp_of_t [Raw_signal_manager.Handlers] |
|
sexp_of_t [Raw_signal_manager] |
|
sexp_of_t [Raw_scheduler] |
|
sexp_of_t [Raw_fd.T] |
|
sexp_of_t [Raw_fd.Watching] |
|
sexp_of_t [Raw_fd.State] |
|
sexp_of_t [Raw_fd.Kind] |
|
sexp_of_t [Io_stats] |
|
sexp_of_t [Interruptor] |
|
sexp_of_t [File_descr_watcher_intf.S.Check_result] |
|
sexp_of_t [File_descr_watcher_intf.S.Pre] |
|
sexp_of_t [File_descr_watcher_intf.S] |
|
sexp_of_t [File_descr_watcher_intf.Post] |
|
sexp_of_t [Fd_by_descr] |
|
sexp_of_t [Fd] |
|
sexp_of_wait_on [Unix_syscalls] |
|
shell [Unix_syscalls.Passwd.Fields] |
|
shell [Unix_syscalls.Passwd] |
|
shutdown [Unix_syscalls.Socket] |
|
shutdown [Std] |
|
shutdown [Shutdown] |
shutdown ?force status initiates shutdown, which runs all the at_shutdown
functions, waits for them to finish, and then exits with the supplied status.
|
shutdown_and_raise [Shutdown] |
shutdown_and_raise ?force status initiates shutdown and immediately raises.
|
shutting_down [Shutdown] |
shutting_down () reports whether we are currently shutting down, and if so, with
what status.
|
signal [Signal] |
|
signal_manager [Raw_scheduler.Fields] |
|
signal_manager [Raw_scheduler] |
|
size [Unix_syscalls.Stats.Fields] |
|
size [Unix_syscalls.Stats] |
|
sndbuf [Unix_syscalls.Socket.Opt] |
|
sndlowat [Unix_syscalls.Socket.Opt] |
|
sndtimeo [Unix_syscalls.Socket.Opt] |
|
socketpair [Unix_syscalls] |
|
standard [Signal] |
standard is a list of signals that are reasonable to supply as arguments to deliver:
|
stat [Unix_syscalls] |
|
state [Raw_fd.T.Fields] |
|
state [Raw_fd.T] |
|
stderr [Writer] |
|
stderr [Fd] |
|
stdin [Reader] |
stdin is a reader for file descriptor 0.
|
stdin [Fd] |
stdin , stdout , and stderr are wrappers around the standard Unix file
descriptors.
|
stdout [Writer] |
stdout and stderr are writers for file descriptors 1 and 2.
|
stdout [Fd] |
|
supports_nonblock [Raw_fd.T.Fields] |
|
supports_nonblock [Raw_fd.T] |
|
supports_nonblock [Fd] |
supports_nonblock t returns true if t supports nonblocking system calls.
|
symlink [Unix_syscalls] |
|
sync [Unix_syscalls] |
|
sync_changed_fds_to_file_descr_watcher [Raw_scheduler] |
|
syscall [Syscall] |
|
syscall [Raw_fd] |
|
syscall [In_thread] |
syscall f runs f, which should be a single system call, and returns the result,
handling the restarting of interrupted system calls.
|
syscall [Fd] |
syscall t f runs Async_unix.syscall with f on the file descriptor underlying
t , if is_open t , and returns `Ok or `Error according to f .
|
syscall_exn [Raw_fd] |
|
syscall_exn [In_thread] |
|
syscall_exn [Fd] |
syscall_exn t f is like syscall , except it raises rather than return
`Already_closed or `Error .
|
syscall_in_thread [Fd] |
syscall_in_thread t f runs In_thread.syscall with f on the file descriptor
underlying t , if is_open t , and returns a deferred that becomes determined with
`Ok or `Error when the system call completes.
|
syscall_in_thread_exn [Fd] |
syscall_in_thread_exn is like syscall_in_thread , except it raises rather than
return `Already_closed or `Error .
|
system [Unix_syscalls] |
|
system_exn [Unix_syscalls] |
|
T |
t_of_sexp [Unix_syscalls.Group] |
|
t_of_sexp [Unix_syscalls.Passwd] |
|
t_of_sexp [Unix_syscalls.Inet_addr] |
|
t_of_sexp [Unix_syscalls.Stats] |
|
t_of_sexp [Unix_syscalls.Socket.Address.Inet] |
|
t_of_sexp [Unix_syscalls.Socket.Address.Unix] |
|
t_of_sexp [Unix_syscalls.Socket.Address] |
|
t_of_sexp [Read_write.Mutable] |
|
t_of_sexp [Read_write.Read_only] |
|
t_of_sexp [Read_write.Immutable] |
|
t_of_sexp [Read_write.Key] |
|
t_of_sexp [Read_write] |
|
t_of_sexp [Reader.Read_result] |
|
t_of_sexp [Io_stats] |
|
t_of_sexp__ [Unix_syscalls.Socket.Address.Inet] |
|
t_of_sexp__ [Unix_syscalls.Socket.Address.Unix] |
|
t_of_sexp__ [Unix_syscalls.Socket.Address] |
|
t_of_sexp__ [Read_write.Key] |
|
t_of_sexp__ [Reader.Read_result] |
|
tcgetattr [Unix_syscalls.Terminal_io] |
|
tcp [Unix_syscalls.Socket.Type] |
|
tcsetattr [Unix_syscalls.Terminal_io] |
|
test_lockf [Unix_syscalls] |
lockf_is_locked fd ?len checks the lock on section of the open file fd specified
by the current file position and len (see man lockf).
|
tests [Inline_tests] |
|
the_one_and_only [Raw_scheduler] |
|
the_one_and_only_ref [Raw_scheduler] |
|
the_one_and_only_uncommon_case [Raw_scheduler] |
|
this_process_became_child_of_init [Unix_syscalls] |
this_process_became_child_of_init returns a deferred that becomes determined when
the current process becomes a child of init(8).
|
thread_pool [Raw_scheduler.Fields] |
|
thread_pool [Raw_scheduler] |
|
thread_safe_check [File_descr_watcher_intf.S] |
|
thread_safe_interrupt [Interruptor] |
thread_safe_interrupt t causes read_fd t to become ready for reading.
|
thread_safe_wakeup_scheduler [Raw_scheduler] |
|
time [Unix_syscalls] |
|
times [Unix_syscalls] |
|
to_formatter [Writer] |
to_formatter t
|
to_int [Raw_fd] |
|
to_int_exn [Fd] |
to_int_exn t returns the the underlying file descriptor as an int.
|
to_list [Unix_syscalls.Group.Fields] |
|
to_list [Unix_syscalls.Passwd.Fields] |
|
to_list [Unix_syscalls.Stats.Fields] |
|
to_list [Raw_scheduler.Fields] |
|
to_list [Raw_fd.T.Fields] |
|
to_sockaddr [Unix_syscalls.Socket.Address] |
|
to_string [Unix_syscalls.Inet_addr] |
|
to_string [Unix_syscalls.Stats] |
|
to_string [Unix_syscalls.Socket.Opt] |
|
to_string [Unix_syscalls.Socket.Family] |
|
to_string [Unix_syscalls.Socket.Address.Inet] |
|
to_string [Unix_syscalls.Socket.Address.Unix] |
|
to_string [Unix_syscalls.Socket.Address] |
|
to_string [Fd] |
to_string t returns a pretty sexp of the representation of t
|
total [Io_stats] |
|
transfer [Writer] |
transfer t pipe_r f repeatedly pulls values from pipe_r , and feeds them to f ,
which should in turn write them to t .
|
transfer [Reader] |
transfer t pipe_w transfers data from t into pipe_w one chunk at a time
(whatever is read from the underlying file descriptor without post-processing).
|
transition_is_allowed [Raw_fd.State] |
|
truncate [Unix_syscalls] |
|
try_lock [Raw_scheduler] |
|
try_lockf [Unix_syscalls] |
try_lockf fd read_or_write ?len attempts to exclusively lock for reading/writing the
section of the open file fd specified by the current file position and len (see
man lockf).
|
typ [Unix_syscalls.Socket.Opt] |
|
U |
udp [Unix_syscalls.Socket.Type] |
|
uid [Unix_syscalls.Passwd.Fields] |
|
uid [Unix_syscalls.Passwd] |
|
uid [Unix_syscalls.Stats.Fields] |
|
uid [Unix_syscalls.Stats] |
|
unix [Unix_syscalls.Socket.Type] |
|
unix [Unix_syscalls.Socket.Family] |
|
unlink [Unix_syscalls] |
|
unlock [Raw_scheduler] |
|
unlockf [Unix_syscalls] |
unlockf fd ?len unlocks the section of the open file fd specified by the current
file position and len (see man lockf).
|
update [Io_stats] |
|
utimes [Unix_syscalls] |
|
W |
wait [Unix_syscalls] |
|
wait_nohang [Unix_syscalls] |
|
wait_nohang_untraced [Unix_syscalls] |
|
wait_on_of_sexp [Unix_syscalls] |
|
wait_on_of_sexp__ [Unix_syscalls] |
|
wait_untraced [Unix_syscalls] |
|
waitpid [Unix_syscalls] |
waitpid pid returns a deferred that becomes determined with the child's exit
status, when the child process with process id pid exits.
|
waitpid_exn [Unix_syscalls] |
|
watching [Raw_fd.T.Fields] |
|
watching [Raw_fd.T] |
|
watching_has_changed [Raw_fd.T.Fields] |
|
watching_has_changed [Raw_fd.T] |
|
when_file_exists [Async_sys] |
when_file_exists ?poll_delay file returns a deferred that becomes determined when
file exists.
|
with_close [Reader] |
|
with_close [Fd] |
with_close t f applies f to t , returns the result of f , and closes t .
|
with_execution_context [Raw_scheduler] |
|
with_file [Unix_syscalls] |
with_file file ~mode ~perm ~f ?exclusive opens file , and applies f to the
resulting file descriptor.
|
with_file [Writer] |
with_file ~file f opens file for writing, creates a writer t , and runs f t to
obtain a deferred d .
|
with_file [Reader] |
with_file file f opens files , creates a reader with it, and passes the reader to
f .
|
with_file_atomic [Writer] |
|
with_file_descr [Raw_fd] |
|
with_file_descr [Fd] |
with_file_descr t f runs f on the file descriptor underlying t , if is_open t ,
and returns `Ok or `Error according to f .
|
with_file_descr_deferred [Fd] |
with_file_descr_deferred t f runs f on the file descriptor underlying t , if
is_open t , and returns `Ok or `Error according to f .
|
with_file_descr_exn [Raw_fd] |
|
with_file_descr_exn [Fd] |
with_file_descr_exn is like with_file_descr except that it raises rather than
return `Already_closed or `Error .
|
with_lock [Raw_scheduler] |
|
within [Std] |
|
within [Scheduler] |
within is like within' , but doesn't require thunk to return a deferred.
|
within' [Std] |
|
within' [Scheduler] |
within' f ~work_group ~monitor ~priority runs f () right now, with the specified
block group, monitor, and priority set as specified.
|
within_context [Scheduler] |
within_context context f runs f () right now with the specified execution
context.
|
within_v [Scheduler] |
within_v is like within , but allows a value to be returned by f .
|
word_size [Async_sys] |
|
wordexp [Unix_syscalls] |
|
write [Writer] |
write ?pos ?len t s adds a job to the writer's queue of pending writes.
|
write_bigstring [Writer] |
|
write_bigsubstring [Writer] |
|
write_bin_prot [Writer] |
write_bin_prot writes out a value using its bin_prot sizer/writer pair.
|
write_byte [Writer] |
write_byte t i writes one 8-bit integer (as the single character with that code).
|
write_char [Writer] |
write_char t c writes the character
|
write_marshal [Writer] |
Serialize data using marshal and write it to the writer
|
write_sexp [Writer] |
|
write_substring [Writer] |
|
writef [Writer] |
|