Index of values

p1 <&> p2 is the same as Lwt.join[p1; p2].

p1 <?> p2 is the same as Lwt.choose[p1; p2].

p >|= f is the same as Lwt.mapf p.

abort ch abort current operations and close the channel immediately.

abort fd exn makes all current and further uses of the file descriptor fail with the given exception.

abort_jobs exn make all pending jobs to fail with exn.

Wrapper for Unix.accept

accept_n fd count accepts up to count connections at one time.

Wrapper for Unix.access

add e q evaluates to a new priority queue, which contains all the elements of q, and the additional element e.

add_hook switch f registers f so it will be called when Lwt_switch.turn_off is invoked.

add_hook_or_exec switch f is the same as Lwt_switch.add_hook except that if the switch is already off, f is called immediately.

add_l x s adds x to the left of the sequence s

add_l x s adds x to the right of the sequence s

Like Lwt.add_task_r, but the equivalent code calls Lwt_sequence.add_l instead.

Lwt.add_task_r sequence is equivalent to

append s1 s2 returns a stream which returns all elements of s1, then all elements of s2

append_bigarray vs buffer offset length appends a slice of the Bigarray buffer buffer beginning at offset and with length length to the I/O vector sequence vs.

append_bytes vs buffer offset length appends a slice of the bytes buffer buffer beginning at offset and with length length to the I/O vector sequence vs.

Lwt.async f applies f (), which returns a promise, and then makes it so that if the promise is rejected, the exception is passed to !Lwt.async_exception_hook.

Reference to a function, to be called on an "unhandled" exception.

async_method () returns the async method used in the current thread.

The key for storing the local async method.

at_exit hook adds hook at the left of exit_hooks

atomic f transforms a sequence of io operations into one single atomic io operation.

auto_yield timeout returns a function f that will yield every timeout seconds.

Binds an address to the given socket.

bind ?eq s f is initially f x where x is the current value of s.

Lwt.bind p_1 f makes it so that f will run when p_1 is fulfilled.

Old version of Lwt_unix.bind.

Since Lwt 3.0.0, this is just an alias for Lwt_unix.bind.

Same as Lwt_react.S.bind except that f returns a thread.

blit buf1 ofs1 buf2 ofs2 len copies len bytes from buf1 starting at offset ofs1 to buf2 starting at offset ofs2.

Same as Lwt_bytes.blit but the first buffer is a string instead of a byte array.

Same as Lwt_bytes.blit but the second buffer is a string instead of a byte array.

block ch size f pass to f the internal buffer and an offset.

blocking fd indicates whether Lwt is internally using blocking or non-blocking I/O with fd.

broadcast condvar value notifies all waiting threads.

broadcast_exn condvar exn fails all waiting threads with exception exn.

Returns the size of the internal buffer.

buffered oc returns the number of bytes in the buffer

The byte order used by the computer running the program.

Call the handler associated to the given notification.

Lwt.cancel p attempts to cancel the pending promise p, without needing access to its resolver.

cancel_jobs () is the same as abort_jobs Lwt.Canceled.

Lwt.catch f h applies f (), which returns a promise, and then makes it so that h (“handler”) will run when that promise is rejected.

catch x behaves like return y if x evaluates to y, and like fail e if x raises e

Changes the duration of the given timeout.

chars_of_file name returns a stream of all characters of the file with name name.

chars_to_file name chars writes all characters of chars to name

Wrapper for Unix.chdir

check switch does nothing if switch is None or contains an switch that is currently on, and raises Lwt_switch.Off otherwise.

check_descriptor fd raise an exception if fd is not in the state Open.

Wrapper for Unix.chmod

Lwt.choose ps is the same as Lwt.pickps, except that it does not try to cancel pending promises in ps.

choose l creates an stream from a list of streams.

Wrapper for Unix.chown

Wrapper for Unix.chroot

clear p will clear all elements in p, calling the dispose function associated with p on each of the cleared elements.

