Index of values


(<&>) [Lwt]

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

(<?>) [Lwt]

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

Error a_api: "(=|<)>>~[<<a_api|moduleLwt>>~]|<<divclass=\"odocwiki_info\"|<<spanclass=\"odocwiki_inlinecode\"|f~=~|~<m>>is<<spanclass=\"odocwiki_inlinecode\"|mapfm>>>>||@@class=\"odocwiki_index\"@@@<<a_apitext=\"(>>=)\"|valueLwt" is not a valid module name=) >> [Lwt]

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

(>|=) [Lwt]

m >|= f is map f m


A
abort [Lwt_unix]

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

abort [Lwt_io]

abort ch abort current operations and close the channel immediatly.

abort [Lwt_ssl]
accept [Lwt_unix]

Wrapper for Unix.accept

accept_n [Lwt_unix]

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

access [Lwt_unix]

Wrapper for Unix.access

accum_s [Lwt_signal]
accum_s [Lwt_react.​S]
accum_s [Lwt_react.​E]
accum_s [Lwt_event]
add [Lwt_pqueue.​S]
add_hook [Lwt_switch]

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

add_hook_or_exec [Lwt_switch]

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

add_rule [Lwt_log]

add_rule pattern level adds a rule for sections logging levels.

always_notify [Lwt_signal]
always_notify [Lwt_event]
always_notify_p [Lwt_signal]
always_notify_p [Lwt_event]
always_notify_s [Lwt_signal]
always_notify_s [Lwt_event]
app_p [Lwt_react.​E]
app_p [Lwt_event]
app_s [Lwt_signal]
app_s [Lwt_react.​S]
app_s [Lwt_react.​E]
app_s [Lwt_event]
append [Lwt_stream]

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

append_rule [Lwt_log]

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

async_method [Lwt_unix]

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

async_method_key [Lwt_unix]

The key for storing the local async method.

at_exit [Lwt_main]

at_exit hook adds hook at the left of exit_hooks

atomic [Lwt_io]

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

auto_yield [Lwt_unix]

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


B
bind [Lwt_unix]

Wrapper for Unix.bind

bind [Lwt_signal]
bind [Lwt_react.​S]

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

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.

bind_s [Lwt_react.​S]

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

blit [Lwt_bytes]

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

blit_bytes_string [Lwt_bytes]

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

blit_string_bytes [Lwt_bytes]

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

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.

broadcast [Lwt_log]

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

broadcast [Lwt_condition]

broadcast condvar value notifies all waiting threads.

buffer_size [Lwt_io]

Returns the size of the internal buffer.

buffered [Lwt_io]

buffered oc returns the number of bytes in the buffer

byte_order [Lwt_sys]

The byte order used by the computer running the program.


C
cancel [Lwt]

cancel t cancels the threads t.

cancel_jobs [Lwt_unix]

cancel_jobs () make all pending jobs to fail with Lwt.​Canceled.

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.

channel [Lwt_log]

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

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

chdir [Lwt_unix]

Wrapper for Unix.chdir

check [Lwt_switch]

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

check_descriptor [Lwt_unix]

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

chmod [Lwt_unix]

Wrapper for Unix.chmod

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.

chown [Lwt_unix]

Wrapper for Unix.chown

chroot [Lwt_unix]

Wrapper for Unix.chroot

clear_close_on_exec [Lwt_unix]

Wrapper for Unix.clear_close_on_exec

clone [Lwt_stream]

clone st clone the given stream.

close [Lwt_unix]

Close a file descriptor.

close [Lwt_log]

Close the given logger

close [Lwt_io]

close ch closes the given channel.

close [Lwt_ssl]
close_in [Lwt_chan]
close_out [Lwt_chan]
closedir [Lwt_unix]

Wrapper for Unix.closedir

combine [Lwt_stream]

combine s1 s2 combine two streams.

compare [Lwt_pqueue.​OrderedType]
concat [Lwt_stream]

concat st returns the concatenation of all streams of st.

connect [Lwt_unix]

Wrapper for Unix.connect

copy [Lwt_bytes]

copy buffer creates a copy of the given byte array.

create [Lwt_timeout]

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

create [Lwt_throttle.​S]
create [Lwt_bytes]

