Index of values

add_exn t fd fails if the file descriptor for fd is already in t.

add_finalizer f x is like Gc.finalise f x, except that the finalizer is guaranteed to run as an Async job (i.e.

am_holding_async_lock () returns true if the currently running thread is holding the async lock.

at_shutdown f causes f () to be run when shutdown is called, and for shutdown to wait until the returned deferred finishes.

block_on_async f runs f () in the async world and blocks until the result becomes determined.

bytes_to_write t returns how many bytes have been requested to write but have not yet been written.

bytes_written t returns how many bytes have been written.

clear t causes read_fd t to become not ready for reading.

close fd closes the file descriptor fd, and raises an exception if fd has already been closed.

close ?force_close t waits for the writer to be flushed, and then calls Unix.close on the underlying file descriptor.

close t prevents further use of t and closes t's underlying file descriptor.

close t prevents further use of t, and closes the underlying file descriptor once all the current uses are finished.

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 t returns the string corresponding to the full contents (up to EOF) of the reader.

cores () Returns the number of cores

create ?buf_len ?syscall ?buffer_age_limit fd creates a new writer.

create creates and returns a signal manager t.

create ~buf_len fd creates a new reader that is reading from fd.

create ~num_file_descrs creates a new file-descr-watcher that is able to watch file descriptors in

 [0, num_file_descrs) 

.

create kind file_descr creates a new t of the underlying kind and file descriptor.

cycle_count () returns the total number of async cycles that have happened.

cycle_start () returns the result of Time.now () called at the beginning of cycle.

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).

deferred () returns (d, fill) where d is a deferred that will become determined with value v once fill v is called.

fd t

fd t

file_contents file returns the string with the full contents of the file

file_descr_exn t returns the file descriptor underlying t, unless is_closed t, in which case it raises.

finalise is rebound to avoid accidental use in Async programs.

flushed t returns a deferred that will become determined when all prior writes complete (i.e.

fork_exec ~prog ~args ?path ?env forks and execs prog with args, and returns the child pid.

Return the login name of the user executing the process.

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_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.

handle ?stop signals ~f arranges so that whenever a signal in signals is delivered, f is called on that signal.

We override values from Core.Signal that we don't want people to use with Async.

handle_delivered t runs all signal handlers on the signals that have been delivered but not yet handled.

id t

id t

invariant t raises an exception if the writer is in a bad state

io_stats Overall IO statistics for all writers

io_stats Overall IO statistics for all readers

is_managed_by_async signal returns true iff signal is being managed by async, and hence its default behavior is no longer in effect.

is_managing t signal returns true iff manage t signal has been called

is_open t is not (is_closed t)

is_running () returns true if the scheduler has been started.

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.

kind t returns the kind of file descriptor that t is.

last_read_time t returns time of the most recent read system call that returned data.

lines t reads all the lines from t and puts them in the pipe, one line per pipe element.

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_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.

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).

manage t signal causes t to manage signal, thus overriding default_sys_behavior for that signal, and any other OCaml handler for that signal.

monitor t returns the writer's monitor.

of_in_channel and of_out_channel create an fd from their underlying file descriptor.

of_in_channel_auto ic is just like of_in_channel, but uses fstat to determine the kind.

of_out_channel_auto ic is just like of_out_channel, but uses fstat to determine the kind.

of_string_or_getbyname hostname does a DNS lookup of hostname and returns the resulting IP address.

open_file ?append file opens file for writing and returns a writer for it.

open_file file opens file for reading and returns a reader reading from it.

The info supplied to pipe is debugging information that will be included in the returned Fds.

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 () returns (reader, write, close), where reader receives all of the values supplied to write and is closed when close is called.

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 squeue returns a pipe p and consumes the contents squeue, placing them in p.

post_check t check_result returns the file descriptors available for read and write.

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 t read_one returns a pipe that receives all values read from t by repeatedly using read_one t.