Wrapper for Unix.clear_close_on_exec

clone st clone the given stream.

close ch closes the given channel.

Close a file descriptor.

closed st returns a thread that will sleep until the stream has been closed.

Closes a directory handle.

combine s1 s2 combines two streams.

concat st returns the concatenation of all streams of st.

Wrapper for Unix.connect

copy buffer creates a copy of the given byte array.

Creates a new byte array of the given size.

Creates an empty I/O vector sequence.

Lwt_timeout.create n f creates a new timeout object with duration n seconds.

create () creates a new switch.

create () creates a new empty sequence

create n ?check ?validate ?dispose f creates a new pool with at most n elements.

create () creates a new condition variable.

create () creates a new mutex, which is initially unlocked

create v creates a new mailbox variable containing value v.

create () returns a new stream and a push function.

create_bounded size returns a new stream and a bounded push source.

create () creates a new empty mailbox variable.

create_with_reference () returns a new stream and a push function.

Returns the default async method.

Return the default size for buffers.

delay thread is an event which does not occurs until thread returns.

detach f x runs the computation f x in a separate preemptive thread.

direct_access ch f passes to f a Lwt_io.direct_access structure.

Stops receiving this signal

drop vs n adjusts the I/O vector sequence vs so that it no longer includes its first n bytes.

Wrapper for Unix.dup

Wrapper for Unix.dup2

The empty priority queue.

Functions that are called before the main iteration.

%! does nothing here.

Returns a promise that prints on the standard error.

%! does nothing here.

Like establish_server_with_client_address, but does not pass the client address or fd to the callback f.

Old version of Lwt_io.establish_server.

Since Lwt 3.0.0, this is just an alias for Lwt_io.establish_server.

Like Lwt_io.establish_server_with_client_socket, but passes two buffered channels to the connection handler f.

establish_server_with_client_socket listen_address f creates a server which listens for incoming connections on listen_address.

Executes the given command and returns its exit status.

Sets of functions executed just before the program exit.

extract buffer offset length creates a new byte array of length length and copy the length bytes of buffer at offset into it.

Lwt.fail exn is like Lwt.return, except the new promise that is already rejected with exn.

Lwt.invalid_arg s is an abbreviation for

Lwt.fail_with s is an abbreviation for

Event which does nothing when stopped.

Simulates activity on the given file descriptor.

Wrapper for Unix.fchmod

Wrapper for Unix.fchown

Synchronise all data (but not metadata) of the file descriptor with the disk.

file_exists name tests if a file named name exists.

file_exists name tests if a file named name exists.

Retrieves the length of the file at the given path.

files_of_directory dir returns the stream of all files of dir.

fill buffer offset length value puts value in all length bytes of buffer starting at offset offset.

filter_map f st filter and map st at the same time

filter f st keeps only values, x, such that f x is true

finalise f x ensures f x is evaluated after x has been garbage collected.

finalise_or_exit f x call f x when x is garbage collected or (exclusively) when the program exits.

Lwt.finalize f c applies f (), which returns a promise, and then makes it so c (“cleanup”) will run when that promise is resolved.

find_map f s find and map at the same time.

find_min q evaluates to the minimum element of q if it is not empty, and raises Not_found otherwise.

find_node_l f s returns the first node of s starting from the left that satisfies f or raises Not_found if none exists.

find_node_opt_l f s returns Some x, where x is the first node of s starting from the left that satisfies f or None if none exists.

find_node_opt_r f s returns Some x, where x is the first node of s starting from the right that satisfies f or None if none exists.

find_node_r f s returns the first node of s starting from the right that satisfies f or raises Not_found if none exists.

find f s find an element in a stream.

flatten st = map_list (fun l -> l) st

flush oc performs all pending writes on oc

flush fmt flushes the formatter (as with Format.pp_print_flush) and executes all the printing action on the underlying channel.

flush_all () flushes all open output channels

fold_l f s is:

fold_l f s x = f en (... (f e2 (f e1 x)))

