Warning: Reason support is experimental. We are looking for beta-tester and contributors.

Index of values


(<&>) [Lwt.Infix]

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

(<&>) [Lwt]

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

(<?>) [Lwt.Infix]

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

(<?>) [Lwt]

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

Error a_api: exception Dune__exe__Api.Error("\"(>>=)>>~[<<a_api|moduleLwt_result\" is not a valid module name")=) >> [Lwt.Infix]

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

(>>=)=) >> [Lwt]

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

(>|=) [Lwt_result.Infix]
(>|=) [Lwt.Infix]

m >|= f is map f m

(>|=) [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 immediately.

abort [Lwt_ssl]
abort_jobs [Lwt_unix]

abort_jobs exn make all pending jobs to fail with exn.

accept [Lwt_unix]

Wrapper for Unix.accept

accept_n [Lwt_unix]

accept_n fd count accepts up to count connections at one time.

access [Lwt_unix]

Wrapper for Unix.access

accum_s [Lwt_react.S]
accum_s [Lwt_react.E]
add [Lwt_pqueue.S]

add e q evaluates to a new priority queue, which contains all the elements of q, and the additional element e.

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, f is called immediately.

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

add_rule pattern level adds a rule for sections logging levels.

add_task_l [Lwt]

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

add_task_r [Lwt]

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

app_p [Lwt_react.E]
app_s [Lwt_react.S]
app_s [Lwt_react.E]
append [Lwt_stream]

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

append_bigarray [Lwt_unix.IO_vectors]

append_bigarray vs buffer offset length appends a slice of the Bigarray buffer buffer beginning at offset and with length length to the I/O vector sequence vs.

append_bytes [Lwt_unix.IO_vectors]

append_bytes vs buffer offset length appends a slice of the bytes buffer buffer beginning at offset and with length length to the I/O vector sequence vs.

append_rule [Lwt_log_core]

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

async [Lwt]

async f starts a thread without waiting for the result.

async_exception_hook [Lwt]

Function called when a asynchronous exception is thrown.

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 that will yield every timeout seconds.


B
bind [Lwt_unix]

Binds an address to the given socket.

bind [Lwt_react.S]

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

bind [Lwt_result]
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_1 [Lwt_unix.Versioned]

Old version of Lwt_unix.bind.

bind_2 [Lwt_unix.Versioned]

Since Lwt 3.0.0, this is just an alias for Lwt_unix.bind.

bind_lwt [Lwt_result]
bind_lwt_err [Lwt_result]
bind_result [Lwt_result]
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 copies len bytes from buf1 starting at offset ofs1 to buf2 starting at offset ofs2.

blit_from_bytes [Lwt_bytes]

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

blit_to_bytes [Lwt_bytes]

Same as Lwt_bytes.blit but the second 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 indicates whether Lwt is internally using blocking or non-blocking I/O with fd.

broadcast [Lwt_log_core]

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

broadcast [Lwt_condition]

broadcast condvar value notifies all waiting threads.

broadcast_exn [Lwt_condition]

broadcast_exn condvar exn fails all waiting threads with exception exn.

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

Call the handler associated to the given notification.

cancel [Lwt]

cancel t cancels the threads t.

cancel_jobs [Lwt_unix]

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

catch [Lwt_result]

catch x behaves like return y if x evaluates to y, and like fail e if x raises e

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

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

choose [Lwt_stream]

choose l creates an stream from a list of streams.

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

close ch closes the given channel.

close [Lwt_ssl]
close [Lwt_log_core]

Close the given logger

close_in [Lwt_chan]
close_out [Lwt_chan]
closed [Lwt_stream]

closed st returns a thread that will sleep until the stream has been closed.

closedir [Lwt_unix]

Closes a directory handle.

combine [Lwt_stream]

combine s1 s2 combines 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_unix.IO_vectors]

Creates an empty I/O vector sequence.

create [Lwt_bytes]

Creates a new byte array of the given size.

create [Lwt_throttle.S]
create [Lwt_timeout]

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

create [Lwt_pool]

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

