Index of values

t <&> t' is the same as join [t; t']

t <&> t' is the same as join [t; t']

t <?> t' is the same as choose [t; t']

t <?> t' is the same as choose [t; t']

t >>= f is an alternative notation for bind t f.

m >|= f is map f m

m >|= f is map f m

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

abort ch abort current operations and close the channel immediately.

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

add_rule pattern level adds a rule for sections logging levels.

add_task_l seq creates a sleeping thread, adds its wakener to the left of seq and returns its waiter.

add_task_r seq creates a sleeping thread, adds its wakener to the right of seq and returns its waiter.

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

append_rule pattern level adds the given rule after all other rules.

async f starts a thread without waiting for the result.

Function called when a asynchronous exception is thrown.

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.

Wrapper for Unix.bind

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

bind t f is a thread which first waits for the thread t to terminate and then, if the thread succeeds, behaves as the application of function f to the return value of t.

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 returns whether fd is used in blocking or non-blocking mode.

broadcast loggers is a logger which send messages to all the given loggers.

broadcast condvar value notifies all waiting threads.

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.

cancel t cancels the threads t.

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

catch t f is a thread that behaves as the thread t () if this thread succeeds.

changes the duration of a timeout.

channel ?template ~close_mode ~channel () creates a logger from a channel.

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

choose l creates an stream from a list of streams.

choose l behaves as the first thread in l to terminate.

Wrapper for Unix.chown

Wrapper for Unix.chroot

Wrapper for Unix.clear_close_on_exec

clone st clone the given stream.

Close a file descriptor.

close ch closes the given channel.

Close the given logger

Wrapper for Unix.closedir

combine s1 s2 combine 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.

create n f defines a new timeout with n seconds duration.

create () creates a new switch.

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

create () creates a new empty sequence

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

create v creates a new mailbox variable containing value v.

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

create () creates a new condition variable.

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.

Put the current running process into daemon mode.

The default logger.

Returns the default async method.

Return the default size for buffers.

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

detaches a computation to a preemptive thread.

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

Stops receiving this signal

dispatch f is a logger which dispatch logging instructions to different logger according to their level and/or section.

Wrapper for Unix.dup

Wrapper for Unix.dup2

Functions that are called before the main iteration.

establish_server ?fd ?buffer_size ?backlog sockaddr f creates a server which will listen for incoming connections.

Executes the given command and returns its exit status.

This is the old and deprecated way of running a job.

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.

fail e is a thread that fails with the exception e.

fail_invalid_arg msg is a thread that fails with the exception Invalid_argument msg.

fail_with msg is a thread that fails with the exception Failure msg.

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.

desf_file ?template ?mode ?perm ~file_name () creates an logger which will write messages to file_name.

file_exists name tests if a file named name exists.

file_exists name tests if a file named name exists.

Returns the length of a file

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

finalize f g returns the same result as f () whether it fails or not.

find f s find and map at the same time.

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

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

from f creates an 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.

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

Returns the contents of a node

get key returns the value associated with key in the current thread.

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.

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

Same as Lwt_log_core.log but ignore the resulting thread.

Same as Lwt_log_core.log_f but ignore the resulting thread.

ignore_result t is like Pervasives.ignore t except that:

init min max log initialises this module.

input input mode representation

Install the Glib<->Lwt integration.

Creates an io-vector

is_busy channel returns whether the given channel is currently busy.

is_empty st returns wether the given stream is empty

Returns true iff the given sequence is empty

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

locked mutex returns whether mutex is currently locked

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

is_sleeping t returns true iff t is sleeping.

Are we using an SSL socket?

Wrapper for Unix.isatty

iter block performs one iteration of the main loop.

This function is not related to Lwt.

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

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

join l waits for all threads in l to terminate.

junk st remove the first element of st.

junk_old st removes all elements that are ready to be read without yeilding 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 sleepping, or wait for one if no one is already 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.

level section returns the logging level of section.

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

Reset the rules set when parsing the LWT_LOG environment variable using this string.

The key for storing current location.

lock mutex lockcs the mutex, that is:

Wrapper for Unix.lockf

log ?section ?logger ~level message logs a message.

log_f is the same as log except that it takes a format string

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.

The main section.

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

make name creates a section with the given name.

make ~output ~close creates a new logger.

error e creates a result containing the exception e.

make_in_channel read creates an input channel from the read function.

new_notifier ?once f registers a new notifier.

make_out_channel write creates an output channel from the write function.

value x creates a result containing the value x.

map f m maps the result of a thread.

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

name section returns the name of section.

nchoose l returns the value of all that have succcessfully terminated.

nchoose_split l does the same as Lwt.nchoose but also retrurns the list of threads that have not yet terminated.

new_key () creates a new key.

next e returns the next occurrence of e