Creates a new byte array of the given size.

create [Lwt_switch]

create () creates a new switch.

create [Lwt_stream]

create () returns a new stream and a push function

create [Lwt_sequence]

create () creates a new empty sequence

create [Lwt_pool]

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

create [Lwt_mvar]

create v creates a new mailbox variable containing value v.

create [Lwt_mutex]

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

create [Lwt_condition]

create () creates a new condition variable.

create_empty [Lwt_mvar]

create () creates a new empty mailbox variable.


D
daemonize [Lwt_daemon]

Put the current running process into daemon mode.

debug [Lwt_log]
debug_f [Lwt_log]
default [Lwt_log]

The default logger.

default_async_method [Lwt_unix]

Returns the default async method.

default_buffer_size [Lwt_io]

Return the default size for buffers.

delay [Lwt_signal]
delay [Lwt_react.​E]

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

delay [Lwt_event]
detach [Lwt_preemptive]

detaches a computation to a preemptive thread.

diff_s [Lwt_signal]
diff_s [Lwt_react.​S]
diff_s [Lwt_react.​E]
diff_s [Lwt_event]
direct_access [Lwt_io]

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

disable [Lwt_signal]
disable [Lwt_event]
disable_signal_handler [Lwt_unix]

Stops receiving this signal

dispatch [Lwt_log]

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

dup [Lwt_unix]

Wrapper for Unix.dup

dup2 [Lwt_unix]

Wrapper for Unix.dup2


E
embed_socket [Lwt_ssl]
empty [Lwt_pqueue.​S]
enter_iter_hooks [Lwt_main]

Functions that are called before the main iteration.

eprint [Lwt_io]
eprintf [Lwt_io]
eprintl [Lwt_io]
eprintlf [Lwt_io]
error [Lwt_log]
error_f [Lwt_log]
establish_server [Lwt_io]

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

exec [Lwt_process]

Executes the given command and returns its exit status.

execute_job [Lwt_unix]

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

exists_p [Lwt_list]
exists_s [Lwt_list]
exit_hooks [Lwt_main]

Sets of functions executed just before the program exit.

extract [Lwt_bytes]

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


F
fail [Lwt]

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

fake_event [Lwt_engine]

Event which does nothing when stopped.

fake_io [Lwt_engine]

Simulates activity on the given file descriptor.

fatal [Lwt_log]
fatal_f [Lwt_log]
fchmod [Lwt_unix]

Wrapper for Unix.fchmod

fchown [Lwt_unix]

Wrapper for Unix.fchown

fdatasync [Lwt_unix]

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

file [Lwt_log]

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

file_length [Lwt_io]

Returns the length of a file

files_of_directory [Lwt_unix]

files_of_directory dir returns the stream of all files of dir.

fill [Lwt_bytes]

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

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_p [Lwt_react.​E]
filter_p [Lwt_event]
filter_p [Lwt_list]
filter_s [Lwt_signal]
filter_s [Lwt_react.​S]
filter_s [Lwt_react.​E]
filter_s [Lwt_event]
filter_s [Lwt_stream]

filter f st keeps only value x such that f x is true

filter_s [Lwt_list]
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_min [Lwt_pqueue.​S]
find_s [Lwt_stream]

find f s find an element in a stream.

find_s [Lwt_list]
flatten [Lwt_stream]

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

flush [Lwt_io]

flush oc performs all pending writes on oc

flush [Lwt_chan]
flush_all [Lwt_io]

flush_all () flushes all open output channels

fmap_p [Lwt_react.​E]
fmap_p [Lwt_event]
fmap_s [Lwt_signal]
fmap_s [Lwt_react.​S]
fmap_s [Lwt_react.​E]
fmap_s [Lwt_event]
fold [Lwt_stream]
fold_l [Lwt_sequence]

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_left [Lwt_util]

Similar to List.fold_left.

fold_left_s [Lwt_list]
fold_r [Lwt_sequence]

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_right_s [Lwt_list]
fold_s [Lwt_signal]
fold_s [Lwt_react.​S]
fold_s [Lwt_react.​E]
fold_s [Lwt_event]
fold_s [Lwt_stream]

fold f s x fold_like function for streams.