create [Lwt_condition]

create () creates a new condition variable.

create [Lwt_mutex]

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

create [Lwt_switch]

create () creates a new switch.

create [Lwt_sequence]

create () creates a new empty sequence

create [Lwt_mvar]

create v creates a new mailbox variable containing value v.

create [Lwt_stream]

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

create_bounded [Lwt_stream]

create_bounded size returns a new stream and a bounded push source.

create_empty [Lwt_mvar]

create () creates a new empty mailbox variable.

create_with_reference [Lwt_stream]

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


D
daemonize [Lwt_daemon]

Put the current running process into daemon mode.

debug [Lwt_log_core]
debug_f [Lwt_log_core]
default [Lwt_engine.Ev_backend]
default [Lwt_log_core]

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_react.E]

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

detach [Lwt_preemptive]

detach f x runs the computation f x in a separate preemptive thread.

devpoll [Lwt_engine.Ev_backend]
diff_s [Lwt_react.S]
diff_s [Lwt_react.E]
direct_access [Lwt_io]

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

disable_signal_handler [Lwt_unix]

Stops receiving this signal

dispatch [Lwt_log_core]

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

drop [Lwt_unix.IO_vectors]

drop vs n adjusts the I/O vector sequence vs so that it no longer includes its first n bytes.

dup [Lwt_unix]

Wrapper for Unix.dup

dup2 [Lwt_unix]

Wrapper for Unix.dup2


E
embed_socket [Lwt_ssl]
embed_uninitialized_socket [Lwt_ssl]
empty [Lwt_pqueue.S]

The empty priority queue.

enter_iter_hooks [Lwt_main]

Functions that are called before the main iteration.

epoll [Lwt_engine.Ev_backend]
eprint [Lwt_io]
eprintf [Lwt_io]
eprintl [Lwt_io]
eprintlf [Lwt_io]
error [Lwt_log_core]
error_f [Lwt_log_core]
establish_server [Lwt_io]

Like establish_server_with_client_address, but does not pass the client address to the callback f.

establish_server_1 [Lwt_io.Versioned]

Old version of Lwt_io.establish_server.

establish_server_2 [Lwt_io.Versioned]

Since Lwt 3.0.0, this is just an alias for Lwt_io.establish_server.

establish_server_with_client_address [Lwt_io]

establish_server_with_client_address listen_address f creates a server which listens for incoming connections on listen_address.

exec [Lwt_process]

Executes the given command and returns its exit status.

execute_job [Lwt_unix]

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_result]
fail [Lwt]

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

fail_invalid_arg [Lwt]

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

fail_with [Lwt]

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

fake_event [Lwt_engine]

Event which does nothing when stopped.

fake_io [Lwt_engine]

Simulates activity on the given file descriptor.

fatal [Lwt_log_core]
fatal_f [Lwt_log_core]
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_exists [Lwt_unix.LargeFile]

file_exists name tests if a file named name exists.

file_exists [Lwt_unix]

file_exists name tests if a file named name exists.

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_p [Lwt_list]
filter_map_s [Lwt_list]
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_list]
filter_s [Lwt_react.S]
filter_s [Lwt_react.E]
filter_s [Lwt_list]
filter_s [Lwt_stream]

filter f st keeps only values, x, such that f x is true

finalise [Lwt_gc]

finalise f x ensures f x is evaluated after x has been 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 exits.

finalize [Lwt]

finalize f g runs f (), and then g (), whether f () fails or completes normally.

find [Lwt_stream]
find_map [Lwt_stream]
find_map_s [Lwt_stream]

find_map f s find and map at the same time.

find_min [Lwt_pqueue.S]

find_min q evaluates to the minimum element of q if it is not empty, and raises Not_found otherwise.

find_node_l [Lwt_sequence]

find_node_l f s returns the first node of s starting from the left that satisfies f or raises Not_found if none exists.

find_node_opt_l [Lwt_sequence]

find_node_opt_l f s returns Some x, where x is the first node of s starting from the left that satisfies f or None if none exists.

find_node_opt_r [Lwt_sequence]

