(<&>) [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] | |
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] | |
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'
|