(<&>) [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']
|
(=<<) [Lwt.Infix] | f =<< t is t >>= f
|
(=<<) [Lwt] | f =<< t is t >>= f
|
(=|<) [Lwt.Infix] | f =|< m is map f m
|
(=|<) [Lwt] | f =|< m is map f m
|
(>>=) [Lwt.Infix] | t >>= f is an alternative notation for bind t f .
|
(>>=) [Lwt] | t >>= f is an alternative notation for bind t f .
|
(>|=) [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_hook [Lwt_switch] | |
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_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] |
Wrapper for
Unix.bind
|
bind [Lwt_react.S] | bind ?eq s f is initially f x where x is the current
value of s .
|
bind [Lwt] | bind t f is a thread which first waits for the thread t to
terminate and then, if the thread succeeds, behaves as the
application of function f to the return value of t .
|
bind_s [Lwt_react.S] |
Same as
Lwt_react.S.bind except that f returns a thread.
|
blit [Lwt_bytes] | blit buf1 ofs1 buf2 ofs2 len 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 returns whether fd is used in blocking or
non-blocking mode.
|
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.
|
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] | 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_stream] | choose l creates an stream from a list of streams.
|
choose [Lwt] | choose l behaves as the first thread in l to terminate.
|
chown [Lwt_unix] |
Wrapper for
Unix.chown
|
chroot [Lwt_unix] |
Wrapper for
Unix.chroot
|
clear_close_on_exec [Lwt_unix] |
Wrapper for
Unix.clear_close_on_exec
|
clone [Lwt_stream] | clone st clone the given stream.
|
close [Lwt_unix] |
Close a file descriptor.
|
close [Lwt_io] | close ch closes the given channel.
|
close [Lwt_log_core] |
Close the given logger
|
close [Lwt_ssl] | |
close_in [Lwt_chan] | |
close_out [Lwt_chan] | |
closedir [Lwt_unix] |
Wrapper for
Unix.closedir
|
combine [Lwt_stream] | combine s1 s2 combine two streams.
|
compare [Lwt_pqueue.OrderedType] | |
concat [Lwt_stream] | concat st returns the concatenation of all streams of st .
|
connect [Lwt_unix] |
Wrapper for
Unix.connect
|
copy [Lwt_bytes] | copy buffer creates a copy of the given byte array.
|
create [Lwt_bytes] |
Creates a new byte array of the given size.
|
create [Lwt_timeout] | create n f defines a new timeout with n seconds duration.
|
create [Lwt_throttle.S] | |
create [Lwt_switch] | create () creates a new switch.
|
create [Lwt_stream] | create () returns a new stream and a push function.
|
create [Lwt_sequence] | create () creates a new empty sequence
|
create [Lwt_pool] | create n ?check ?validate f creates a new pool with at most
n members.
|
create [Lwt_mvar] | create v creates a new mailbox variable containing value v .
|
create [Lwt_mutex] | create () creates a new mutex, which is initially unlocked
|
create [Lwt_condition] | create () creates a new condition variable.
|
create_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_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] |
detaches a computation to a preemptive thread.
|
diff_s [Lwt_react.S] | |
diff_s [Lwt_react.E] | |
direct_access [Lwt_io] | |
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.
|
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] | |
enter_iter_hooks [Lwt_main] |
Functions that are called before the main iteration.
|
eprint [Lwt_io] | |
eprintf [Lwt_io] | |
eprintl [Lwt_io] | |
eprintlf [Lwt_io] | |
error [Lwt_log_core] | |
error_f [Lwt_log_core] | |
establish_server [Lwt_io] | establish_server ?fd ?buffer_size ?backlog sockaddr f creates
a server which will listen for incoming connections.
|
exec [Lwt_process] |
Executes the given command and returns its exit status.
|
execute_job [Lwt_unix] |
This is the old and deprecated way of running a job.
|
exists_p [Lwt_list] | |
exists_s [Lwt_list] | |
exit_hooks [Lwt_main] |
Sets of functions executed just before the program exit.
|
extract [Lwt_bytes] | extract buffer offset length creates a new byte array of
length length and copy the length bytes of buffer at
offset into it.
|
F | |
fail [Lwt] | fail e is a thread that fails with the exception e .
|
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_stream] | filter_map f st filter and map st at the same time
|
filter_map_s [Lwt_list] | |
filter_p [Lwt_react.E] | |
filter_p [Lwt_list] | |
filter_s [Lwt_react.S] | |
filter_s [Lwt_react.E] | |
filter_s [Lwt_stream] | filter f st keeps only value x such that f x is true
|
filter_s [Lwt_list] | |
finalise [Lwt_gc] | finalise f x 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 returns the same result as f () whether it
fails or not.
|
find [Lwt_stream] | |
find_map [Lwt_stream] | |
find_map_s [Lwt_stream] | find f s find and map at the same time.
|
find_min [Lwt_pqueue.S] | |
find_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_stream] | find f s find an element in a stream.
|
find_s [Lwt_list] | |
flatten [Lwt_stream] | flatten st = map_list (fun l -> l) st
|
flush [Lwt_io] | flush oc performs all pending writes on oc
|
flush [Lwt_chan] | |
flush_all [Lwt_io] | flush_all () flushes all open output channels
|
fmap_p [Lwt_react.E] | |
fmap_s [Lwt_react.S] | |
fmap_s [Lwt_react.E] | |
fold [Lwt_stream] | |
fold_l [Lwt_sequence] | fold_l f s is:
where e1 , e2 , ..., en are the elements of s
|
fold_left_s [Lwt_list] | |
fold_r [Lwt_sequence] | fold_r f s is:
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 an 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_stream] | get st remove and returns the first element of the stream, if
any.
|
get [Lwt_sequence] |
Returns the contents of a node
|
get [Lwt] | get key returns the value associated with key in the current
thread.
|
get_affinity [Lwt_unix] | get_affinity ?pid () returns the list of CPUs the process with
pid pid is allowed to run on.
|
get_available [Lwt_stream] | get_available 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_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
|
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 is like Pervasives.ignore t except that:
|
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_io] | input input mode representation
|
input [Lwt_chan] | |
input_binary_int [Lwt_chan] | |
input_char [Lwt_chan] | |
input_line [Lwt_chan] | |
input_value [Lwt_chan] | |
install [Lwt_glib] |
Install the Glib<->Lwt integration.
|
io_vector [Lwt_bytes] | |
io_vector [Lwt_unix] |
Creates an io-vector
|
is_busy [Lwt_io] | is_busy channel returns whether the given channel is currently
busy.
|
is_empty [Lwt_pqueue.S] | |
is_empty [Lwt_stream] | is_empty st returns wether the given stream is empty
|
is_empty [Lwt_sequence] |
Returns
true iff the given sequence is empty
|
is_empty [Lwt_mutex] | is_empty mutex returns true if they are no thread waiting on
the mutex, and false otherwise
|
is_locked [Lwt_mutex] | locked mutex returns whether mutex is currently locked
|
is_on [Lwt_switch] | is_on switch returns true if the switch is currently on, and
false otherwise.
|
is_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_stream] | |
iter_p [Lwt_list] | |
iter_r [Lwt_sequence] | iter_l f s applies f on all elements of s starting from
the right
|
iter_s [Lwt_stream] | iter f s iterates over all elements of the stream
|
iter_s [Lwt_list] | |
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 remove the first element of st .
|
junk_old [Lwt_stream] | junk_old st removes all elements that are ready to be read
without yeilding from st .
|
junk_while [Lwt_stream] | |
junk_while_s [Lwt_stream] | junk_while f st removes all elements at the beginning of the
streams which satisfy f .
|
K | |
keep [Lwt_react.S] | keep s keeps a reference to s so it will never be garbage
collected.
|
keep [Lwt_react.E] | keep e keeps a reference to e so it will never be garbage
collected.
|
L | |
l1_s [Lwt_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 sleepping, or wait for one if no one is already
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 .
|
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] | |
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_stream] | |
map [Lwt] | map f m maps the result of a thread.
|
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_stream] | map f st maps the value returned by st with f
|
map_s [Lwt_list] | |
mapi_p [Lwt_list] | |
mapi_s [Lwt_list] | |
mapped [Lwt_bytes] | mapped buffer returns true iff buffer is a memory mapped
file.
|
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 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.
|
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] |
Creates a lwt file descriptor from a unix one.
|
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_stream] | on_termination st f executes f when the end of the stream st
is reached.
|
on_termination [Lwt] | on_termination t f executes f when t terminates.
|
on_timer [Lwt_engine] | on_timer delay repeat f calls f one time after delay
seconds.
|
on_writable [Lwt_engine] | on_readable fd f calls f each time fd becomes writable.
|
open_connection [Lwt_io] | open_connection ?fd ?in_buffer ?out_buffer addr opens a
connection to the given address and returns two channels for using
it.
|
open_connection [Lwt_chan] | |
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] |
Wrapper for
Unix.opendir
|
openfile [Lwt_unix] |
Wrapper for
Unix.openfile .
|
out_channel_of_descr [Lwt_chan] | |
out_channel_of_descr [Lwt_ssl] | |
output [Lwt_io] | output output mode representation
|
output [Lwt_chan] | |
output_binary_int [Lwt_chan] | |
output_char [Lwt_chan] | |
output_string [Lwt_chan] | |
output_value [Lwt_chan] | |
P | |
page_size [Lwt_bytes] |
Size of pages.
|
parse [Lwt_stream] | parse st f parses st with f .
|
partition_p [Lwt_list] | |
partition_s [Lwt_list] | |
pause [Lwt] | pause () is a sleeping thread which is wake up on the next
call to Lwt.wakeup_paused .
|
paused_count [Lwt] | paused_count () returns the number of 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] | |
pool_size [Lwt_unix] |
Maximum number of system threads that can be started.
|
position [Lwt_io] | position ch Returns the current position in the channel.
|
pread [Lwt_process] | |
pread_chars [Lwt_process] | |
pread_line [Lwt_process] | |
pread_lines [Lwt_process] | |
print [Lwt_io] | |
printf [Lwt_io] | |
printl [Lwt_io] | |
printlf [Lwt_io] | |
protected [Lwt] | protected thread creates a new cancelable thread which behave
as thread except that cancelling it does not cancel
thread .
|
proxy [Lwt_bytes] | proxy buffer offset length creates a ``proxy''.
|
put [Lwt_mvar] | put mvar value puts a value into a mailbox variable.
|
pwrite [Lwt_process] | |
pwrite_chars [Lwt_process] | |
pwrite_line [Lwt_process] | |
pwrite_lines [Lwt_process] | |
R | |
read [Lwt_bytes] | |
read [Lwt_unix] | read fd buf ofs len has the same semantic as Unix.read , but
is cooperative
|
read [Lwt_io] | read ?count ic reads at most 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 ic reads a marshaled value from ic
|
readable [Lwt_unix] |
Returns whether the given file descriptor is currently
readable.
|
readable_count [Lwt_engine] |
Returns the number of events waiting for a file descriptor to
become readable.
|
readdir [Lwt_unix] |
Wrapper for
Unix.readdir .
|
readdir_n [Lwt_unix] | readdir_n handle count reads at most count entry from the
given directory.
|
readlink [Lwt_unix] |
Wrapper for
Unix.readlink
|
really_input [Lwt_chan] | |
recv [Lwt_bytes] | |
recv [Lwt_unix] |
Wrapper for
Unix.recv
|
recv_msg [Lwt_bytes] |
This call is not available 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.
|
recvfrom [Lwt_bytes] | |
recvfrom [Lwt_unix] |
Wrapper for
Unix.recvfrom
|
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] | |
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] | return e is a thread whose return value is the value of the
expression e .
|
return_false [Lwt] | return_false = return false
|
return_nil [Lwt] | return_nil = return []
|
return_none [Lwt] | return_none = return None
|
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] |
Wrapper for
Unix.rewinddir
|
rmdir [Lwt_unix] |
Wrapper for
Unix.rmdir
|
rules [Lwt_log_rules] | parse lexbuf returns the list of rules contained in
lexbuf 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 executes f in the main 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] | |
send [Lwt_bytes] | |
send [Lwt_unix] |
Wrapper for
Unix.send
|
send_msg [Lwt_bytes] |
This call is not available 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_notification [Lwt_unix] | send_notification id sends a notification.
|
sendto [Lwt_bytes] | |
sendto [Lwt_unix] |
Wrapper for
Unix.sendto
|
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 puts fd in blocking or non-blocking
mode.
|
set_bounds [Lwt_preemptive] | set_bounds (min, max) set the minimum and the maximum number
of preemptive threads.
|
set_close_on_exec [Lwt_unix] |
Wrapper for
Unix.set_close_on_exec
|
set_default_async_method [Lwt_unix] |
Sets the default async method.
|
set_default_buffer_size [Lwt_io] |
Change the default buffer size.
|
set_exn_handler [Lwt_timeout] |
set the default handler for exception occurring after a timeout.
|
set_level [Lwt_log_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] |
Shutdown the given server
|
signal [Lwt_condition] | signal condvar value notifies that a condition is ready.
|
signal_count [Lwt_unix] |
Returns the number of registered signal handler.
|
simple_init [Lwt_preemptive] | simple_init () does a simple initialization.
|
size [Lwt_pqueue.S] | |
sleep [Lwt_unix] | sleep d is a 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] |
Same as
Lwt_sys.byte_order .
|
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] | |
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] | |
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 member of the pool p and gives it to
the function f .
|
W | |
wait [Lwt_unix] |
Wrapper for
Unix.wait
|
wait [Lwt_throttle.S] | |
wait [Lwt] | wait () is a pair of a thread which sleeps forever (unless it
is resumed by one of the functions wakeup , wakeup_exn below)
and the corresponding wakener.
|
wait [Lwt_condition] | wait mutex condvar will cause the current thread to block,
awaiting notification for a condition variable, condvar .
|
wait4 [Lwt_unix] | wait4 flags pid returns (pid, status, rusage) where (pid,
status) is the same result as Unix.waitpid flags pid , and
rusage contains accounting information about the child.
|
wait_count [Lwt_unix] |
Returns the number of threads waiting for a child to
terminate.
|
wait_for_jobs [Lwt_unix] |
Wait for all pending jobs to terminate.
|
wait_mincore [Lwt_bytes] | wait_mincore buffer offset waits until the page containing the
byte at offset offset 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] | true iff running on windows.
|
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_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_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_bytes] | |
write [Lwt_unix] | write fd buf ofs len has the same semantic as Unix.write , but
is cooperative
|
write [Lwt_io] | write oc str writes all characters of str on oc
|
write [Lwt_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] |
See
Lwt_io.write .
|
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] |
See
Lwt_unix.write .
|
write_value [Lwt_io] | write_value oc ?flags x marshals the value x to oc
|
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'
|