find_node_opt_r f s returns Some x, where x is the first node of s starting from the right that satisfies f or None if none exists.

find_node_r [Lwt_sequence]

find_node_r f s returns the first node of s starting from the right that satisfies f or raises Not_found if none exists.

find_s [Lwt_list]
find_s [Lwt_stream]

find f s find an element in a stream.

flatten [Lwt_stream]

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

flush [Lwt_chan]
flush [Lwt_io]

flush oc performs all pending writes on oc

flush_all [Lwt_io]

flush_all () flushes all open output channels

fmap_p [Lwt_react.E]
fmap_s [Lwt_react.S]
fmap_s [Lwt_react.E]
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_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_react.S]
fold_s [Lwt_react.E]
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 time f () returns a value.

from [Lwt_stream]

from f creates a stream from the given input function.

from_direct [Lwt_stream]

from_direct f does the same as Lwt_stream.from but with a function that does not return a thread.

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

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

get [Lwt_engine]

get () returns the engine currently in use.

get [Lwt_sequence]

Returns the contents of a node

get [Lwt]

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

get [Lwt_stream]

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

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

get_available_up_to [Lwt_stream]

get_available_up_to n st 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 credentials information from the given socket.

get_exn [Lwt_result]

get_exn is the opposite of Lwt_result.catch: it unwraps the result type, returning the value in case of success, calls Lwt.fail in case of error.

get_fd [Lwt_ssl]
get_max_number_of_threads_queued [Lwt_preemptive]

Returns the size of the waiting queue, if no more threads are available

get_unix_fd [Lwt_ssl]
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

getcwd [Lwt_unix]

Wrapper for Unix.getcwd

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

gethostname [Lwt_unix]

Wrapper for Unix.gethostname

getlogin [Lwt_unix]

Wrapper for Unix.getlogin

getnameinfo [Lwt_unix]

Wrapper for Unix.getnameinfo

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
ign_debug [Lwt_log_core]
ign_debug_f [Lwt_log_core]
ign_error [Lwt_log_core]
ign_error_f [Lwt_log_core]
ign_fatal [Lwt_log_core]
ign_fatal_f [Lwt_log_core]
ign_info [Lwt_log_core]
ign_info_f [Lwt_log_core]
ign_log [Lwt_log_core]

Same as Lwt_log_core.log but ignore the resulting thread.

ign_log_f [Lwt_log_core]

Same as Lwt_log_core.log_f but ignore the resulting thread.

ign_notice [Lwt_log_core]
ign_notice_f [Lwt_log_core]
ign_warning [Lwt_log_core]
ign_warning_f [Lwt_log_core]
ignore_result [Lwt]

ignore_result t behaves as follows:

in_channel_of_descr [Lwt_chan]
in_channel_of_descr [Lwt_ssl]
info [Lwt_log_core]
info_f [Lwt_log_core]
init [Lwt_preemptive]

init min max log initialises this module.

input [Lwt_chan]
input [Lwt_io]

input input mode representation

input_binary_int [Lwt_chan]
input_char [Lwt_chan]
input_line [Lwt_chan]
input_value [Lwt_chan]
install [Lwt_glib]

Install the Glib<->Lwt integration.

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_closed [Lwt_stream]

is_closed st returns whether the given stream has been closed.

is_empty [Lwt_unix.IO_vectors]

is_empty vs is true if and only if vs has no I/O vectors, or all I/O vectors in vs have zero bytes.

is_empty [Lwt_pqueue.S]

is_empty q evaluates to true iff q is empty.

is_empty [Lwt_mutex]

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

is_empty [Lwt_sequence]

Returns true iff the given sequence is empty

is_empty [Lwt_stream]

is_empty st returns whether the given stream is empty.

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

is_sleeping t returns true iff t is sleeping.

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

This function is not related to Lwt.

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_list]
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_list]
iter_s [Lwt_stream]

iter f s iterates over all elements of the stream.

iteri_p [Lwt_list]
iteri_s [Lwt_list]

J
join [Lwt]

