Index of values

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

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

f =<< t = t >>= f

f =|< m = map f m

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

m >|= f = map f m

abort ch abort current operations and close the channel immediatly.

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

Wrapper for Unix.accept

accept_n fd count accepts up to count connection in one time.

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

Same as notify but does not return a notifier

Same as notify but does not return a notifier

Same as notify_p but does not return a notifier

Same as notify_p but does not return a notifier

Same as notify_s but does not return a notifier

Same as notify_s but does not return a notifier

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

apply_filters select apply all the filters on the given select function.

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

Wrapper for Unix.bind

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.

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.

buffered oc returns the number of bytes in the buffer

cancel t cancels the threads t.

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

changes the duration of a 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

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

choose l creates an stream from a list of streams.

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

clone st clone the given stream.

close ch closes the given channel: wait for all pending operations to terminate, preventing new one to be queued, then flush the channel if it is an output channel and close it.

Close a file descriptor.

combine s1 s2 combine two streams.

concat st returns the concatenation of all streams of st.

Wrapper for Unix.connect

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

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

create () creates a new empty sequence

create_condition () creates a new condition variable.

create () creates a new empty mailbox variable.

Return the default size for buffers.

The default iteration function.

The default select function.

detaches a computation to a preemptive thread.

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

disable notif stops the corresponding signal to be monitored

disable notif stops the corresponding event to be monitored

exec command execute command and returns its exit status.

Sets of functions executed just before the program exit.

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

Returns the length of a file

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.

flush oc performs all pending writes on oc

fold_l f s is:

Similar to List.fold_left.

fold_r f s is:

fold f s x fold_like function for streams.

from f creates an stream from the given input function.

Returns the contents of a node

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

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

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.

Cooperative getaddrinfo with cache (using Lwt_preemptive.detach)

Cooperative gethostbyname with cache (using Lwt_preemptive.detach)

Cooperative getnameinfo with cache (using Lwt_preemptive.detach)

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

The set of action waiting for a file descriptor to become readable

Returns true iff the given sequence is empty

is_empty enum returns wether the given stream is empty

Are we using an SSL socket?

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

Returns the length of the channel in bytes

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

lock mon locks a monitor to gain exclusive access to a shared resource.

The function doing one step of the main loop.

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

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

min_timeout a b returns the smallest timeout of two timeouts.

mode ch returns the mode of a channel

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

notify f s calls f each time the value of s change

notify f ev calls f x each time ev has a value x

notify mon condvar value notifies that a condition is ready.

notify_all mon condvar value notifies all waiting threads.

notify_p f s is the same as notify except that f x is a thread.

notify_p f ev is the same as notify except that f x is a thread.

notify_s f s is the same as notify except that f x is a thread.

notify_s f ev is the same as notify except that f x is a thread.

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

Output which drops everything

of_fd ~mode ~fd creates a channel from a file descriptor

of_lazy_list st creates a stream from a lazy-list

of_list l creates a stream returns all elements of l

of_string str creates a stream returning all characters of str

of_unix_fd ~mode ~fd is a short-hand for:

Creates a lwt file descriptor from a unix one.

Normally Lwt_unix uses file descriptors in non-blocking mode, but in certain cases, like for standard descriptors (Lwt_unix.stdin, Lwt_unix.stdout and Lwt_unix.stderr) we do not want that.

on_cancel t f executes f when t is canceled.

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.

output output mode representation

The set of action waiting for a file descriptor to become writable

parse st f parsses to f a copy of st.

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

pipe ?buffer_size () 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.

position ch Returns the current position in the channel.

put mvar value puts a value into a mailbox variable.

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

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

read_char ic reads the next character of ic.

Same as read_byte but do 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

register_action set fd action registers action on fd.

Removes a node from the sequence it is part of.

resize_region reg sz resize the region reg to size sz.

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

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.

select l is the same as choose but it cancels all sleeping threads when one terminates.

The set of all select filters.

Change the contents of a node

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

Change the default buffer size.

set the default handler for exception occurring after a timeout.

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

set_position ch pos Sets the position in the output channel.

Wrapper for Unix.setsockopt

A command executed with "/bin/sh"

Wrapper for Unix.shutdown

signal signum returns an object with a method event which is the event occuring each time the signal number signum is received by the running process.

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.

state fd returns the state of fd

state t returns the state of a thread

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

The standard file descriptor for printing error messages

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

stops a timeout.

Wrapper for Unix.system

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 () creates a sleeping thread that can be canceled using Lwt.cancel

timeout d is a threads which remain suspended for d seconds then fail with Lwt_unix.Timeout

to_lazy_list ll returns the internal lazy-list of a 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.

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

Returns the underlying unix file descriptor.

unlock mon unlocks a monitor.

use p f takes one free member of the pool p and gives it to the function f.

Wrapper for Unix.wait

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

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.

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

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.

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_lock lock f is used to lock a mutex within a block scope.

with_lock mon f is used to lock a monitor within a block scope.

with_timeout d f is a short-hand for:

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

write oc str writes all characters of str on oc

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

write_char oc char writes char on oc

write_chars oc chars writes all characters contained hold by chars on oc

Writes an IEEE single precision floating point value

Writes an IEEE double precision floating point value

write_from oc buffer offset length writes up to length bytes to oc, from buffer at offset offset and returns the number of bytes actually written

write_from_exactly oc buffer offset length writes all length bytes from buffer at offset offset to oc

Writes an ocaml int as a 32-bits integer

write_line oc str writes str on oc followed by a new-line.

write_lines oc lines writes all lines of lines to oc

write_value oc ?flags x marshals the value x to oc

yield () is a threads which suspends itself and then resumes as soon as possible and terminates.

Inputs which returns always '\x00'