(>>=) [Lwt] | t >>= f is an alternative notation for bind t f .
|
A | |
abort [Lwt_unix] |
Makes all current and further uses of the file descriptor
fail with the given exception
|
abort [Lwt_ssl] | |
accept [Lwt_unix] | |
add [Pqueue.S] | |
add [Lwt_queue] | |
add [Lwt_pqueue.S] | |
add_call [Orpc_js_client] | |
B | |
bind [Lwt_unix] | |
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 .
|
broadcast [Lwt_condition] | |
C | |
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.
|
choose [Lwt] | choose l behaves as the first thread in l to terminate.
|
close [Lwt_unix] | |
close [Lwt_ssl] | |
close_in [Lwt_chan] | |
close_out [Lwt_chan] | |
compare [Pqueue.OrderedType] | |
compare [Lwt_pqueue.OrderedType] | |
connect [Lwt_unix] | |
create [Orpc_js_client] | |
create [Lwt_timeout] | create n f defines a new timeout with n seconds duration.
|
create [Lwt_queue] | |
create [Lwt_pqueue.S] | |
create [Lwt_pool] | create n f creates a new pool with at most n members.
|
create [Lwt_mutex] | |
create [Lwt_condition] | |
D | |
detach [Lwt_preemptive] |
detaches a computation to a preemptive thread.
|
E | |
empty [Pqueue.S] | |
event_system [Lwt_equeue] | |
F | |
fail [Lwt] | fail e is a thread that fails with the exception e .
|
finalize [Lwt] | finalize f g returns the same result as f () whether it fails
or not.
|
find_min [Pqueue.S] | |
flush [Lwt_chan] | |
fold [Pqueue.S] | |
fold [Lwt_pqueue.S] | |
fold_left [Lwt_util] |
Similar to
List.fold_left .
|
G | |
get_max_number_of_threads_queued [Lwt_preemptive] |
Returns the size of the waiting queue, if no more threads are available
|
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 | |
handler [Orpc_js_server] | |
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] | |
in_channel_of_descr [Lwt_chan] | |
init [Lwt_preemptive] |
Should be called only once at the begining of the process.
|
input [Lwt_chan] | |
input_binary_int [Lwt_chan] | |
input_char [Lwt_chan] | |
input_line [Lwt_chan] | |
input_value [Lwt_chan] | |
is_empty [Pqueue.S] | |
is_ssl [Lwt_ssl] |
Are we using an SSL socket?
|
iter [Lwt_util] | iter f l start a thread for each element in l .
|
iter_serial [Lwt_util] |
Similar to
iter but wait for one thread to terminate before
starting the next one.
|
J | |
join [Lwt_util] | join l wait for all threads in l to terminate.
|
L | |
listen [Lwt_unix] | |
lock [Lwt_mutex] | |
M | |
make_in_channel [Lwt_chan] | make_in_channel read creates an input channel from the read
function.
|
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_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.
|
O | |
of_list [Orpc_onc] | |
of_option [Orpc_onc] | |
of_unix_file_descr [Lwt_unix] | |
open_connection [Lwt_chan] | |
open_in [Lwt_chan] | |
open_in_gen [Lwt_chan] | |
open_out [Lwt_chan] | |
open_out_gen [Lwt_chan] | |
orpc_aux_of_orpc_result [Orpc_onc] | |
orpc_aux_to_orpc_result [Orpc_onc] | |
orpc_aux_xdr_orpc_result [Orpc_onc] | |
out_channel_of_descr [Lwt_ssl] | |
out_channel_of_descr [Lwt_chan] | |
output [Lwt_chan] | |
output_binary_int [Lwt_chan] | |
output_char [Lwt_chan] | |
output_string [Lwt_chan] | |
output_value [Lwt_chan] | |
P | |
pack_orpc_result [Orpc] | |
pack_orpc_result_async [Orpc] | |
pipe [Lwt_unix] | |
pipe_in [Lwt_unix] | |
pipe_out [Lwt_unix] | |
plain [Lwt_ssl] | |
pp_array [Orpc_pp] | |
pp_list [Orpc_pp] | |
pp_option [Orpc_pp] | |
R | |
read [Lwt_unix] | |
read [Lwt_ssl] | |
really_input [Lwt_chan] | |
remove_min [Pqueue.S] | |
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_unix] | run t lets the thread t run until it terminates.
|
run_in_region [Lwt_util] | run_in_region reg size f execute the thread produced by the
function f in the region reg .
|
S | |
service [Orpc_js_server] | |
session [Orpc_onc] | |
set_close_on_exec [Lwt_unix] | |
set_debug [Orpc_js_server] | |
set_event_system [Lwt_equeue] | |
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 threads are available
|
setsockopt [Lwt_unix] | |
shutdown [Lwt_unix] | |
shutdown [Lwt_ssl] | |
signal [Lwt_condition] | |
size [Pqueue.S] | |
size [Lwt_pqueue.S] | |
sleep [Lwt_unix] | sleep d is a threads which remain suspended for d seconds
(letting other threads run) and then terminates.
|
socket [Lwt_unix] | |
socketpair [Lwt_unix] | |
ssl_accept [Lwt_ssl] | |
ssl_connect [Lwt_ssl] | |
ssl_shutdown [Lwt_ssl] | |
start [Lwt_timeout] |
starts a timeout.
|
stop [Lwt_timeout] |
stops a timeout.
|
sync_call [Orpc_js_client] | |
system [Lwt_unix] | |
T | |
take [Lwt_queue] | |
take [Lwt_pqueue.S] | |
to_bool [Orpc_js_server] | |
to_char [Orpc_js_server] | |
to_float [Orpc_js_server] | |
to_int [Orpc_js_server] | |
to_int32 [Orpc_js_server] | |
to_int64 [Orpc_js_server] | |
to_list [Orpc_onc] | |
to_list [Orpc_js_server] | |
to_option [Orpc_onc] | |
to_option [Orpc_js_server] | |
to_string [Orpc_js_server] | |
to_unit [Orpc_js_server] | |
trace_call [Orpc_pp.Trace] | |
trace_reply_exn [Orpc_pp.Trace] | |
trace_reply_ok [Orpc_pp.Trace] | |
try_bind [Lwt] | try_bind t f g behaves as bind (t ()) f if t does not fail.
|
U | |
union [Pqueue.S] | |
unix_file_descr [Lwt_unix] | |
unlock [Lwt_mutex] | |
unpack_orpc_result [Orpc] | |
unset_event_system [Lwt_equeue] | |
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] | |
wait [Lwt_condition] | |
wait [Lwt] | wait () is a thread which sleeps forever (unless it is
resumed by one of the functions wakeup , wakeup_exn below).
|
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] | |
waitpid [Lwt_unix] | |
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 .
|
write [Lwt_unix] | |
write [Lwt_ssl] | |
X | |
x_char [Orpc_onc] | |
x_list [Orpc_onc] | |
Y | |
yield [Lwt_unix] | yield () is a threads which suspends itself (letting other
thread run) and then resumes as soon as possible and
terminates.
|