join l waits for all threads in l to terminate.

junk [Lwt_stream]

junk st removes the first element of st.

junk_old [Lwt_stream]

junk_old st removes all elements that are ready to be read without yielding 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.

kqueue [Lwt_engine.Ev_backend]

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

last_new st returns the last element that can be obtained without sleeping, or wait for one if none is available.

leave_iter_hooks [Lwt_main]

Functions that are called after the main iteration.

length [Lwt_bytes]

Returns the length of the given byte array.

length [Lwt_io]

Returns the length of the channel in bytes

length [Lwt_sequence]

Returns the number of elemenets in the given sequence.

level [Lwt_log_core.Section]

level section returns the logging level of section.

level_of_string [Lwt_log_core]
lift [Lwt_result]
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.

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 file with name name.

link [Lwt_unix]

Wrapper for Unix.link

listen [Lwt_unix]

Wrapper for Unix.listen

load_rules [Lwt_log_core]

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

location_key [Lwt_log_core]

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

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

log_f [Lwt_log_core]

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

lookup_min [Lwt_pqueue.S]

lookup_min q evaluates to Some e, where e is the minimum element of q, if q is not empty, and evaluates to None otherwise.

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 advises the kernel how the program will use the memory mapped file between pos and pos + len.

main [Lwt_log_core.Section]

The main section.

make [Lwt_io]

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

make [Lwt_log_core.Section]

make name creates a section with the given name.

make [Lwt_log_core]

make ~output ~close creates a new logger.

make_error [Lwt]

error e creates a result containing the exception e.

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

value x creates a result containing the value x.

map [Lwt_result]
map [Lwt]

map f m maps the result of a thread.

map [Lwt_stream]
map_err [Lwt_result]
map_exn [Lwt_stream]

map_exn s returns a stream that captures all exceptions raised by the source of the stream (the function passed to Lwt_stream.from).

map_file [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_list]
map_s [Lwt_react.S]
map_s [Lwt_react.E]
map_s [Lwt_list]
map_s [Lwt_stream]

map f st maps the value returned by st with f

mapi_p [Lwt_list]
mapi_s [Lwt_list]
mapped [Lwt_bytes]

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

mapper [Ppx_lwt]
mcast_add_membership [Lwt_unix]

mcast_add_membership fd ~ifname addr joins the multicast group addr on the network interface ifname.

mcast_drop_membership [Lwt_unix]

mcast_drop_membership fd ~ifname addr leaves the multicast group addr on the network interface ifname.

mcast_set_loop [Lwt_unix]

Whether sent multicast messages are received by the sending host

mcast_set_ttl [Lwt_unix]

Set TTL/hops value

merge_s [Lwt_react.S]
merge_s [Lwt_react.E]
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_core.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_stream]

next st removes and returns the next element of the stream or fails with Lwt_stream.Empty, if the stream is empty.

nget [Lwt_stream]

nget n st removes 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.

no_cancel [Lwt]

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

notice [Lwt_log_core]
notice_f [Lwt_log_core]
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_io]

Output which drops everything

null [Lwt_log_core]

Logger which drops everything


O
of_array [Lwt_stream]

of_array a creates a stream returning all elements of a.

of_bytes [Lwt_bytes]

of_bytes buf returns a newly allocated byte array with the same contents as buf.

of_bytes [Lwt_io]

Create a channel from a byte array.

of_fd [Lwt_io]

of_fd ?buffer ?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_result [Lwt]

Returns a thread from a result.

of_stream [Lwt_react.E]

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

of_string [Lwt_bytes]

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

of_string [Lwt_stream]

of_string str creates a stream returning all characters of str.

of_unix_fd [Lwt_io]

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

of_unix_file_descr [Lwt_unix]

Wraps a Unix file descriptor fd in an Lwt_unix.file_descr fd'.

ok [Lwt_result]
on_any [Lwt]

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

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

on_signal_full f is the same as on_signal f except that f also receive the signal handler identifier as argument so it can disable it.

on_success [Lwt]

on_success t f executes f when t terminates without failing.