next st remove and returns the next element of the stream, of fail with Lwt_stream.Empty if the stream is empty.

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

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

no_cancel thread creates a thread which behave as thread except that it cannot be canceled.

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

npick l is the same as Lwt.nchoose, except that it cancels all sleeping threads when one terminates.

Output which drops everything

Logger 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_fd ?buffer ?close ~mode fd creates a channel from a file descriptor.

of_list l creates a stream returning all elements of l

Returns a thread from a result.

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:

Creates a lwt file descriptor from a unix one.

on_any t f g executes f or g when t terminates.

on_cancel t f executes f when t is canceled.

on_failure t f executes f when t terminates and fails.

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.

on_success t f executes f when t terminates without failing.

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

on_termination t f executes f when t terminates.

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.

open_file ?buffer ?flags ?perm ~mode filename opens the file with name filename and returns a channel for reading/writing it.

Wrapper for Unix.opendir

Wrapper for Unix.openfile.

output output mode representation

Size of pages.

parse st f parses st with f.

pause () is a sleeping thread which is wake up on the next call to Lwt.wakeup_paused.

paused_count () returns the number of currently paused threads.

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

pick l is the same as Lwt.choose, except that it cancels all sleeping threads when one terminates.

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

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

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.

protected thread creates a new cancelable thread which behave as thread except that cancelling it does not cancel thread.

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

put mvar value puts a value into a mailbox variable.

read fd buf ofs len has the same semantic as Unix.read, but is cooperative

read ?count ic reads at most count characters from ic.

read_char ic reads the next character of ic.

Same as read_byte 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 ic reads a marshaled value from ic

Returns whether the given file descriptor is currently readable.

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

Wrapper for Unix.readdir.

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

Wrapper for Unix.readlink

Wrapper for Unix.recv

This call is not available on windows.

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

Wrapper for Unix.recvfrom

register_action set fd action registers action on fd.

register_pause_notifier f register a function f that will be called each time pause is called.

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

Remove the Glib<->Lwt integration.

Removes a node from the sequence it is part of.

Wrapper for Unix.rename

Same as Lwt_log_core.render, except that the template may also contain the following variables:

render ~buffer ~template ~section ~level ~message instantiate all variables of template, and store the result in buffer.

reset_level section resets the level of section to its default value, i.e.

removes all rules.

Resize the internal buffer to the given size

Same as const.

return e is a thread whose return value is the value of the expression e.

return_false = return false

return_nil = return []

return_none = return None

return_some x = return (Some x)

return_true = return true

return_unit = return ()

Wrapper for Unix.rewinddir

Wrapper for Unix.rmdir

parse lexbuf returns the list of rules contained in lexbuf or None in case of parsing error

run t calls the Lwt scheduler repeatedly until t terminates, then returns the value returned by the thread.

run_in_main f executes f in the main thread, i.e.

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

Wrapper for Unix.send

This call is not available 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.

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 puts fd in blocking or non-blocking mode.

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.

set the default handler for exception occurring after a timeout.

set_level section sets the logging level of the given section.

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

Shutdown the given server

signal condvar value notifies that a condition is ready.

Returns the number of registered signal handler.

simple_init () does a simple initialization.

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

Await a SSL/TLS handshake on the specified socket (used by servers).

Initiate a SSL/TLS handshake on the specified socket (used by clients).

Returns the underlying SSL socket used for this wrapper.

Returns the underlying SSL socket used for this wrapper.

starts a timeout.

Wrapper for Unix.LargeFile.stat

Wrapper for Unix.stat

state fd returns the state of fd

state t returns the state of a thread

The standard file descriptor for printing error messages

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

The standard file descriptor for input.

The standard input, it reads data from Lwt_unix.stdin

The standard file descriptor for output

The standard output, it writes data to Lwt_unix.stdout

stops a timeout.

stop_event event stops the given event.

Stop the given notification.

Wrapper for Unix.symlink

syslog ?template ?paths ~facility () creates an logger which send message to the system logger.

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

Same as Lwt_sys.byte_order.

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

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

task () is the same as wait () except that threads created with task can be canceled.

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

try_bind t f g behaves as bind (t ()) f if t does not fail.

turn_off switch turns off the switch.

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 blit_string_bytes but without bounds checking.

Same as blit_bytes_string 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 takes one free member of the pool p and gives it to the function f.

Wrapper for Unix.wait

wait () is a pair of a thread which sleeps forever (unless it is resumed by one of the functions wakeup, wakeup_exn below) and the corresponding wakener.

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

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.

waits (without blocking other threads) until there is something to read on the file descriptor

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

Returns the thread associated to a wakener.

Wrapper for Unix.waitpid

If one thread is blocking on Lwt_glib.iter, then wakeup () make Lwt_glib.iter to return immediately.