for_all_p [Lwt_list]
for_all_s [Lwt_list]
fork [Lwt_unix]

fork () does the same as Unix.fork.

fprint [Lwt_io]
fprintf [Lwt_io]
fprintl [Lwt_io]
fprintlf [Lwt_io]
from [Lwt_react.​E]

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

from [Lwt_event]
from [Lwt_stream]

from f creates an stream from the given input function.

fstat [Lwt_unix.​LargeFile]

Wrapper for Unix.LargeFile.fstat

fstat [Lwt_unix]

Wrapper for Unix.fstat

fsync [Lwt_unix]

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

ftruncate [Lwt_unix.​LargeFile]

Wrapper for Unix.LargeFile.ftruncate

ftruncate [Lwt_unix]

Wrapper for Unix.ftruncate


G
get [Lwt_engine]

get () returns the engine currently in use.

get [Lwt_bytes]

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

get [Lwt_stream]

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

get [Lwt_sequence]

Returns the contents of a node

get [Lwt]

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

get_affinity [Lwt_unix]

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

get_available [Lwt_stream]

get_available l returns all available elements of l without blocking

get_available_up_to [Lwt_stream]

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

get_bounds [Lwt_preemptive]

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

get_cpu [Lwt_unix]

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

get_credentials [Lwt_unix]

get_credentials fd returns credential informations from the given socket.

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

Wrapper for Unix.getaddrinfo

getaddrinfo [Lwt_lib]

Cooperative getaddrinfo with cache (using Lwt_preemptive.detach)

getgrgid [Lwt_unix]

Wrapper for Unix.getgrgid

getgrnam [Lwt_unix]

Wrapper for Unix.getgrnam

gethostbyaddr [Lwt_unix]

Wrapper for Unix.gethostbyaddr

gethostbyname [Lwt_unix]

Wrapper for Unix.gethostbyname

gethostbyname [Lwt_lib]

Cooperative gethostbyname with cache (using Lwt_preemptive.detach)

gethostname [Lwt_unix]

Wrapper for Unix.gethostname

getlogin [Lwt_unix]

Wrapper for Unix.getlogin

getnameinfo [Lwt_unix]

Wrapper for Unix.getnameinfo

getnameinfo [Lwt_lib]

Cooperative getnameinfo with cache (using Lwt_preemptive.detach)

getpeername [Lwt_unix]

Wrapper for Unix.getpeername

getpeername [Lwt_ssl]
getprotobyname [Lwt_unix]

Wrapper for Unix.getprotobyname

getprotobynumber [Lwt_unix]

Wrapper for Unix.getprotobynumber

getpwnam [Lwt_unix]

Wrapper for Unix.getpwnam

getpwuid [Lwt_unix]

Wrapper for Unix.getpwuid

getservbyname [Lwt_unix]

Wrapper for Unix.getservbyname

getservbyport [Lwt_unix]

Wrapper for Unix.getservbyport

getsockname [Lwt_unix]

Wrapper for Unix.getsockname

getsockname [Lwt_ssl]
getsockopt [Lwt_unix]

Wrapper for Unix.getsockopt

getsockopt_error [Lwt_unix]

Wrapper for Unix.getsockopt_error

getsockopt_float [Lwt_unix]

Wrapper for Unix.getsockopt_float

getsockopt_int [Lwt_unix]

Wrapper for Unix.getsockopt_int

getsockopt_optint [Lwt_unix]

Wrapper for Unix.getsockopt_optint


H
handle_unix_error [Lwt_unix]

Same as Unix.handle_unix_error but catches lwt-level exceptions

have [Lwt_sys]

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

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_chan]
in_channel_of_descr [Lwt_ssl]
info [Lwt_log]
info_f [Lwt_log]
init [Lwt_preemptive]

init min max log initialises this module.

input [Lwt_io]

input input mode representation

input [Lwt_chan]
input_binary_int [Lwt_chan]
input_char [Lwt_chan]
input_line [Lwt_chan]
input_value [Lwt_chan]
io_vector [Lwt_unix]

Creates an io-vector

io_vector [Lwt_bytes]
is_busy [Lwt_io]

is_busy channel returns whether the given channel is currently busy.