on_terminate [Lwt_stream]
on_termination [Lwt]

on_termination t f executes f when t terminates.

on_termination [Lwt_stream]

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

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_chan]
open_connection [Lwt_io]

open_connection ?fd ?in_buffer ?out_buffer addr opens a connection to the given address and returns two channels for using it.

open_file [Lwt_io]

open_file ?buffer ?flags ?perm ~mode filename opens 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]

Opens a directory for listing.

openfile [Lwt_unix]

Wrapper for Unix.openfile.

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

output output mode representation

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 currently paused threads.

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 ?in_buffer ?out_buffer () 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]
poll [Lwt_engine.Ev_backend]
pool_size [Lwt_unix]

Maximum number of system threads that can be started.

port [Lwt_engine.Ev_backend]
position [Lwt_io]

position ch Returns the current position in the channel.

pp [Lwt_engine.Ev_backend]
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 reads up to len bytes from fd, and writes them to buf, starting at offset ofs.

read [Lwt_bytes]
read [Lwt_io]

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

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 raise 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 channel reads a marshaled value from channel; it corresponds to the standard library's Marshal.from_channel.

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]

Reads the next directory entry from the given directory.

readdir_n [Lwt_unix]

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

readlink [Lwt_unix]

Wrapper for Unix.readlink

readv [Lwt_unix]

readv fd vs reads bytes from fd into the buffer slices vs.

really_input [Lwt_chan]
recv [Lwt_unix]

Wrapper for Unix.recv.

recv [Lwt_bytes]

Not implemented on Windows.

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

recv_msg [Lwt_bytes]

Not implemented on Windows.

recvfrom [Lwt_unix]

Wrapper for Unix.recvfrom.

recvfrom [Lwt_bytes]

Not implemented on Windows.

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

Remove the Glib<->Lwt integration.

remove [Lwt_sequence]

Removes a node from the sequence it is part of.

remove_min [Lwt_pqueue.S]

remove_min q evaluates to a new priority queue, which contains all the elements of q except for its minimum element.

rename [Lwt_unix]

Wrapper for Unix.rename

render [Lwt_log]

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

render [Lwt_log_core]

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

reset_level [Lwt_log_core.Section]

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

reset_rules [Lwt_log_core]

removes all rules.

resize_buffer [Lwt_io]

Resize the internal buffer to the given size

return [Lwt_react.S]

Same as const.

return [Lwt_result]
return [Lwt]

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

return_error [Lwt]

return_error x is equivalent to return (Error x).

return_false [Lwt]

return_false = return false

return_nil [Lwt]

return_nil = return []

return_none [Lwt]

return_none = return None

return_ok [Lwt]

return_ok x is equivalent to return (Ok x).

return_some [Lwt]

return_some x = return (Some x)

return_true [Lwt]

return_true = return true

return_unit [Lwt]

return_unit = return ()

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

Resets the given directory handle, so that directory listing can be restarted.

rmdir [Lwt_unix]

Wrapper for Unix.rmdir

rules [Lwt_log_rules]

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

run [Lwt_main]

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

run_in_main [Lwt_preemptive]

run_in_main f can be called from a detached computation to execute f () in the main preemptive thread, i.e.

run_job [Lwt_unix]

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

run_p [Lwt_react.E]
run_s [Lwt_react.S]
run_s [Lwt_react.E]

S
sample_s [Lwt_react.S]
select [Lwt_engine.Ev_backend]
send [Lwt_unix]

Wrapper for Unix.send.

send [Lwt_bytes]

Not implemented on Windows.

send_msg [Lwt_unix]

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

send_msg [Lwt_bytes]

Not implemented on Windows.

send_notification [Lwt_unix]

send_notification id sends a notification.

sendto [Lwt_unix]

Wrapper for Unix.sendto.

sendto [Lwt_bytes]

Not implemented on Windows.

set [Lwt_bytes]

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

set [Lwt_engine]

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

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 causes Lwt to internally use blocking or non-blocking I/O with fd, according to the value of b.

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_core.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 the shell.

