Index of values


(<&>) [Lwt]
t <&> t' is the same as join [t; t']
(<?>) [Lwt]
t <?> t' is the same as choose [t; t']
(=<<) [Lwt]
f =<< t = t >>= f
(=|<) [Lwt]
f =|< m = map f m
(>>=) [Lwt]
t >>= f is an alternative notation for bind t f.
(>|=) [Lwt]
m >|= f = map f m

A
abort [Lwt_ssl]
abort [Lwt_io]
abort ch abort current operations and close the channel immediatly.
abort [Lwt_unix]
abort fd exn makes all current and further uses of the file descriptor fail with the given exception.
accept [Lwt_unix]
Wrapper for Unix.accept
accept_n [Lwt_unix]
accept_n fd count accepts up to count connection in one time.
add_l [Lwt_sequence]
add_l x s adds x to the left of the sequence s
add_r [Lwt_sequence]
add_l x s adds x to the right of the sequence s
always_notify [Lwt_signal]
Same as notify but does not return a notifier
always_notify [Lwt_event]
Same as notify but does not return a notifier
always_notify_p [Lwt_signal]
Same as notify_p but does not return a notifier
always_notify_p [Lwt_event]
Same as notify_p but does not return a notifier
always_notify_s [Lwt_signal]
Same as notify_s but does not return a notifier
always_notify_s [Lwt_event]
Same as notify_s but does not return a notifier
append [Lwt_stream]
append s1 s2 returns a stream which returns all elements of s1, then all elements of s2
apply_filters [Lwt_main]
apply_filters select apply all the filters on the given select function.
atomic [Lwt_io]
atomic f transforms a sequence of io operations into one single atomic io operation.

B
bind [Lwt_unix]
Wrapper for Unix.bind
bind [Lwt]
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 [Lwt_io]
block ch size f pass to f the internal buffer and an offset.
blocking [Lwt_unix]
blocking fd returns whether fd is used in blocking or non-blocking mode.
buffered [Lwt_io]
buffered oc returns the number of bytes in the buffer

C
cancel [Lwt]
cancel t cancels the threads t.
catch [Lwt]
catch t f is a thread that behaves as the thread t () if this thread succeeds.
change [Lwt_timeout]
changes the duration of a timeout.
chars_of_file [Lwt_io]
chars_of_file name returns a stream of all characters of the file with name name.
chars_to_file [Lwt_io]
chars_to_file name chars writes all characters of chars to name
check_descriptor [Lwt_unix]
check_descriptor fd raise an exception if fd is not in the state Open
choose [Lwt_stream]
choose l creates an stream from a list of streams.
choose [Lwt]
choose l behaves as the first thread in l to terminate.
clone [Lwt_stream]
clone st clone the given stream.
close [Lwt_ssl]
close [Lwt_io]
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 [Lwt_unix]
Close a file descriptor.
combine [Lwt_stream]
combine s1 s2 combine two streams.
concat [Lwt_stream]
concat st returns the concatenation of all streams of st.
connect [Lwt_unix]
Wrapper for Unix.connect
create [Lwt_timeout]
create n f defines a new timeout with n seconds duration.
create [Lwt_throttle.S]
create [Lwt_pool]
create n f creates a new pool with at most n members.
create [Lwt_mutex]
create [Lwt_mvar]
create v creates a new mailbox variable containing value v.
create [Lwt_monitor]
create () creates a new monitor.
create [Lwt_sequence]
create () creates a new empty sequence
create_condition [Lwt_monitor]
create_condition () creates a new condition variable.
create_empty [Lwt_mvar]
create () creates a new empty mailbox variable.

D
default_buffer_size [Lwt_io]
Return the default size for buffers.
default_iteration [Lwt_main]
The default iteration function.
default_select [Lwt_main]
The default select function.
detach [Lwt_preemptive]
detaches a computation to a preemptive thread.
direct_access [Lwt_io]
direct_access ch f pass to f a Lwt_io.direct_access structure.
disable [Lwt_signal]
disable notif stops the corresponding signal to be monitored
disable [Lwt_event]
disable notif stops the corresponding event to be monitored

E
eprint [Lwt_io]
eprintf [Lwt_io]
eprintl [Lwt_io]
eprintlf [Lwt_io]
exec [Lwt_process]
exec command execute command and returns its exit status.
exit_hooks [Lwt_main]
Sets of functions executed just before the program exit.