is_empty [Lwt_stream]

is_empty enum returns wether the given stream is empty

is_empty [Lwt_sequence]

Returns true iff the given sequence is empty

is_empty [Lwt_pqueue.​S]
is_empty [Lwt_mutex]

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

is_locked [Lwt_mutex]

locked mutex returns whether mutex is currently locked

is_on [Lwt_switch]

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

is_ssl [Lwt_ssl]

Are we using an SSL socket?

isatty [Lwt_unix]

Wrapper for Unix.isatty

iter [Lwt_engine]

iter block performs one iteration of the main loop.

iter [Lwt_util]

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

iter [Lwt_stream]
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_p [Lwt_list]
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_s [Lwt_list]
iter_serial [Lwt_util]

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


J
join [Lwt]

join l waits 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.


K
keep [Lwt_react.​S]

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

keep [Lwt_react.​E]

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


L
l1_s [Lwt_signal]
l1_s [Lwt_react.​S]
l2_s [Lwt_signal]
l2_s [Lwt_react.​S]
l3_s [Lwt_signal]
l3_s [Lwt_react.​S]
l4_s [Lwt_signal]
l4_s [Lwt_react.​S]
l5_s [Lwt_signal]
l5_s [Lwt_react.​S]
l6_s [Lwt_signal]
l6_s [Lwt_react.​S]
last_new [Lwt_stream]

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

leave_iter_hooks [Lwt_main]

Functions that are called after the main iteration.

length [Lwt_io]

Returns the length of the channel in bytes

length [Lwt_bytes]

Returns the length of the given byte array.

length [Lwt_sequence]

Returns the number of elemenets in the given sequence.

level [Lwt_log.​Section]

level section returns the logging level of section.

limit [Lwt_signal]
limit [Lwt_react.​S]

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

limit [Lwt_react.​E]

limit f e limits the rate of e with f.

limit [Lwt_event]
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

link [Lwt_unix]

Wrapper for Unix.link

listen [Lwt_unix]

Wrapper for Unix.listen

location_key [Lwt_log]

The key for storing current location.

lock [Lwt_mutex]

lock mutex lockcs the mutex, that is:

lockf [Lwt_unix]

Wrapper for Unix.lockf

log [Lwt_log]

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

log_f [Lwt_log]

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

lookup_min [Lwt_pqueue.​S]
lseek [Lwt_unix.​LargeFile]

Wrapper for Unix.LargeFile.lseek

lseek [Lwt_unix]

Wrapper for Unix.lseek

lstat [Lwt_unix.​LargeFile]

Wrapper for Unix.LargeFile.lstat

lstat [Lwt_unix]

Wrapper for Unix.lstat


M
madvise [Lwt_bytes]

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.

main [Lwt_log.​Section]

The main section.

make [Lwt_log.​Section]

make name creates a section with the given name.

make [Lwt_log]

make ~output ~close creates a new logger.

make [Lwt_io]

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

make_in_channel [Lwt_chan]

make_in_channel read creates an input channel from the read function.

make_notification [Lwt_unix]

new_notifier ?once f registers a new notifier.

make_out_channel [Lwt_chan]

make_out_channel write creates an output channel from the write function.

make_region [Lwt_util]

make_region sz create a region of size sz.

map [Lwt_util]

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

map [Lwt_stream]
map [Lwt]

map f m map the result of a thread.

map_file [Lwt_bytes]

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

map_list [Lwt_stream]
map_list_s [Lwt_stream]

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

map_p [Lwt_react.​E]
map_p [Lwt_event]
map_p [Lwt_list]
map_s [Lwt_signal]
map_s [Lwt_react.​S]
map_s [Lwt_react.​E]
map_s [Lwt_event]
map_s [Lwt_stream]

map f st maps the value returned by st with f

map_s [Lwt_list]
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.

mapped [Lwt_bytes]

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

merge_s [Lwt_signal]
merge_s [Lwt_react.​S]
merge_s [Lwt_react.​E]
merge_s [Lwt_event]
mincore [Lwt_bytes]

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

mkdir [Lwt_unix]

Wrapper for Unix.mkdir

mkfifo [Lwt_unix]

Wrapper for Unix.mkfifo

mode [Lwt_io]

