(<&>) [Lwt] | t <&> t' is the same as join [t; t']
|
(<?>) [Lwt] | t <?> t' is the same as choose [t; t']
|
(=<<) [Lwt] | f =<< t is t >>= f
|
(=|<) [Lwt] | f =|< m is map f m
|
(>>=) [Lwt] | t >>= f is an alternative notation for bind t f .
|
(>|=) [Lwt] | m >|= f is 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.
|
accum_s [Lwt_signal] | accum ?eq event_f initial
|
accum_s [Lwt_event] | |
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
|
app_p [Lwt_event] | |
app_s [Lwt_signal] | app_s ?eq signal_f initial signal_x
|
app_s [Lwt_event] | |
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.
|
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_signal] | bind signal f is initially f x where x is the current
value of signal .
|
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.
|
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
|
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.
|
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
|
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.
|
clear_close_on_exec [Lwt_unix] |
Wrapper for
Unix.clear_close_on_exec
|
clone [Lwt_stream] | clone st clone the given stream.
|
close [Lwt_ssl] | |
close [Lwt_log] |
Close the given logger
|
close [Lwt_io] | close ch closes the given channel.
|
close [Lwt_unix] |
Close a file descriptor.
|
closedir [Lwt_unix] |
Close a directory 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_condition] | create () creates a new condition variable.
|
create [Lwt_pool] | create n f creates a new pool with at most n members.
|
create [Lwt_mutex] | create () creates a new mutex, which is initially unlocked
|
create [Lwt_mvar] | create v creates a new mailbox variable containing value v .
|
create [Lwt_sequence] | create () creates a new empty sequence
|
create [Lwt_stream] | create () returns a new stream and a push function
|
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_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.
|
diff_s [Lwt_signal] | diff_s f signal
|
diff_s [Lwt_event] | |
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
|
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 | |
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.
|
exists_p [Lwt_list] | |
exists_s [Lwt_list] | |
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 .
|
fatal [Lwt_log] | |
fatal_f [Lwt_log] | |
fchmod [Lwt_unix] |
Wrapper for
Unix.fchmod
|
fchown [Lwt_unix] |
Wrapper for
Unix.fchown
|
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
|
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_event] | |
filter_p [Lwt_list] | |
filter_s [Lwt_signal] | filter_s ?eq f initial signal
|
filter_s [Lwt_event] | |
filter_s [Lwt_list] | |
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_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_io] | flush oc performs all pending writes on oc
|
fmap_p [Lwt_event] | |
fmap_s [Lwt_signal] | fmap ?eq f initial signal
|
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_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 ?eq f initial event
|
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] | |
fprint [Lwt_io] | |
fprintf [Lwt_io] | |
fprintl [Lwt_io] | |
fprintlf [Lwt_io] | |
from [Lwt_event] | from f creates an event which occurs each f () returns a
value.
|
from [Lwt_stream] | from f creates an stream from the given input function.
|
fstat [Lwt_unix.LargeFile] | |
fstat [Lwt_unix] |
Wrapper for
Unix.fstat
|
ftruncate [Lwt_unix.LargeFile] | |
ftruncate [Lwt_unix] |
Wrapper for
Unix.ftruncate
|
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_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_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_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)
|
getpeername [Lwt_unix] |
Wrapper for
Unix.getpeername
|
getsockname [Lwt_unix] |
Wrapper for
Unix.getsockname
|
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
|
has_wait4 [Lwt_unix] |
Whether the
wait4 system call is available on this 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_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
|
inputs [Lwt_unix] |
The set of action waiting for a file descriptor to become
readable
|
io_vector [Lwt_unix] |
Creates an io-vector
|
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 enum returns wether the given stream is empty
|
is_locked [Lwt_mutex] | locked mutex returns whether mutex is currently locked
|
is_ssl [Lwt_ssl] |
Are we using an SSL socket?
|
isatty [Lwt_unix] |
Wrapper for
Unix.isatty
|
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
|
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 | |
l1_s [Lwt_signal] | |
l2_s [Lwt_signal] | |
l3_s [Lwt_signal] | |
l4_s [Lwt_signal] | |
l5_s [Lwt_signal] | |
l6_s [Lwt_signal] | |
last_new [Lwt_stream] | next_new st if no element are available on st without
sleeping, then it is the same as next st .
|
length [Lwt_io] |
Returns the length of the channel in bytes
|
level [Lwt_log.Section] | level section returns the logging level of section
|
limit [Lwt_signal] | limit f signal limits the rate of signal update with f .
|
limit [Lwt_event] | limit f event limits the rate of event 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
files
|
listen [Lwt_unix] |
Wrapper for
Unix.listen
|
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
|
lseek [Lwt_unix.LargeFile] | |
lseek [Lwt_unix] |
Wrapper for
Unix.lseek
|
M | |
main [Lwt_log.Section] |
The main section.
|
main_loop_iteration [Lwt_main] |
The function doing one step of the main loop.
|
make [Lwt_log.Section] | make name creates a section with the given name, with level
initialised according to the LWT_LOG environment variable.
|
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.
|
map [Lwt_stream] | |
map [Lwt] | map f m map the result of a thread.
|
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_event] | |
map_p [Lwt_list] | |
map_s [Lwt_signal] | map_s ?eq f initial signal
|
map_s [Lwt_event] | |
map_s [Lwt_list] | |
map_s [Lwt_stream] | map f st maps the value returned by st with f
|
merge_s [Lwt_signal] | merge ?eq f initial signals
|
merge_s [Lwt_event] | |
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 | |
name [Lwt_log.Section] | name section returns the name of section
|
next [Lwt_event] | next ev returns the next occurrence of ev
|
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 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_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_log] |
Logger which drops everything
|
null [Lwt_io] |
Output which drops everything
|
O | |
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 returns all elements of l
|
of_stream [Lwt_event] | of_stream stream creates an event which occurs each time a
value is available on the stream.
|
of_string [Lwt_io] |
Create a channel from a string.
|
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.
|
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.
|
on_signal [Lwt_unix] | on_signal signum f calls f each time the signal with numnber
signum is received by the process.
|
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] | |
opendir [Lwt_unix] |
Open a descriptor on a directory
|
openfile [Lwt_unix] |
Wrapper for
Unix.openfile
|
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 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 .
|
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_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] | |
protected [Lwt] | protected thread creates a new cancelable thread which behave
as thread except that cancelling it does not cancel
thread .
|
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 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
|
readdir [Lwt_unix] |
Return the next entry in a directory.
|
recv [Lwt_unix] |
Wrapper for
Unix.recv
|
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.
|
recvfrom [Lwt_unix] |
Wrapper for
Unix.recvfrom
|
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.
|
render [Lwt_log] | render ~buffer ~template ~section ~level ~message instantiate
all variables of template , and store the result in
buffer .
|
resize_buffer [Lwt_io] |
Resize the internal buffer to the given size
|
return [Lwt_signal] |
Same as
React.S.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] |
Reposition the descriptor to the beginning of the directory
|
run [Lwt_main] | run t calls the Lwt scheduler repeatedly until t terminates,
then returns the value returned by the thread.
|
run_p [Lwt_event] | |
run_s [Lwt_signal] | |
run_s [Lwt_event] | |
S | |
sample_s [Lwt_signal] | sample f event signal
|
select_filters [Lwt_main] |
The set of all select filters.
|
send [Lwt_unix] |
Wrapper for
Unix.send
|
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.
|
sendto [Lwt_unix] |
Wrapper for
Unix.sendto
|
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_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_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_ssl] | |
shutdown [Lwt_unix] |
Wrapper for
Unix.shutdown
|
shutdown_server [Lwt_io] |
Shutdown the given server
|
signal [Lwt_condition] | signal condvar value notifies that a condition is ready.
|
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.
|
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] |
The byte order used by the computer running the program
|
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
|
tcsetattr [Lwt_unix] |
Wrapper for
Unix.tcsetattr
|
timeout [Lwt_unix] | |
to_list [Lwt_stream] |
Returns the list of elements of the given stream
|
to_stream [Lwt_event] |
Creates a stream holding all values occurring on the given
event
|
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 .
|
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 mutex unlock the mutex if no threads is waiting on
it.
|
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_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_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 .
|
wakeup_paused [Lwt] | wakeup_paused () wakes up all threads which suspended
themselves with Lwt.pause .
|
warning [Lwt_log] | |
warning_f [Lwt_log] | |
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 f signal returns a signal signal' which
behave as signal , except that f is called when signal' is
garbage collected.
|
with_finaliser [Lwt_event] | with_finaliser f event returns an event event' which behave
as event , except that f is called when event' 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_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 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.
|
Z | |
zero [Lwt_io] |
Inputs which returns always
'\x00'
|