where e1, e2, ..., en are the elements of s

fold_r f s is:

fold_r f s x = f e1 (f e2 (... (f en x)))

where e1, e2, ..., en are the elements of s

fold f s x fold_like function for streams.

fork () does the same as Unix.fork.

%! does nothing here.

%! does nothing here.

from f creates an event which occurs each time f () returns a value.

from f creates a stream from the given input function.

from_direct f does the same as Lwt_stream.from but with a function that does not return a thread.

Wrapper for Unix.LargeFile.fstat

Wrapper for Unix.fstat

Synchronise all data and metadata of the file descriptor with the disk.

Wrapper for Unix.LargeFile.ftruncate

Wrapper for Unix.ftruncate

get buffer offset returns the byte at offset offset in buffer.

get () returns the engine currently in use.

Returns the contents of a node

Retrieves the value currently associated with the given implicit callback argument key.

get st removes and returns the first element of the stream, if any.

get_affinity ?pid () returns the list of CPUs the process with pid pid is allowed to run on.

get_available st returns all available elements of l without blocking.

get_available_up_to n st returns up to n elements of l without blocking.

get_bounds () returns the minimum and the maximum number of preemptive threads.

get_cpu () returns the number of the CPU the current thread is running on.

get_credentials fd returns credentials information from the given socket.

get_exn is the opposite of Lwt_result.catch: it unwraps the result type, returning the value in case of success, calls Lwt.fail in case of error.

get_formatter fmt returns the underlying Format.formatter.

Returns the size of the waiting queue, if no more threads are available

get_while f st returns the longest prefix of st where all elements satisfy f.

Wrapper for Unix.getaddrinfo

Wrapper for Unix.getcwd

Wrapper for Unix.getgrgid

Wrapper for Unix.getgrnam

Wrapper for Unix.gethostbyaddr

Wrapper for Unix.gethostbyname

Wrapper for Unix.gethostname

Wrapper for Unix.getlogin

Wrapper for Unix.getnameinfo

Wrapper for Unix.getpeername

Wrapper for Unix.getprotobyname

Wrapper for Unix.getprotobynumber

Wrapper for Unix.getpwnam

Wrapper for Unix.getpwuid

Wrapper for Unix.getservbyname

Wrapper for Unix.getservbyport

Wrapper for Unix.getsockname

Wrapper for Unix.getsockopt

Wrapper for Unix.getsockopt_error

Wrapper for Unix.getsockopt_float

Wrapper for Unix.getsockopt_int

Wrapper for Unix.getsockopt_optint

Same as Unix.handle_unix_error but catches lwt-level exceptions

Test whether the given feature is available on the current system.

hexdump oc str = hexdump_stream oc (Lwt_stream.of_string str)

hexdump byte_stream returns a stream which is the same as the output of hexdump -C.

hexdump_stream oc byte_stream produces the same output as the command hexdump -C.

An obsolete variant of Lwt.async.

init min max log initialises this module.

input input mode representation

Creates an io-vector

is_busy channel returns whether the given channel is currently busy.

is_closed st returns whether the given stream has been closed.

is_empty vs is true if and only if vs has no I/O vectors, or all I/O vectors in vs have zero bytes.

Returns true iff the given sequence is empty

is_empty q evaluates to true iff q is empty.

is_empty mutex returns true if they are no thread waiting on the mutex, and false otherwise

is_empty mvar indicates if put mvar can be called without blocking.

is_empty st returns whether the given stream is empty.

locked mutex returns whether mutex is currently locked

is_on switch returns true if the switch is currently on, and false otherwise.

Lwt.is_sleeping p is equivalent to Lwt.statep = Lwt.Sleep.

Wrapper for Unix.isatty

iter block performs one iteration of the main loop.

iter_l f s applies f on all elements of s starting from the left

iter_n ?max_concurrency f s iterates over all elements of the stream s.

iter_l f s applies f on all nodes of s starting from the left

iter_l f s applies f on all nodes of s starting from the right