mode ch returns the mode of a channel


N
name [Lwt_log.​Section]

name section returns the name of section.

nchoose [Lwt]

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

nchoose_split [Lwt]

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

new_key [Lwt]

new_key () creates a new key.

next [Lwt_react.​E]

next e returns the next occurrence of e

next [Lwt_event]
next [Lwt_stream]

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

notice [Lwt_log]
notice_f [Lwt_log]
notify [Lwt_signal]
notify [Lwt_event]
notify_p [Lwt_signal]
notify_p [Lwt_event]
notify_s [Lwt_signal]
notify_s [Lwt_event]
npeek [Lwt_stream]

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

npick [Lwt]

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

null [Lwt_log]

Logger which drops everything

null [Lwt_io]

Output which drops everything


O
of_array [Lwt_stream]

of_array a creates a stream returning all elements of a

of_bytes [Lwt_io]

Create a channel from a byte array.

of_fd [Lwt_io]

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

of_list [Lwt_stream]

of_list l creates a stream returning all elements of l

of_stream [Lwt_react.​E]

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

of_stream [Lwt_event]
of_string [Lwt_bytes]

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

of_string [Lwt_stream]

of_string str creates a stream returning all characters of str

of_unix_fd [Lwt_io]

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

of_unix_file_descr [Lwt_unix]

Creates a lwt file descriptor from a unix one.

on_cancel [Lwt]

on_cancel t f executes f when t is canceled.

on_failure [Lwt]

on_failure t f executes f when t terminates and fails.

on_readable [Lwt_engine]

on_readable fd f calls f each time fd becomes readable.

on_signal [Lwt_unix]

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

on_success [Lwt]

on_success t f executes f when t terminates without failing.

on_termination [Lwt]

on_termination t f executes f when t terminates.

on_timer [Lwt_engine]

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

on_writable [Lwt_engine]

on_readable fd f calls f each time fd becomes writable.

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_connection [Lwt_chan]
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_in [Lwt_chan]
open_in_gen [Lwt_chan]
open_out [Lwt_chan]
open_out_gen [Lwt_chan]
open_process [Lwt_process]
open_process_full [Lwt_process]
open_process_in [Lwt_process]
open_process_none [Lwt_process]
open_process_out [Lwt_process]
opendir [Lwt_unix]

Wrapper for Unix.opendir

openfile [Lwt_unix]

Wrapper for Unix.openfile.

out_channel_of_descr [Lwt_chan]
out_channel_of_descr [Lwt_ssl]
output [Lwt_io]

output output mode representation

output [Lwt_chan]
output_binary_int [Lwt_chan]
output_char [Lwt_chan]
output_string [Lwt_chan]
output_value [Lwt_chan]

P
page_size [Lwt_bytes]

Size of pages.

parse [Lwt_stream]

parse st f parses st with f.

partition_p [Lwt_list]
partition_s [Lwt_list]
pause [Lwt]

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

paused_count [Lwt]

paused_count () returns the number of thread currently paused.

peek [Lwt_stream]

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

pick [Lwt]

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

pipe [Lwt_unix]

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

pipe [Lwt_io]

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

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]
pool_size [Lwt_unix]

Maximum number of system threads that can be started.

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]
protected [Lwt]

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

proxy [Lwt_bytes]

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

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

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

read [Lwt_io]

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

read [Lwt_bytes]
read [Lwt_ssl]
read_bytes [Lwt_ssl]
read_char [Lwt_io]

read_char ic reads the next character of ic.

read_char_opt [Lwt_io]

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

readable [Lwt_unix]

Returns whether the given file descriptor is currently readable.

readable_count [Lwt_engine]

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

readdir [Lwt_unix]

Wrapper for Unix.dir

readdir_n [Lwt_unix]

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

readlink [Lwt_unix]

Wrapper for Unix.readlink

really_input [Lwt_chan]
recv [Lwt_unix]

Wrapper for Unix.recv

recv [Lwt_bytes]
recv_msg [Lwt_unix]

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

recv_msg [Lwt_bytes]

This call is not available on windows.

recvfrom [Lwt_unix]

Wrapper for Unix.recvfrom

recvfrom [Lwt_bytes]
register_action [Lwt_unix]