F
fail [Lwt]
fail e is a thread that fails with the exception e.
file_length [Lwt_io]
Returns the length of a file
filter [Lwt_stream]
filter_map [Lwt_stream]
filter_map_s [Lwt_stream]
filter_map f st filter and map st at the same time
filter_s [Lwt_stream]
filter f st keeps only value x such that f x is true
finalise [Lwt_gc]
finalise f x calls f x when x is garbage collected.
finalise_or_exit [Lwt_gc]
finalise_or_exit f x call f x when x is garbage collected or (exclusively) when the program exit.
finalize [Lwt]
finalize f g returns the same result as f () whether it fails or not.
find [Lwt_stream]
find_map [Lwt_stream]
find_map_s [Lwt_stream]
find f s find and map at the same time.
find_s [Lwt_stream]
find f s find an element in a stream.
flush [Lwt_io]
flush oc performs all pending writes on oc
fold [Lwt_stream]
fold_l [Lwt_sequence]
fold_l f s is:
fold_left [Lwt_util]
Similar to List.fold_left.
fold_r [Lwt_sequence]
fold_r f s is:
fold_s [Lwt_stream]
fold f s x fold_like function for streams.
fprint [Lwt_io]
fprintf [Lwt_io]
fprintl [Lwt_io]
fprintlf [Lwt_io]
from [Lwt_stream]
from f creates an stream from the given input function.

G
get [Lwt_sequence]
Returns the contents of a node
get [Lwt_stream]
get st remove and returns the first element of the stream, if any.
get_bounds [Lwt_preemptive]
get_bounds () returns the minimum and the maximum number of preemptive threads.
get_max_number_of_threads_queued [Lwt_preemptive]
Returns the size of the waiting queue, if no more threads are available
get_while [Lwt_stream]
get_while_s [Lwt_stream]
get_while f st returns the longest prefix of st where all elements satisfy f.
getaddrinfo [Lwt_lib]
Cooperative getaddrinfo with cache (using Lwt_preemptive.detach)
gethostbyname [Lwt_lib]
Cooperative gethostbyname with cache (using Lwt_preemptive.detach)
getnameinfo [Lwt_lib]
Cooperative getnameinfo with cache (using Lwt_preemptive.detach)

H
hexdump [Lwt_io]
hexdump oc str = hexdump_stream oc (Lwt_stream.of_string str)
hexdump [Lwt_stream]
hexdump byte_stream returns a stream which is the same as the output of hexdump -C.
hexdump_stream [Lwt_io]
hexdump_stream oc byte_stream produces the same output as the command hexdump -C.

I
ignore_result [Lwt]
ignore_result t start the thread t and ignores its result value if the thread terminates sucessfully.
in_channel_of_descr [Lwt_ssl]
init [Lwt_preemptive]
init min max log initialises this module.
input [Lwt_io]
input input mode representation
inputs [Lwt_unix]
The set of action waiting for a file descriptor to become readable
is_empty [Lwt_sequence]
Returns true iff the given sequence is empty
is_empty [Lwt_stream]
is_empty enum returns wether the given stream is empty
is_ssl [Lwt_ssl]
Are we using an SSL socket?
iter [Lwt_stream]
iter [Lwt_util]
iter f l start a thread for each element in l.
iter_l [Lwt_sequence]
iter_l f s applies f on all elements of s starting from the left
iter_node_l [Lwt_sequence]
iter_l f s applies f on all nodes of s starting from the left
iter_node_r [Lwt_sequence]
iter_l f s applies f on all nodes of s starting from the right
iter_p [Lwt_stream]
iter_r [Lwt_sequence]
iter_l f s applies f on all elements of s starting from the right
iter_s [Lwt_stream]
iter f s iterates over all elements of the stream
iter_serial [Lwt_util]
Similar to iter but wait for one thread to terminate before starting the next one.

J
join [Lwt]
join l wait for all threads in l to terminate.
junk [Lwt_stream]
junk st remove the first element of st.
junk_old [Lwt_stream]
junk_old st removes all elements that are ready to be read without yeilding from st.
junk_while [Lwt_stream]
junk_while_s [Lwt_stream]
junk_while f st removes all elements at the beginning of the streams which satisfy f.