iter_l f s applies f on all elements of s starting from the right

iter f s iterates over all elements of the stream.

Lwt.join ps returns a promise that is pending until all promises in the list ps become resolved.

junk st removes the first element of st.

junk_old st removes all elements that are ready to be read without yielding from st.

junk_while f st removes all elements at the beginning of the streams which satisfy f.

keep s keeps a reference to s so it will never be garbage collected.

keep e keeps a reference to e so it will never be garbage collected.

last_new st returns the last element that can be obtained without sleeping, or wait for one if none is available.

Functions that are called after the main iteration.

Returns the length of the given byte array.

Returns the length of the channel in bytes

Returns the number of elemenets in the given sequence.

limit f s limits the rate of s update with f.

limit f e limits the rate of e with f.

lines_of_file name returns a stream of all lines of the file with name name.

lines_to_file name lines writes all lines of lines to file with name name.

Wrapper for Unix.link

Wrapper for Unix.listen

lock mutex lockcs the mutex, that is:

Wrapper for Unix.lockf

lookup_min q evaluates to Some e, where e is the minimum element of q, if q is not empty, and evaluates to None otherwise.

Wrapper for Unix.LargeFile.lseek

Wrapper for Unix.lseek

Wrapper for Unix.LargeFile.lstat

Wrapper for Unix.lstat

madvise buffer pos len advice advises the kernel how the program will use the memory mapped file between pos and pos + len.

make ?buffer ?close ~mode perform_io is the main function for creating new channels.

Lwt.make_error exn is equivalent to Error exn since OCaml 4.03.

make_formatter ~commit ~fmt creates a new lwt formatter based on the Format.formatter fmt.

new_notifier ?once f registers a new notifier.

make_stream () returns a formatter and a stream of all the writing order given on that stream.

Lwt.make_value v is equivalent to Ok v since OCaml 4.03.

Lwt.map f p_1 is similar to Lwt.bindp_1 f, but f is not expected to return a promise.

map_exn s returns a stream that captures all exceptions raised by the source of the stream (the function passed to Lwt_stream.from).

map_file ~fd ?pos ~shared ?size () maps the file descriptor fd to an array of bytes.

map_list f st applies f on each element of st and flattens the lists returned

map f st maps the value returned by st with f

mapped buffer returns true iff buffer is a memory mapped file.

mcast_add_membership fd ~ifname addr joins the multicast group addr on the network interface ifname.

mcast_drop_membership fd ~ifname addr leaves the multicast group addr on the network interface ifname.

Whether sent multicast messages are received by the sending host

Set TTL/hops value

mincore buffer offset states tests whether the given pages are in the system memory (the RAM).

Wrapper for Unix.mkdir

Wrapper for Unix.mkfifo

mode ch returns the mode of a channel

Lwt.nchoose ps is the same as Lwt.npickps, except that it does not try to cancel pending promises in ps.

Lwt.nchoose_split ps is the same as Lwt.nchooseps, except that when multiple promises in ps are fulfilled simultaneously (and none are rejected), the result promise is fulfilled with both the list of values of the fulfilled promises, and the list of promises that are still pending.

Creates a fresh implicit callback argument key.

next e returns the next occurrence of e

next st removes and returns the next element of the stream or fails with Lwt_stream.Empty, if the stream is empty.

nget n st removes and returns at most the first n elements of st.

njunk n st removes at most the first n elements of the stream.

Lwt.no_cancel p creates a non-cancelable promise p', with the same state as p.

npeek n st returns at most the first n elements of st, without removing them.

Lwt.npick ps is similar to Lwt.pickps, the difference being that when multiple promises in ps are fulfilled simultaneously (and none are rejected), the result promise is fulfilled with the list of values the promises were fulfilled with.

Output which drops everything

of_array a creates a stream returning all elements of a.

of_bytes buf returns a newly allocated byte array with the same contents as buf.

Create a channel from a byte array.