shutdown [Lwt_unix]

Wrapper for Unix.shutdown

shutdown [Lwt_ssl]
shutdown_server [Lwt_io]

Closes the given server's listening socket.

shutdown_server_1 [Lwt_io.Versioned]

Old version of Lwt_io.shutdown_server.

shutdown_server_2 [Lwt_io.Versioned]

Since Lwt 3.0.0, this is just an alias for Lwt_io.shutdown_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]

size q evaluates to the number of elements in q.

sleep [Lwt_unix]

sleep d is a thread that remains 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_accept_handshake [Lwt_ssl]

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

ssl_connect [Lwt_ssl]
ssl_perform_handshake [Lwt_ssl]

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

ssl_shutdown [Lwt_ssl]
ssl_socket [Lwt_ssl]

Returns the underlying SSL socket used for this wrapper.

ssl_socket_of_uninitialized_socket [Lwt_ssl]

Returns the underlying SSL socket used for this wrapper.

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.

string_of_level [Lwt_log_core]
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]

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

system_byte_order [Lwt_io]
system_limit [Lwt_unix.IO_vectors]

Some systems limit the number of I/O vectors that can be passed in a single call to their writev or readv system calls.


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 thread that remains suspended for d seconds and then fails with Lwt_unix.Timeout.

timer_count [Lwt_engine]

Returns the number of registered timers.

to_bytes [Lwt_bytes]

to_bytes buf returns newly allocated bytes with the same contents as buf.

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

union q q' evaluates to a new priority queue, which contains all the elements of both q and q'.

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_from_bytes [Lwt_bytes]

Same as blit_string_bytes but without bounds checking.

unsafe_blit_to_bytes [Lwt_bytes]

Same as blit_bytes_string but without bounds checking.

unsafe_fill [Lwt_bytes]

Same as Lwt_bytes.fill but without bounds checking.

unsafe_get [Lwt_bytes]

Same as Lwt_bytes.get but without bounds checking.

unsafe_set [Lwt_bytes]

Same as Lwt_bytes.set but without bounds checking.

use [Lwt_pool]

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

utimes [Lwt_unix]

utimes path atime mtime updates the access and modification times of the file at path.


W
wait [Lwt_unix]

Wrapper for Unix.wait

wait [Lwt_throttle.S]
wait [Lwt_condition]

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

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 is in 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_glib]

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

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 woken up immediately.

wakeup_later_exn [Lwt]

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

wakeup_later_result [Lwt]

Same as Lwt.wakeup_result but it is not guaranteed that the thread will be woken up immediately.

wakeup_paused [Lwt]

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

wakeup_result [Lwt]

wakeup_result t r makes the sleeping thread t terminate with the result r.

warning [Lwt_log_core]
warning_f [Lwt_log_core]
windows [Lwt_sys]

with_async_detach [Lwt_unix]

with_async_detach 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_switch f is a shorthand for:

with_connection [Lwt_io]

with_connection ?fd ?in_buffer ?out_buffer addr f opens a connection to the given address and passes the channels to f

with_file [Lwt_io]

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

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_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_switch [Lwt_switch]

with_switch fn is fn switch, where switch is a fresh switch that is turned off when the callback thread finishes (whether it succeeds or fails).

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 transforms the result into an Lwt thread.

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_exn [Lwt_stream]

wrap_exn s is a stream s' such that each time s yields a value v, s' yields Result.Ok v, and when the source of s raises an exception e, s' yields Result.Error e.

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]

write fd buf ofs len writes up to len bytes to fd from buf, starting at buffer offset ofs.

write [Lwt_bytes]
write [Lwt_io]

write oc str writes all characters of str on oc

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_from_string [Lwt_io]
write_from_string_exactly [Lwt_io]
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_string [Lwt_unix]
write_value [Lwt_io]

write_value channel ?flags v writes v to channel using the Marshal module of the standard library.

writev [Lwt_unix]

writev fd vs writes the bytes in the buffer slices vs to the file descriptor fd.


Y
yield [Lwt_unix]

yield () is a thread that 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'