L
length [Lwt_io]
Returns the length of the channel in bytes
lines_of_file [Lwt_io]
lines_of_file name returns a stream of all lines of the file with name name.
lines_to_file [Lwt_io]
lines_to_file name lines writes all lines of lines to files
listen [Lwt_unix]
Wrapper for Unix.listen
lock [Lwt_mutex]
lock [Lwt_monitor]
lock mon locks a monitor to gain exclusive access to a shared resource.

M
main_loop_iteration [Lwt_main]
The function doing one step of the main loop.
make [Lwt_io]
make ?buffer_size ?close ~mode perform_io is the main function for creating new channels.
make_region [Lwt_util]
make_region sz create a region of size sz.
map [Lwt_stream]
map [Lwt_util]
map f l apply f to each element in l and collect the results of the threads thus created.
map [Lwt]
map f m map the result of a thread.
map_s [Lwt_stream]
map f st maps the value returned by st with f
map_serial [Lwt_util]
Similar to map but wait for one thread to terminate before starting the next one.
map_with_waiting_action [Lwt_util]
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 [Lwt_main]
min_timeout a b returns the smallest timeout of two timeouts.
mode [Lwt_io]
mode ch returns the mode of a channel

N
next [Lwt_stream]
next enum remove and returns the next element of the stream, of fail with Lwt_stream.Empty if the stream is empty.
nget [Lwt_stream]
nget n st remove and returns at most the first n elements of st.
njunk [Lwt_stream]
njunk n st removes at most the first n elements of the stream.
notify [Lwt_signal]
notify f s calls f each time the value of s change
notify [Lwt_event]
notify f ev calls f x each time ev has a value x
notify [Lwt_monitor]
notify mon condvar value notifies that a condition is ready.
notify_all [Lwt_monitor]
notify_all mon condvar value notifies all waiting threads.
notify_p [Lwt_signal]
notify_p f s is the same as notify except that f x is a thread.
notify_p [Lwt_event]
notify_p f ev is the same as notify except that f x is a thread.
notify_s [Lwt_signal]
notify_s f s is the same as notify except that f x is a thread.
notify_s [Lwt_event]
notify_s f ev is the same as notify except that f x is a thread.
npeek [Lwt_stream]
npeek n st returns at most the first n elements of st, without removing them.
null [Lwt_io]
Output which drops everything

O
of_fd [Lwt_io]
of_fd ~mode ~fd creates a channel from a file descriptor
of_lazy_list [Lwt_stream]
of_lazy_list st creates a stream from a lazy-list
of_list [Lwt_stream]
of_list l creates a stream returns all elements of l
of_string [Lwt_stream]
of_string str creates a stream returning all characters of str
of_unix_fd [Lwt_io]
of_unix_fd ~mode ~fd is a short-hand for:
of_unix_file_descr [Lwt_unix]
Creates a lwt file descriptor from a unix one.
of_unix_file_descr_blocking [Lwt_unix]
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 [Lwt]
on_cancel t f executes f when t is canceled.
open_connection [Lwt_io]
open_connection ?buffer_size ~mode addr open a connection to the given address and returns two channels for using it.
open_file [Lwt_io]
open_file ?buffer_size ?flags ?perm ~mode filename open the file with name filename and returns a channel for reading/writing it.
open_process [Lwt_process]
open_process_full [Lwt_process]
open_process_in [Lwt_process]
open_process_none [Lwt_process]
open_process_out [Lwt_process]
out_channel_of_descr [Lwt_ssl]
output [Lwt_io]
output output mode representation
outputs [Lwt_unix]
The set of action waiting for a file descriptor to become writable

P
parse [Lwt_stream]
parse st f parsses to f a copy of st.
peek [Lwt_stream]
peek st returns the first element of the stream, if any, without removing it.
pipe [Lwt_io]
pipe ?buffer_size () creates a pipe using Lwt_unix.pipe and makes two channels from the two returned file descriptors
pipe [Lwt_unix]
pipe () creates pipe using Unix.pipe and returns two lwt file descriptors created from unix file_descriptor
pipe_in [Lwt_unix]
pipe_in () is the same as Lwt_unix.pipe but maps only the unix file descriptor for reading into a lwt one.
pipe_out [Lwt_unix]
pipe_out () is the inverse of Lwt_unix.pipe_in.
plain [Lwt_ssl]
pmap [Lwt_process]
pmap_chars [Lwt_process]
pmap_line [Lwt_process]
pmap_lines [Lwt_process]
position [Lwt_io]
position ch Returns the current position in the channel.
pread [Lwt_process]
pread_chars [Lwt_process]
pread_line [Lwt_process]
pread_lines [Lwt_process]
print [Lwt_io]
printf [Lwt_io]
printl [Lwt_io]
printlf [Lwt_io]
put [Lwt_mvar]
put mvar value puts a value into a mailbox variable.
pwrite [Lwt_process]
pwrite_chars [Lwt_process]
pwrite_line [Lwt_process]
pwrite_lines [Lwt_process]