of_channel oc creates a formatter that writes to the channel oc.

of_fd ?buffer ?close ~mode fd creates a channel from a file descriptor.

of_list l creates a stream returning all elements of l.

Lwt.of_result r converts an r to a resolved promise.

of_stream stream creates an event which occurs each time a value is available on the stream.

of_string buf returns a newly allocated byte array with the same contents as buf.

of_string str creates a stream returning all characters of str.

of_unix_fd ?buffer ?close ~mode fd is a short-hand for:

Wraps a Unix file descriptor fd in an Lwt_unix.file_descr fd'.

Lwt.on_any p f g makes it so that:

Lwt.on_cancel p f makes it so that f will run when p becomes canceled.

Lwt.on_failure p f makes it so that f will run when p is rejected.

on_readable fd f calls f each time fd becomes readable.

on_signal signum f calls f each time the signal with numnber signum is received by the process.

on_signal_full f is the same as on_signal f except that f also receive the signal handler identifier as argument so it can disable it.

Lwt.on_success p f makes it so that f will run when p is fulfilled.

Same as Lwt_stream.on_termination.

Lwt.on_termination p f makes it so that f will run when p is resolved – that is, fulfilled or rejected.

on_termination st f executes f when the end of the stream st is reached.

on_timer delay repeat f calls f one time after delay seconds.

on_readable fd f calls f each time fd becomes writable.

open_connection ?fd ?in_buffer ?out_buffer addr opens a connection to the given address and returns two channels for using it.

Lwt_io.open_file ~mode file opens the given file, either for reading (with ~mode:Input) or for writing (with ~mode:Output).

open_temp_file () starts creating a new temporary file, and evaluates to a promise for the pair of the file's name, and an output channel for writing to the file.

Opens a directory for listing.

Wrapper for Unix.openfile.

output output mode representation

Size of pages.

parse st f parses st with f.

Lwt.pause () creates a pending promise that is fulfilled after Lwt finishes calling all currently ready callbacks, i.e.

peek st returns the first element of the stream, if any, without removing it.

Lwt.pick ps returns a promise that is pending until one promise in the list ps becomes resolved.

pipe ?in_buffer ?out_buffer () creates a pipe using Lwt_unix.pipe and makes two channels from the two returned file descriptors

pipe () creates pipe using Unix.pipe and returns two lwt file descriptors created from unix file_descriptor

pipe_in () is the same as Lwt_unix.pipe but maps only the unix file descriptor for reading into a lwt one.

pipe_out () is the inverse of Lwt_unix.pipe_in.

Maximum number of system threads that can be started.

position ch Returns the current position in the channel.

%! does nothing here.

Returns a promise that prints on the standard output.

%! does nothing here.

Lwt.protected p creates a cancelable promise p' with the same state as p.

proxy buffer offset length creates a ``proxy''.

put mvar value puts a value into a mailbox variable.

If ~count is specified, read ~count ic reads at most ~count characters from ic.

read fd buf ofs len reads up to len bytes from fd, and writes them to buf, starting at offset ofs.

read_char ic reads the next character of ic.

Same as Lwt_io.read_char, but does not raise End_of_file on end of input

read_chars ic returns a stream holding all characters of ic

Reads an IEEE single precision floating point value

Reads an IEEE double precision floating point value

Reads a 32-bits integer as an ocaml int

read_into ic buffer offset length reads up to length bytes, stores them in buffer at offset offset, and returns the number of bytes read.

read_into_exactly ic buffer offset length reads exactly length bytes and stores them in buffer at offset offset.

read_line ic reads one complete line from ic and returns it without the end of line.

Same as Lwt_io.read_line but do not raise End_of_file on end of input.

read_lines ic returns a stream holding all lines of ic

read_value channel reads a marshaled value from channel; it corresponds to the standard library's Marshal.from_channel.

Returns whether the given file descriptor is currently readable.

Returns the number of events waiting for a file descriptor to become readable.

Reads the next directory entry from the given directory.