register_action set fd action registers action on fd.

register_pause_notifier [Lwt]

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

reinstall_signal_handler [Lwt_unix]

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 [Lwt_sequence]

Removes a node from the sequence it is part of.

remove_min [Lwt_pqueue.​S]
rename [Lwt_unix]

Wrapper for Unix.rename

render [Lwt_log]

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

reset_level [Lwt_log.​Section]

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

resize_buffer [Lwt_io]

Resize the internal buffer to the given size

resize_region [Lwt_util]

resize_region reg sz resize the region reg to size sz.

return [Lwt_signal]
return [Lwt_react.​S]

Same as const.

return [Lwt]

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

rev_map_p [Lwt_list]
rev_map_s [Lwt_list]
rewinddir [Lwt_unix]

Wrapper for Unix.rewinddir

rmdir [Lwt_unix]

Wrapper for Unix.rmdir

rules [Lwt_log_rules]

parse lexbuf returns the list of rules contained in lexbuf

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.

run_p [Lwt_react.​E]
run_p [Lwt_event]
run_s [Lwt_signal]
run_s [Lwt_react.​S]
run_s [Lwt_react.​E]
run_s [Lwt_event]

S
sample_s [Lwt_signal]
sample_s [Lwt_react.​S]
send [Lwt_unix]

Wrapper for Unix.send

send [Lwt_bytes]
send_msg [Lwt_unix]

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

send_msg [Lwt_bytes]

This call is not available on windows.

send_notification [Lwt_unix]

send_notification id sends a notification.

sendto [Lwt_unix]

Wrapper for Unix.sendto

sendto [Lwt_bytes]
set [Lwt_engine]

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

set [Lwt_bytes]

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

set [Lwt_sequence]

Change the contents of a node

set_affinity [Lwt_unix]

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

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_async_method [Lwt_unix]

Sets the default async method.

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_level [Lwt_log.​Section]

set_level section sets the logging level of the given section.

set_max_number_of_threads_queued [Lwt_preemptive]

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

set_notification [Lwt_unix]

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

set_pool_size [Lwt_unix]

Change the size of the pool.

set_position [Lwt_io]

set_position ch pos Sets the position in the output channel.

setsockopt [Lwt_unix]

Wrapper for Unix.setsockopt

setsockopt_float [Lwt_unix]

Wrapper for Unix.setsockopt_float

setsockopt_int [Lwt_unix]

Wrapper for Unix.setsockopt_int

setsockopt_optint [Lwt_unix]

Wrapper for Unix.setsockopt_optint

shell [Lwt_process]

A command executed with "/bin/sh"

shutdown [Lwt_unix]

Wrapper for Unix.shutdown

shutdown [Lwt_ssl]
shutdown_server [Lwt_io]

Shutdown the given server

signal [Lwt_condition]

signal condvar value notifies that a condition is ready.

signal_count [Lwt_unix]

Returns the number of registered signal handler.

simple_init [Lwt_preemptive]

simple_init () does a simple initialization.

size [Lwt_pqueue.​S]
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.

stat [Lwt_unix.​LargeFile]

Wrapper for Unix.LargeFile.stat

stat [Lwt_unix]

Wrapper for Unix.stat

state [Lwt_unix]

state fd returns the state of fd

state [Lwt]

state t returns the state of a thread

stderr [Lwt_unix]

The standard file descriptor for printing error messages

stderr [Lwt_io]

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

stdin [Lwt_unix]

The standard file descriptor for input.

stdin [Lwt_io]

The standard input, it reads data from Lwt_unix.​stdin

stdout [Lwt_unix]

The standard file descriptor for output

stdout [Lwt_io]

The standard output, it writes data to Lwt_unix.​stdout

stop [Lwt_timeout]

stops a timeout.

stop_event [Lwt_engine]

stop_event event stops the given event.

stop_notification [Lwt_unix]

Stop the given notification.

symlink [Lwt_unix]

Wrapper for Unix.symlink

syslog [Lwt_log]

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

system [Lwt_unix]

Wrapper for Unix.system

system_byte_order [Lwt_io]

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 () is the same as wait () except that threads created with task can be canceled.

tcdrain [Lwt_unix]

