Index of values

t <&> t' is the same as join [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

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

Wrapper for Unix.accept

accept_n fd count accepts up to count connection in 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, then f is called immediatly.

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.

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_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 which 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 copy len bytes from buf1 starting at offset ofs1 to buf2 starting at offset ofs2.

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

Same as blit but the first 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.

cancel t cancels the threads t.

cancel_jobs () make all pending jobs to fail with 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 raise 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 the given logger

close ch closes the given channel.

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.

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

Creates a new byte array of the given size.

create () creates a new switch.

create () returns a new stream and a push function

create () creates a new empty sequence

create n 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 () creates a new empty mailbox variable.

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

establich_server ?buffer_size ?backlog sockaddr f creates a server which will listen for incomming connections.

Executes the given command and returns its exit status.

execute_job ?async_method ~job ~get ~free starts job and wait for its termination.

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.

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.

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 calls f x when x is garbage collected.

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

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

Similar to List.fold_left.

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 f () returns a value.

from f creates an stream from the given input function.

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 () returns the engine currently in use.

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

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 l returns all available elements of l without blocking

get_available_up_to l n 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 credential informations 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

Cooperative getaddrinfo with cache (using Lwt_preemptive.detach)

Wrapper for Unix.getgrgid

Wrapper for Unix.getgrnam

Wrapper for Unix.gethostbyaddr

Wrapper for Unix.gethostbyname

Cooperative gethostbyname with cache (using Lwt_preemptive.detach)

Wrapper for Unix.gethostname

Wrapper for Unix.getlogin

Wrapper for Unix.getnameinfo

Cooperative getnameinfo with cache (using Lwt_preemptive.detach)

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.

ignore_result t start the thread t and ignores its result value if the thread terminates sucessfully.

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

Are we using an SSL socket?

Wrapper for Unix.isatty

iter block performs one iteration of the main loop.

iter f l start a thread for each element in l.

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

Similar to iter but wait for one thread to terminate before starting the next one.

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.

next_new st if no element are available on st without sleeping, then it is the same as next st.

Functions that are called after the main iteration.

Returns the length of the channel in bytes

Returns the length of the given byte array.

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 files

Wrapper for Unix.link

Wrapper for Unix.listen

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 advise the kernel about how the program is going to use the part of the memory mapped file between pos and pos + len.

The main section.

make name creates a section with the given name.

make ~output ~close creates a new logger.

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

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.

make_region sz create a region of size sz.

map f l apply f to each element in l and collect the results of the threads thus created.

map f m map the result of a thread.

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

Similar to map but wait for one thread to terminate before starting the next one.

map_with_waiting_action f wa l apply f to each element in l and collect the results of the threads thus created.

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

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.

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.

Logger which drops everything

Output which drops everything

of_array a creates a stream returning all elements of a

Create a channel from a byte array.

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

of_list l creates a stream returning all elements of l

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

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

of_string str creates a stream returning all characters of str

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

Creates a lwt file descriptor from a unix one.

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_success t f executes f when t terminates without failing.

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 ?buffer_size ~mode addr open a connection to the given address and returns two channels for using it.

open_file ?buffer_size ?flags ?perm ~mode filename open 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 thread currently paused.

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 ?buffer_size () 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 len characters from ic.

read_char ic reads the next character of ic.

Same as read_byte but does not raises 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.dir

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

Wrapper for Unix.readlink

Wrapper for Unix.recv

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

This call is not available on windows.

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

Removes a node from the sequence it is part of.

Wrapper for Unix.rename

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.

Resize the internal buffer to the given size

resize_region reg sz resize the region reg to size sz.

Same as const.

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

Wrapper for Unix.rewinddir

Wrapper for Unix.rmdir

parse lexbuf returns the list of rules contained in lexbuf

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

run_in_region reg size f execute the thread produced by the function f in the region reg.

Wrapper for Unix.send

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

This call is not available on windows.

send_notification id sends a notification.

Wrapper for Unix.sendto

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

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

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 "/bin/sh"

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 threads which remain 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 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.

Wrapper for Unix.system

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 threads which remain suspended for d seconds then fail with Lwt_unix.Timeout

Returns the number of registered timers.

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 Lwt_bytes.blit_bytes_string but without bound checking.

Same as Lwt_bytes.blit_string_bytes but without bound checking.

Same as Lwt_bytes.fill but without bound checking.

Same as Lwt_bytes.get but without bound checking.

Same as Lwt_bytes.set but without bound 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 in the the 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

wakeup t e makes the sleeping thread t terminate and return the value of the expression e.

wakeup_exn t e makes the sleeping thread t fail with the exception e.

Same as Lwt.wakeup but it is not guaranteed that the thread will be wakeup immediately.

Same as Lwt.wakeup_exn but it is not guaranteed that the thread will be wakeup immediately.

wakeup_paused () wakes up all threads which suspended themselves with Lwt.pause.

true iff running on windows.

with_async_none f is a shorthand for:

with_async_none f is a shorthand for:

with_async_none f is a shorthand for:

with_connection ?buffer_size ~mode addr f open a connection to the given address and passes the channels to f

with_file ?buffer_size ?flags ?perm ~mode filename f open a file and passes the channel to f.

with_finaliser f s returns a signal s' which behave as s, except that f is called when s' is garbage collected.

with_finaliser f e returns an event e' which behave as e, except that f is called when e' is garbage collected.

with_lock lock f is used to lock a mutex within a block scope.

with_timeout d f is a short-hand for:

with_value key value f executes f with value associated to key.

wrap f calls f and transform the result into a monad.

wrap1 f x applies f on x and returns the result as a thread.

wrap_syscall set fd action wrap an action on a file descriptor.

Returns whether the given file descriptor is currently writable.

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

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