R
read [Lwt_ssl]
read [Lwt_io]
read ?count ic reads at most len characters from ic.
read [Lwt_unix]
read fd buf ofs len has the same semantic as Unix.read, but is cooperative
read_char [Lwt_io]
read_char ic reads the next character of ic.
read_char_opt [Lwt_io]
Same as read_byte but do not raises End_of_file on end of input
read_chars [Lwt_io]
read_chars ic returns a stream holding all characters of ic
read_float32 [Lwt_io.NumberIO]
Reads an IEEE single precision floating point value
read_float64 [Lwt_io.NumberIO]
Reads an IEEE double precision floating point value
read_int [Lwt_io.NumberIO]
Reads a 32-bits integer as an ocaml int
read_int16 [Lwt_io.NumberIO]
read_int32 [Lwt_io.NumberIO]
read_int64 [Lwt_io.NumberIO]
read_into [Lwt_io]
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 [Lwt_io]
read_into_exactly ic buffer offset length reads exactly length bytes and stores them in buffer at offset offset.
read_line [Lwt_io]
read_line ic reads one complete line from ic and returns it without the end of line.
read_line_opt [Lwt_io]
Same as Lwt_io.read_line but do not raise End_of_file on end of input.
read_lines [Lwt_io]
read_lines ic returns a stream holding all lines of ic
read_value [Lwt_io]
read_value ic reads a marshaled value from ic
register_action [Lwt_unix]
register_action set fd action registers action on fd.
remove [Lwt_sequence]
Removes a node from the sequence it is part of.
resize_region [Lwt_util]
resize_region reg sz resize the region reg to size sz.
return [Lwt]
return e is a thread whose return value is the value of the expression e.
run [Lwt_main]
run t calls the Lwt scheduler repeatedly until t terminates, then returns the value returned by the thread.
run_in_region [Lwt_util]
run_in_region reg size f execute the thread produced by the function f in the region reg.

S
select [Lwt]
select l is the same as choose but it cancels all sleeping threads when one terminates.
select_filters [Lwt_main]
The set of all select filters.
set [Lwt_sequence]
Change the contents of a node
set_blocking [Lwt_unix]
set_blocking fd b puts fd in blocking or non-blocking mode.
set_bounds [Lwt_preemptive]
set_bounds (min, max) set the minimum and the maximum number of preemptive threads.
set_close_on_exec [Lwt_unix]
Wrapper for Unix.set_close_on_exec
set_default_buffer_size [Lwt_io]
Change the default buffer size.
set_exn_handler [Lwt_timeout]
set the default handler for exception occurring after a timeout.
set_max_number_of_threads_queued [Lwt_preemptive]
Sets the size of the waiting queue, if no more preemptive threads are available.
set_position [Lwt_io]
set_position ch pos Sets the position in the output channel.
setsockopt [Lwt_unix]
Wrapper for Unix.setsockopt
shell [Lwt_process]
A command executed with "/bin/sh"
shutdown [Lwt_ssl]
shutdown [Lwt_unix]
Wrapper for Unix.shutdown
signal [Lwt_unix]
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 [Lwt_preemptive]
simple_init () does a simple initialization.
sleep [Lwt_unix]
sleep d is a threads which remain suspended for d seconds and then terminates.
socket [Lwt_unix]
socket domain type proto is the same as Unix.socket but maps the result into a lwt file descriptor
socketpair [Lwt_unix]
Wrapper for Unix.socketpair
ssl_accept [Lwt_ssl]
ssl_connect [Lwt_ssl]
ssl_shutdown [Lwt_ssl]
start [Lwt_timeout]
starts a timeout.
state [Lwt_unix]
state fd returns the state of fd
state [Lwt]
state t returns the state of a thread
stderr [Lwt_io]
The standard output for error messages, it writes data to Lwt_unix.stderr
stderr [Lwt_unix]
The standard file descriptor for printing error messages
stdin [Lwt_io]
The standard input, it reads data from Lwt_unix.stdin
stdin [Lwt_unix]
The standard file descriptor for input.
stdout [Lwt_io]
The standard output, it writes data to Lwt_unix.stdout
stdout [Lwt_unix]
The standard file descriptor for output
stop [Lwt_timeout]
stops a timeout.
system [Lwt_unix]
Wrapper for Unix.system