readdir_n handle count reads at most count entries from the given directory.

Wrapper for Unix.readlink

readv fd vs reads bytes from fd into the buffer slices vs.

Not implemented on Windows.

Wrapper for Unix.recv.

Not implemented on Windows.

recv_msg ~socket ~io_vectors receives data into a list of io-vectors, plus any file-descriptors that may accompany the messages.

Not implemented on Windows.

Wrapper for Unix.recvfrom.

register_action set fd action registers action on fd.

reinstall_signal_handler signum if any signal handler is registered for this signal with Lwt_unix.on_signal, it reinstall the signal handler (with Sys.set_signal).

Removes a node from the sequence it is part of.

remove_min q evaluates to a new priority queue, which contains all the elements of q except for its minimum element.

Wrapper for Unix.rename

Resize the internal buffer to the given size

Same as const.

Lwt.return v creates a new promise that is already fulfilled with value v.

Like Lwt.return_some, this function performs no optimization.

Lwt.return_false is like Lwt.return_unit, but for Lwt.returnfalse.

Lwt.return_nil is like Lwt.return_unit, but for Lwt.return[].

Lwt.return_none is like Lwt.return_unit, but for Lwt.returnNone.

Like Lwt.return_some, this function performs no optimization.

Counterpart to Lwt.return_none.

Lwt.return_true is like Lwt.return_unit, but for Lwt.returntrue.

Lwt.return_unit is defined as Lwt.return(), but this definition is evaluated only once, during initialization of module Lwt, at the beginning of your program.

Resets the given directory handle, so that directory listing can be restarted.

Wrapper for Unix.rmdir

run p calls the Lwt scheduler repeatedly until p resolves, and returns the value of p if it is fulfilled.

run_in_main f can be called from a detached computation to execute f () in the main preemptive thread, i.e.

run_job ?async_method job starts job and wait for its termination.

Not implemented on Windows.

Wrapper for Unix.send.

Not implemented on Windows.

send_msg ~socket ~io_vectors ~fds sends data from a list of io-vectors, accompanied with a list of file-descriptors.

send_notification id sends a notification.

Not implemented on Windows.

Wrapper for Unix.sendto.

get buffer offset value changes the value of the byte at offset offset in buffer to value.

set ?transfer ?destroy engine replaces the current engine by the given one.

Change the contents of a node

set_affinity ?pid cpus sets the list of CPUs the given process is allowed to run on.

set_blocking fd b causes Lwt to internally use blocking or non-blocking I/O with fd, according to the value of b.

set_bounds (min, max) set the minimum and the maximum number of preemptive threads.

Wrapper for Unix.set_close_on_exec

Sets the default async method.

Change the default buffer size.

Lwt_timeout.set_exn_handler f sets the handler to be used for exceptions raised by timeout actions.

Sets the size of the waiting queue, if no more preemptive threads are available.

set_notification id f replace the function associated to the notification by f.

Change the size of the pool.

set_position ch pos Sets the position in the output channel.

Wrapper for Unix.setsockopt

Wrapper for Unix.setsockopt_float

Wrapper for Unix.setsockopt_int

Wrapper for Unix.setsockopt_optint

A command executed with the shell.

Wrapper for Unix.shutdown

Closes the given server's listening socket.

Old version of Lwt_io.shutdown_server.

Since Lwt 3.0.0, this is just an alias for Lwt_io.shutdown_server.

signal condvar value notifies that a condition is ready.

Returns the number of registered signal handler.

simple_init () checks if the library is not yet initialized, and if not, does a simple initialization.

size q evaluates to the number of elements in q.

sleep d is a thread that remains suspended for d seconds and then terminates.

socket domain type proto is the same as Unix.socket but maps the result into a lwt file descriptor

Wrapper for Unix.socketpair

Starts the given timeout.

Wrapper for Unix.LargeFile.stat

Wrapper for Unix.stat

state fd returns the state of fd

Lwt.state p evaluates to the current state of promise p:

