Index of modules


A
Address [Unix_syscalls.Socket]
Async_print
Non-blocking, Async-friendly print functions
Async_sys
This module overrides everything in the Sys module that might block.

C
Check_result [File_descr_watcher_intf.S]
thread_safe_check t pre ~timeout checks the file descriptors for their status and returns when at least one is available, or the timeout passes.
Config [Import]
Core_scheduler [Raw_scheduler]

D
Debug [Import]
Direct [Unix_syscalls.Group.Fields]
Direct [Unix_syscalls.Passwd.Fields]
Direct [Unix_syscalls.Stats.Fields]
Direct [Raw_scheduler.Fields]
Direct [Raw_fd.T.Fields]

E
Epoll_file_descr_watcher
Returns the underlying epoll value.
Exit [Unix_syscalls]
Exit_or_signal [Unix_syscalls]
Exit_or_signal_or_stop [Unix_syscalls]
Export [Read_write]

F
Family [Unix_syscalls.Socket]
Fd [Std.Unix]
Fd [Std]
Fd [Raw_scheduler]
Fd
An Fd.t is a wrapper around a Unix file descriptor, with additional information about the kind of file descriptor and logic to ensure that we don't use a file descriptor that has been closed, or close a file descriptor that is in use.
Fd_by_descr
Fd_by_descr is a table of the open Fd.ts, indexed by file descriptor number.
Fields [Unix_syscalls.Group]
Fields [Unix_syscalls.Passwd]
Fields [Unix_syscalls.Stats]
Fields [Raw_scheduler]
Fields [Raw_fd.T]
File_descr [Raw_fd]
File_descr [Import]
File_descr_watcher [Raw_scheduler]
File_descr_watcher_intf
File_descr_watcher_intf.S provides an API for for watching a set of file descriptors to see if they are ready for reading or writing.
File_kind [Unix_syscalls]

G
Group [Unix_syscalls]
Structure of entries in the groups database.

H
Handler [Raw_signal_manager]
Handlers [Raw_signal_manager]
Helper_thread [Thread_pool]
Helper_thread [In_thread]
Host [Unix_syscalls]

I
Id [Writer]
Id [Reader]
Immutable [Read_write]
Import
In_thread [Std]
In_thread
The In_thread module has functions for interaction between the Async world and other (kernel) threads.
Inet [Unix_syscalls.Socket.Address]
Inet_addr [Unix_syscalls]
Interruptor
An interruptor provides a file descriptor that can be used to cause a file-descr-watcher to detect the file descriptor is ready for reading.
Io_stats [Std]
Io_stats

K
Key [Read_write]
Kind [Raw_fd]
Kind [Fd]

M
Mutable [Read_write]

O
Open_flags [Unix_syscalls]
Opt [Unix_syscalls.Socket]
Output [Process]
wait t closes stdin t and then begins collecting the output produced on t's stdout and stderr, continuing to collect output until t terminates.

P
Passwd [Unix_syscalls]
Structure of entries in the passwd database.
Post [File_descr_watcher_intf]
Pre [File_descr_watcher_intf.S]
pre_check t does whatever non-thread-safe work is necessary to prepare for the system call that checks file descriptors being ready for read or write.
Print [Std]
Priority [Thread_pool]
Priority [In_thread]
Process [Std]
Process
Async.Process is for creating child processes of the current process, and communicating with children via their stdin, stdout, and stderr.
Protocol_family [Unix_syscalls]

R
Raw_fd
Raw_scheduler
Raw_signal_manager
Read_only [Read_write]
Read_result [Reader]
Read_write
Read_write is like Dirpair, except "buy/sell" has been changed to "read/write".
Reader [Std]
Reader
Reader is Async's main API for buffered input from a file descriptor.

S
Scheduler [Std]
Scheduler
Threading model:
Select_file_descr_watcher
Shutdown [Std]
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.
Signal [Std]
Signal
We override values from Core.Std.Signal that we don't want people to use with Async.
Signal [Raw_signal_manager]
Signal [Raw_scheduler]
Signal_manager
A signal manager keeps track of a set of signals to be managed and the signal handlers for them.
Socket [Unix_syscalls]
Socket [Std]
State [Raw_fd]
Stats [Unix_syscalls]
Std
Sys [Std]
Syscall

T
T [Raw_fd]
Terminal_io [Unix_syscalls]
Thread_pool
A thread pool is a set of OCaml threads used to do work, where each piece of work is simply a thunk.
Thread_safe
The Thread_safe module has functions that are safe to call from threads outside async.
Thread_safe [Std]
Thread_safe_pipe
A thread-safe pipe is a thread-safe interface to the write end of a normal Async.Pipe.
Thread_safe_pipe [Std]
Timeout [File_descr_watcher_intf]
Timerfd [Raw_scheduler]
Type [Unix_syscalls.Socket]

U
Unix [Std]
Unix [Unix_syscalls.Socket.Address]
Unix_syscalls
Unix_syscalls provides an interface to many of the functions in OCaml's standard Unix module.

W
Watching [Raw_scheduler]
Watching [Raw_fd]
Writer
Writer is Async's main API for output to a file descriptor.
Writer [Std]