T
take [Lwt_mvar]
take mvar will take any currently available value from the mailbox variable.
take_l [Lwt_sequence]
take_l x s remove and returns the leftmost element of s
take_opt_l [Lwt_sequence]
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_r [Lwt_sequence]
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_r [Lwt_sequence]
take_l x s remove and returns the rightmost element of s
task [Lwt]
task () creates a sleeping thread that can be canceled using Lwt.cancel
timeout [Lwt_unix]
timeout d is a threads which remain suspended for d seconds then fail with Lwt_unix.Timeout
to_lazy_list [Lwt_stream]
to_lazy_list ll returns the internal lazy-list of a stream
transfer_l [Lwt_sequence]
transfer_l s1 s2 removes all elements of s1 and add them at the left of s2.
transfer_r [Lwt_sequence]
transfer_r s1 s2 removes all elements of s1 and add them at the right of s2.
try_bind [Lwt]
try_bind t f g behaves as bind (t ()) f if t does not fail.

U
unix_file_descr [Lwt_unix]
Returns the underlying unix file descriptor.
unlock [Lwt_mutex]
unlock [Lwt_monitor]
unlock mon unlocks a monitor.
use [Lwt_pool]
use p f takes one free member of the pool p and gives it to the function f.

W
wait [Lwt_unix]
Wrapper for Unix.wait
wait [Lwt_throttle.S]
wait [Lwt_monitor]
wait mon condvar will cause the current thread to block, awaiting notification for a condition variable, condvar.
wait [Lwt]
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_read [Lwt_ssl]
wait_read [Lwt_unix]
waits (without blocking other threads) until there is something to read on the file descriptor
wait_write [Lwt_ssl]
wait_write [Lwt_unix]
waits (without blocking other threads) until it is possible to write on the file descriptor
waitpid [Lwt_unix]
Wrapper for Unix.waitpid
wakeup [Lwt]
wakeup t e makes the sleeping thread t terminate and return the value of the expression e.
wakeup_exn [Lwt]
wakeup_exn t e makes the sleeping thread t fail with the exception e.
with_connection [Lwt_io]
with_connection ?buffer_size ~mode addr f open a connection to the given address and passes the channels to f
with_file [Lwt_io]
with_file ?buffer_size ?flags ?perm ~mode filename f open a file and passes the channel to f.
with_lock [Lwt_mutex]
with_lock lock f is used to lock a mutex within a block scope.
with_lock [Lwt_monitor]
with_lock mon f is used to lock a monitor within a block scope.
with_process [Lwt_process]
with_process_full [Lwt_process]
with_process_in [Lwt_process]
with_process_none [Lwt_process]
with_process_out [Lwt_process]
with_timeout [Lwt_unix]
with_timeout d f is a short-hand for:
wrap_syscall [Lwt_unix]
wrap_syscall set fd action wrap an action on a file descriptor.
write [Lwt_ssl]
write [Lwt_io]
write oc str writes all characters of str on oc
write [Lwt_unix]
read fd buf ofs len has the same semantic as Unix.write, but is cooperative
write_char [Lwt_io]
write_char oc char writes char on oc
write_chars [Lwt_io]
write_chars oc chars writes all characters contained hold by chars on oc
write_float32 [Lwt_io.NumberIO]
Writes an IEEE single precision floating point value
write_float64 [Lwt_io.NumberIO]
Writes an IEEE double precision floating point value
write_from [Lwt_io]
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 [Lwt_io]
write_from_exactly oc buffer offset length writes all length bytes from buffer at offset offset to oc
write_int [Lwt_io.NumberIO]
Writes an ocaml int as a 32-bits integer
write_int16 [Lwt_io.NumberIO]
write_int32 [Lwt_io.NumberIO]
write_int64 [Lwt_io.NumberIO]
write_line [Lwt_io]
write_line oc str writes str on oc followed by a new-line.
write_lines [Lwt_io]
write_lines oc lines writes all lines of lines to oc
write_value [Lwt_io]
write_value oc ?flags x marshals the value x to oc

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

Z
zero [Lwt_io]
Inputs which returns always '\x00'