The standard output for error messages, it writes data to Lwt_unix.stderr

The standard file descriptor for printing error messages

Formatter printing on Lwt_io.stdout.

The standard input, it reads data from Lwt_unix.stdin

The standard file descriptor for input.

The standard output, it writes data to Lwt_unix.stdout

The standard file descriptor for output

Formatter printing on Lwt_io.stdout.

Stops (cancels) the given timeout.

stop_event event stops the given event.

Stop the given notification.

Wrapper for Unix.symlink

Executes the given command, waits until it terminates, and return its termination status.

Same as Lwt_sys.byte_order.

Some systems limit the number of I/O vectors that can be passed in a single call to their writev or readv system calls.

take mvar will take any currently available value from the mailbox variable.

take_available mvar immediately takes the value from mvar without blocking, returning None if the mailbox is empty.

take_l x s remove and returns the leftmost element of s

take_opt_l x s remove and returns Some x where x is the leftmost element of s or None if s is empty

take_opt_l x s remove and returns Some x where x is the rightmost element of s or None if s is empty

take_l x s remove and returns the rightmost element of s

Creates a new pending promise, paired with its resolver.

Wrapper for Unix.tcdrain

Wrapper for Unix.tcflow

Wrapper for Unix.tcflush

Wrapper for Unix.tcgetattr

Wrapper for Unix.tcsendbreak

Wrapper for Unix.tcsetattr

The number of system threads running (excluding this one).

The number threads waiting for a job.

timeout d is a thread that remains suspended for d seconds and then fails with Lwt_unix.Timeout.

Returns the number of registered timers.

to_bytes buf returns newly allocated bytes with the same contents as buf.

Returns the list of elements of the given stream

Creates a stream holding all values occurring on the given event

to_string buf returns a newly allocated string with the same contents as buf.

Returns the word composed of all characters of the given stream

transfer_l s1 s2 removes all elements of s1 and add them at the left of s2.

transfer_r s1 s2 removes all elements of s1 and add them at the right of s2.

Wrapper for Unix.LargeFile.truncate

Wrapper for Unix.truncate

Lwt.try_bind f g h applies f (), and then makes it so that:

turn_off switch turns off the switch.

union q q' evaluates to a new priority queue, which contains all the elements of both q and q'.

Returns the underlying unix file descriptor.

Wrapper for Unix.unlink

unlock mutex unlock the mutex if no threads is waiting on it.

Same as Lwt_bytes.blit but without bound checking.

Same as Lwt_bytes.blit_from_bytes but without bounds checking.

Same as Lwt_bytes.blit_to_bytes but without bounds checking.

Same as Lwt_bytes.fill but without bounds checking.

Same as Lwt_bytes.get but without bounds checking.

Same as Lwt_bytes.set but without bounds checking.

use p f requests one free element of the pool p and gives it to the function f.

utimes path atime mtime updates the access and modification times of the file at path.

Wrapper for Unix.wait

wait mutex condvar will cause the current thread to block, awaiting notification for a condition variable, condvar.

Lwt.wait is the same as Lwt.task, except the resulting promise p is not cancelable.

wait4 flags pid returns (pid, status, rusage) where (pid, status) is the same result as Unix.waitpid flags pid, and rusage contains accounting information about the child.

Returns the number of threads waiting for a child to terminate.

Wait for all pending jobs to terminate.

wait_mincore buffer offset waits until the page containing the byte at offset offset is in RAM.

wait_queue_length p returns the number of Lwt_pool.use requests currently waiting for an element of the pool p to become available.

Waits (without blocking other threads) until there is something to read from the file descriptor.

Waits (without blocking other threads) until it is possible to write on the file descriptor.

Lwt.waiter_of_wakener r evaluates to the promise associated with resolver r.

A promise-returning analog to Unix.waitpid.

Lwt.wakeup r v is like Lwt.wakeup_laterr v, except it guarantees that callbacks associated with r will be called immediately, deeper on the current stack.