Index of values
(<&>) [Lwt.Infix] |
t <&> t' is the same as join [t; t']
(<&>) [Lwt] |
t <&> t' is the same as join [t; t']
(<?>) [Lwt.Infix] |
t <?> t' is the same as choose [t; t']
(<?>) [Lwt] |
t <?> t' is the same as choose [t; t']
Error a_api: exception Dune__exe__Api.Error("\">>||@@class=\\\"odocwiki_index\\\"@@@<<a_apitext=\\\"(>>=)\\\"|valueLwt\" is not a valid module name")=) >> [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 switch f registers f so it will be called when Lwt_switch.turn_off is invoked.
add_hook_or_exec [Lwt_switch] |
add_hook_or_exec switch f is the same as Lwt_switch.add_hook except that if the switch is already off, f is called immediately.
add_l [Lwt_sequence] |
add_l x s adds x to the left of the sequence s
add_r [Lwt_sequence] |
add_l x s adds x to the right of the sequence s
add_rule [Lwt_log_core] |
add_rule pattern level adds a rule for sections logging levels.
add_task_l [Lwt] |
add_task_l seq creates a sleeping thread, adds its wakener to the left of seq and returns its waiter.
add_task_r [Lwt] |
add_task_r seq creates a sleeping thread, adds its wakener to the right of seq and returns its waiter.
app_p [Lwt_react.E] | |
app_s [Lwt_react.S] | |
app_s [Lwt_react.E] | |
append [Lwt_stream] |
append s1 s2 returns a stream which returns all elements of s1, then all elements of s2
append_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] |
direct_access ch f passes to f a Lwt_io.direct_access structure.
disable_signal_handler [Lwt_unix] |
Stops receiving this signal
dispatch [Lwt_log_core] |
dispatch f is a logger which dispatch logging instructions to different logger according to their level and/or section.
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:
fold_l f s x = f en (... (f e2 (f e1 x)))
where e1, e2, ..., en are the elements of s
fold_left_s [Lwt_list] | |
fold_r [Lwt_sequence] |
fold_r f s is:
fold_r f s x = f e1 (f e2 (... (f en x)))
where e1, e2, ..., en are the elements of s
fold_right_s [Lwt_list] | |
fold_s [Lwt_react.S] | |
fold_s [Lwt_react.E] | |
fold_s [Lwt_stream] |
fold f s x fold_like function for streams.
for_all_p [Lwt_list] | |
for_all_s [Lwt_list] | |
fork [Lwt_unix] |
fork () does the same as Unix.fork.
fprint [Lwt_io] | |
fprintf [Lwt_io] | |
fprintl [Lwt_io] | |
fprintlf [Lwt_io] | |
from [Lwt_react.E] |
from f creates an event which occurs each time f () returns a value.
from [Lwt_stream] |
from f creates 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.
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.
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 len 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] |
timeout d is a thread that remains suspended for d seconds and then fails with Lwt_unix.Timeout.
timer_count [Lwt_engine] |
Returns the number of registered timers.
to_bytes [Lwt_bytes] |
to_bytes buf returns newly allocated bytes with the same contents as buf.
to_list [Lwt_stream] |
Returns the list of elements of the given stream
to_stream [Lwt_react.E] |
Creates a stream holding all values occurring on the given event
to_string [Lwt_bytes] |
to_string buf returns a newly allocated string with the same contents as buf.
to_string [Lwt_stream] |
Returns the word composed of all characters of the given stream
transfer_l [Lwt_sequence] |
transfer_l s1 s2 removes all elements of s1 and add them at the left of s2.
transfer_r [Lwt_sequence] |
transfer_r s1 s2 removes all elements of s1 and add them at the right of s2.
truncate [Lwt_unix.LargeFile] |
Wrapper for Unix.LargeFile.truncate
truncate [Lwt_unix] |
Wrapper for Unix.truncate
try_bind [Lwt] |
try_bind t f g behaves as bind (t ()) f if t does not fail.
turn_off [Lwt_switch] |
turn_off switch turns off the switch.
U | |
union [Lwt_pqueue.S] | |
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_none 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_none 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'
|