read_bin_prot ?max_len t bp_reader reads the next binary protocol message using binary protocol reader bp_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.

Like read_marshal_raw, but unmarshal the value after reading it

Read and return a buffer containing one marshaled value, but don't unmarshal it.

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 t reads the next sexp.

read_sexps t reads all the sexps and returns them as a pipe.

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 t pred ~keep_delim reads until it hits a delimiter c such that:

just like read_until, except you have the option of specifiying a maximum number of chars to read.

ready_to t read_write is like ready_to_interruptible, but without the possibility of interruption.

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 t buf ?pos ?len reads until it fills len bytes of buf starting at pos or runs out of input.

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.

recv t returns a string that was written with Writer.send

remove_handler handler causes the particular handler to no longer handle the signals it was registered to handle.

replace t kind is for internal use only, by Unix_syscalls.

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.

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.

run ?priority ?thread ?name f runs f() in another thread and returns the result as a Deferred in the Async world.

run_in_async f acquires the async lock and runs f () and an async cycle while holding the lock.

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_with_optional_cycle f acquires the async lock and runs f () while holding the lock.

Just like schedule', but doesn't require thunk to return a deferred.

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 t bstr schedules a write of bigstring bstr.

schedule_iovec t iovec schedules a write of I/O-vector iovec.

schedule_iovecs t iovecs like Writer.schedule_iovec, but takes a whole queue iovecs of I/O-vectors as argument.

send t s writes a string to the channel that can be read back using Reader.recv

set alters the map of file descriptors being watched.

set_fd t fd sets the fd used by t for its underlying system calls.

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_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).

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 ?force status initiates shutdown and immediately raises.

shutting_down () reports whether we are currently shutting down, and if so, with what status.

stdin is a reader for file descriptor 0.

stdin, stdout, and stderr are wrappers around the standard Unix file descriptors.

stdout and stderr are writers for file descriptors 1 and 2.

supports_nonblock t returns true if t supports nonblocking system calls.

syscall f runs f, which should be a single system call, and returns the result, handling the restarting of interrupted system calls.

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 t f is like syscall, except it raises rather than return `Already_closed or `Error.

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 is like syscall_in_thread, except it raises rather than return `Already_closed or `Error.

terminating is a list of signals that can be supplied to handle and whose default behavior is to terminate the program: alrm hup int term usr1 usr2.

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).

this_process_became_child_of_init returns a deferred that becomes determined when the current process becomes a child of init(8).

thread_safe_interrupt t causes read_fd t to become ready for reading.

to_formatter t

to_int_exn t returns the the underlying file descriptor as an int.

to_string t returns a pretty sexp of the representation of t

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 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).

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).

unlockf fd ?len unlocks the section of the open file fd specified by the current file position and len (see man lockf).

waitpid pid returns a deferred that becomes determined with the child's exit status, when the child process with process id pid exits.

when_file_exists ?poll_delay file returns a deferred that becomes determined when file exists.

with_close t f applies f to t, returns the result of f, and closes t.

with_file file ~mode ~perm ~f ?exclusive opens file, and applies f to the resulting file descriptor.

with_file ~file f opens file for writing, creates a writer t, and runs f t to obtain a deferred d.

with_file file f opens files, creates a reader with it, and passes the reader to f.

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 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 is like with_file_descr except that it raises rather than return `Already_closed or `Error.

within is like within', but doesn't require thunk to return a deferred.

within' f ~work_group ~monitor ~priority runs f () right now, with the specified block group, monitor, and priority set as specified.

within_context context f runs f () right now with the specified execution context.

within_v is like within, but allows a value to be returned by f.

write ?pos ?len t s adds a job to the writer's queue of pending writes.

write_bin_prot writes out a value using its bin_prot sizer/writer pair.

write_byte t i writes one 8-bit integer (as the single character with that code).

write_char t c writes the character

Serialize data using marshal and write it to the writer