Index of values

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.

attach_pipe t pipe_r f repeatedly pulls values from pipe_r, and feeds them to f, which should in turn write them to t.

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 closes the underlying file descriptor of the reader.

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

close_finished t becomes determined after the close() system call on t's underlying file descriptor has finished.

close_was_started t returns true if the closing process for the Reader has been started (it may not yet be closed, however).

closed t returns a deferred that is filled in when the reader is closed by a call to close.

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 since Scheduler.go was called

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.

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.

got_epipe t returns a deferred that becomes determined when t attempts to write to a broken pipe.

handle ?stop signals ~f runs f on each signal in signals that is delivered, stopping when stop becomes determined.

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

handle_signal t signal causes t to manage handling of signal, so that it will record all future deliveries of that signal.

id t

id t

io_stats Overall IO statistics for all writers

io_stats Overall IO statistics for all readers

is_closed t returns true if close t has been called.

is_open t is not (is_closed t)

is_running () returns true if Scheduler.go has been called.

iter t ~f iterates over all the file descriptors being watched by t, supplying them to f along with their state and whether they are read/write.

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

monitor t returns the writer's monitor.

num_pending_jobs () returns the number of jobs that are scheduled that haven't yet been run.

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.

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.

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: in case pred = `Char c', c = c', in case pred = `Pred p, p c = true `Char c' is equivalent to `Pred (fun c -> c = c') but the underlying implementation is more efficient, in particular it will not call a function on every input character. read_until returns a freshly-allocated string consisting of all the characters read and optionally including the delimiter as per keep_delim.

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 select indicates that 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.

request_start_watching t file_descr a watching read_or_write requests that t start watching file_descr to see if it is available for reading or writing, depending on the value of read_or_write.

request_stop_watching t file_descr read_or_write requests that t stop watching file_descr for reading or writing, according to read_or_write.

run ?thread ?name_first16 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.

save ?temp_prefix ?perm ?fsync file ~contents atomically replaces contents of file with contents.

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_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_epipe t bool sets the raise_epipe flag of t, which determies how t responds to a write system call raising EPIPE (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.

standard is a list of signals that are reasonable to supply as arguments to deliver:

state t file_descr read_or_write returns Some state with the state of file_descr if it is monitored by t, or None if not.

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.

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

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 ~block_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