Wrapper for Unix.tcdrain

tcflow [Lwt_unix]

Wrapper for Unix.tcflow

tcflush [Lwt_unix]

Wrapper for Unix.tcflush

tcgetattr [Lwt_unix]

Wrapper for Unix.tcgetattr

tcsendbreak [Lwt_unix]

Wrapper for Unix.tcsendbreak

tcsetattr [Lwt_unix]

Wrapper for Unix.tcsetattr

thread_count [Lwt_unix]

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

thread_waiting_count [Lwt_unix]

The number threads waiting for a job.

timeout [Lwt_unix]

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

timer_count [Lwt_engine]

Returns the number of registered timers.

to_list [Lwt_stream]

Returns the list of elements of the given stream

to_stream [Lwt_react.​E]

Creates a stream holding all values occurring on the given event

to_stream [Lwt_event]
to_string [Lwt_bytes]

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

to_string [Lwt_stream]

Returns the word composed of all characters of the given 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.

truncate [Lwt_unix.​LargeFile]

Wrapper for Unix.LargeFile.truncate

truncate [Lwt_unix]

Wrapper for Unix.truncate

try_bind [Lwt]

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

turn_off [Lwt_switch]

turn_off switch turns off the switch.


U
union [Lwt_pqueue.​S]
unix_file_descr [Lwt_unix]

Returns the underlying unix file descriptor.

unlink [Lwt_unix]

Wrapper for Unix.unlink

unlock [Lwt_mutex]

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

unsafe_blit [Lwt_bytes]

Same as Lwt_bytes.​blit but without bound checking.

unsafe_blit_bytes_string [Lwt_bytes]

Same as Lwt_bytes.​blit_bytes_string but without bound checking.

unsafe_blit_string_bytes [Lwt_bytes]

Same as Lwt_bytes.​blit_string_bytes but without bound checking.

unsafe_fill [Lwt_bytes]

Same as Lwt_bytes.​fill but without bound checking.

unsafe_get [Lwt_bytes]

Same as Lwt_bytes.​get but without bound checking.

unsafe_set [Lwt_bytes]

Same as Lwt_bytes.​set but without bound checking.

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]

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 [Lwt_condition]

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

wait4 [Lwt_unix]

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.

wait_count [Lwt_unix]

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

wait_for_jobs [Lwt_unix]

Wait for all pending jobs to terminate.

wait_mincore [Lwt_bytes]

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

wait_read [Lwt_unix]

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

wait_read [Lwt_ssl]
wait_write [Lwt_unix]

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

wait_write [Lwt_ssl]
waiter_of_wakener [Lwt]

Returns the thread associated to a wakener.

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.

wakeup_later [Lwt]

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

wakeup_later_exn [Lwt]

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

wakeup_paused [Lwt]

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

warning [Lwt_log]
warning_f [Lwt_log]
windows [Lwt_sys]

true iff running on windows.

with_async_detach [Lwt_unix]

with_async_none f is a shorthand for:

with_async_none [Lwt_unix]

with_async_none f is a shorthand for:

with_async_switch [Lwt_unix]

with_async_none f is a shorthand for:

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_finaliser [Lwt_signal]
with_finaliser [Lwt_react.​S]

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

with_finaliser [Lwt_react.​E]

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

with_finaliser [Lwt_event]
with_lock [Lwt_mutex]

with_lock lock f is used to lock a mutex 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:

with_value [Lwt]

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

wrap [Lwt]

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

wrap1 [Lwt]

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

wrap2 [Lwt]
wrap3 [Lwt]
wrap4 [Lwt]
wrap5 [Lwt]
wrap6 [Lwt]
wrap7 [Lwt]
wrap_syscall [Lwt_unix]

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

writable [Lwt_unix]

Returns whether the given file descriptor is currently writable.

writable_count [Lwt_engine]

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

write [Lwt_unix]

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

write [Lwt_io]

write oc str writes all characters of str on oc

write [Lwt_bytes]
write [Lwt_ssl]
write_bytes [Lwt_ssl]
write_char [Lwt_io]

write_char oc char writes char on oc

write_chars [Lwt_io]

write_chars oc chars writes all characters of 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.

yield [Lwt_main]

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'