Index of values


(<&>) [Lwt]
t <&> t' is the same as join [t; t']
(<?>) [Lwt]
t <?> t' is the same as choose [t; t']
(=<<) [Lwt]
f =<< t is t >>= f
(=|<) [Lwt]
f =|< m is map f m
(>>=) [Lwt]
t >>= f is an alternative notation for bind t f.
(>|=) [Lwt]
m >|= f is map f m

A
abort [Lwt_ssl]
abort [Lwt_io]
abort ch abort current operations and close the channel immediatly.
abort [Lwt_unix]
abort fd exn makes all current and further uses of the file descriptor fail with the given exception.
accept [Lwt_read_line.Control]
accept instance = send_command instance Command.Accept_line
accept [Lwt_unix]
Wrapper for Unix.accept
accept_n [Lwt_unix]
accept_n fd count accepts up to count connection in one time.
accum_s [Lwt_signal]
accum ?eq event_f initial
accum_s [Lwt_event]
add_entry [Lwt_read_line]
add_entry line history returns the history history plus line at the beginning.
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
all_input [Lwt_read_line.Engine]
Returns the current complete user input.
always_notify [Lwt_signal]
Same as notify but does not return a notifier
always_notify [Lwt_event]
Same as notify but does not return a notifier
always_notify_p [Lwt_signal]
Same as notify_p but does not return a notifier
always_notify_p [Lwt_event]
Same as notify_p but does not return a notifier
always_notify_s [Lwt_signal]
Same as notify_s but does not return a notifier
always_notify_s [Lwt_event]
Same as notify_s but does not return a notifier
app_p [Lwt_event]
app_s [Lwt_signal]
app_s ?eq signal_f initial signal_x
app_s [Lwt_event]
append [Lwt_stream]
append s1 s2 returns a stream which returns all elements of s1, then all elements of s2
apply_filters [Lwt_main]
apply_filters select apply all the filters on the given select function.
at_exit [Lwt_main]
at_exit hook adds hook at the left of exit_hooks
atomic [Lwt_text]
atomic [Lwt_io]
atomic f transforms a sequence of io operations into one single atomic io operation.
auto_yield [Lwt_unix]
auto_yield timeout returns a function f which will yield every timeout seconds.

B
bg [Lwt_term]
bg col = Background col
bind [Lwt_signal]
bind signal f is initially f x where x is the current value of signal.
bind [Lwt_unix]
Wrapper for Unix.bind
bind [Lwt]
bind t f is a thread which first waits for the thread t to terminate and then, if the thread succeeds, behaves as the application of function f to the return value of t.
black [Lwt_term]
blank [Lwt_term]
A space with default color and styles
blink [Lwt_term]
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.
blue [Lwt_term]
bold [Lwt_term]
broadcast [Lwt_log]
broadcast loggers is a logger which send messages to all the given loggers.
broadcast [Lwt_condition]
broadcast condvar value notifies all waiting threads.
buffer_size [Lwt_io]
Returns the size of the internal buffer.
buffered [Lwt_io]
buffered oc returns the number of bytes in the buffer
byte_channel [Lwt_text]
byte_channel ch returns the underlying byte channel of a text channel

C
cancel [Lwt]
cancel t cancels the threads t.
catch [Lwt]
catch t f is a thread that behaves as the thread t () if this thread succeeds.
change [Lwt_timeout]
changes the duration of a timeout.
channel [Lwt_log]
channel ?template ~close_mode ~channel () creates a logger from a channel.
chars_of_file [Lwt_text]
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_text]
chars_to_file [Lwt_io]
chars_to_file name chars writes all characters of chars to name
check_descriptor [Lwt_unix]
check_descriptor fd raise an exception if fd is not in the state Open
choose [Lwt_stream]
choose l creates an stream from a list of streams.
choose [Lwt]
choose l behaves as the first thread in l to terminate.
clear_close_on_exec [Lwt_unix]
Wrapper for Unix.clear_close_on_exec
clear_line [Lwt_term]
clear_line () clears the current line
clear_screen [Lwt_term]
clear_screen () clears the entire screen
clipboard [Lwt_read_line]
The global clipboard.
clone [Lwt_stream]
clone st clone the given stream.
close [Lwt_text]
Close the underlying byte channel
close [Lwt_ssl]
close [Lwt_log]
Close the given logger
close [Lwt_io]
close ch closes the given channel.
close [Lwt_unix]
Close a file descriptor.
closedir [Lwt_unix]
Close a directory descriptor.
columns [Lwt_term]
Number of columns of the terminal
combine [Lwt_stream]
combine s1 s2 combine two streams.
complete [Lwt_read_line]
complete ?suffix before word after words basic completion functions.
completion_mode [Lwt_top]
Return the current completion mode.
concat [Lwt_stream]
concat st returns the concatenation of all streams of st.
connect [Lwt_unix]
Wrapper for Unix.connect
control_mapping [Lwt_term]
Mapping from control key codes to character codes.
create [Lwt_timeout]
create n f defines a new timeout with n seconds duration.
create [Lwt_throttle.S]
create [Lwt_condition]
create () creates a new condition variable.
create [Lwt_pool]
create n f creates a new pool with at most n members.
create [Lwt_mutex]
create () creates a new mutex, which is initially unlocked
create [Lwt_mvar]
create v creates a new mailbox variable containing value v.
create [Lwt_sequence]
create () creates a new empty sequence
create [Lwt_stream]
create () returns a new stream and a push function
create_empty [Lwt_mvar]
create () creates a new empty mailbox variable.
cyan [Lwt_term]

D
daemonize [Lwt_daemon]
Put the current running process into daemon mode.
debug [Lwt_log]
debug_f [Lwt_log]
decode_key [Lwt_term]
Decode a key.
default [Lwt_term]
default [Lwt_log]
The default logger.
default_buffer_size [Lwt_io]
Return the default size for buffers.
default_iteration [Lwt_main]
The default iteration function.
default_select [Lwt_main]
The default select function.
detach [Lwt_preemptive]
detaches a computation to a preemptive thread.
diff_s [Lwt_signal]
diff_s f signal
diff_s [Lwt_event]
direct_access [Lwt_io]
direct_access ch f pass to f a Lwt_io.direct_access structure.
disable [Lwt_signal]
disable notif stops the corresponding signal to be monitored
disable [Lwt_event]
disable notif stops the corresponding event to be monitored
disable_signal_handler [Lwt_unix]
Stops receiving this signal
dispatch [Lwt_log]
dispatch f is a logger which dispatch logging instructions to different logger according to their level and/or section.
draw [Lwt_read_line.Terminal]
draw ~column ?map_text ?bar ~render_state ~engine_state prompt () returns (text, state) where state is the new rendering state, and text is a text containing escape sequences.
dup [Lwt_unix]
Wrapper for Unix.dup
dup2 [Lwt_unix]
Wrapper for Unix.dup2

E
edition_state [Lwt_read_line.Engine]
Returns the edition state of a state, whatever its mode is.
encoding [Lwt_text]
encoding ch returns the character encoding of a channel.
engine_state [Lwt_read_line.Control]
Return the engine state of the given state
enter_drawing_mode [Lwt_term]
Put the terminal into drawing mode
eprint [Lwt_text]
eprint [Lwt_io]
eprintc [Lwt_term]
Same as printc but prints on stderr.
eprintf [Lwt_text]
eprintf [Lwt_io]
eprintl [Lwt_text]
eprintl [Lwt_io]
eprintlc [Lwt_term]
Same as printlc but prints on stderr
eprintlf [Lwt_text]
eprintlf [Lwt_io]
erase [Lwt_read_line.Terminal]
erase ~columns ~render_state () returns a text which will erase everything (the prompt, user input, completion, ...).
error [Lwt_log]
error_f [Lwt_log]
establish_server [Lwt_io]
establich_server ?buffer_size ?backlog sockaddr f creates a server which will listen for incomming connections.
exec [Lwt_process]
Executes the given command and returns its exit status.
exists_p [Lwt_list]
exists_s [Lwt_list]
exit_hooks [Lwt_main]
Sets of functions executed just before the program exit.

F
fail [Lwt]
fail e is a thread that fails with the exception e.
fatal [Lwt_log]
fatal_f [Lwt_log]
fchmod [Lwt_unix]
Wrapper for Unix.fchmod
fchown [Lwt_unix]
Wrapper for Unix.fchown
fg [Lwt_term]
fg col = Foreground col
file [Lwt_log]
desf_file ?template ?mode ?perm ~file_name () creates an logger which will write messages to file_name.
file_length [Lwt_io]
Returns the length of a file
filter [Lwt_stream]
filter_map [Lwt_stream]
filter_map_s [Lwt_stream]
filter_map f st filter and map st at the same time
filter_p [Lwt_event]
filter_p [Lwt_list]
filter_s [Lwt_signal]
filter_s ?eq f initial signal
filter_s [Lwt_event]
filter_s [Lwt_list]
filter_s [Lwt_stream]
filter f st keeps only value x such that f x is true
finalise [Lwt_gc]
finalise f x calls f x when x is garbage collected.
finalise_or_exit [Lwt_gc]
finalise_or_exit f x call f x when x is garbage collected or (exclusively) when the program exit.
finalize [Lwt]
finalize f g returns the same result as f () whether it fails or not.
find [Lwt_stream]
find_map [Lwt_stream]
find_map_s [Lwt_stream]
find f s find and map at the same time.
find_s [Lwt_list]
find_s [Lwt_stream]
find f s find an element in a stream.
flatten [Lwt_stream]
flatten st = map_list (fun l -> l) st
flush [Lwt_text]
Flush the underlying byte channel
flush [Lwt_io]
flush oc performs all pending writes on oc
fmap_p [Lwt_event]
fmap_s [Lwt_signal]
fmap ?eq f initial signal
fmap_s [Lwt_event]
fold [Lwt_stream]
fold_l [Lwt_sequence]
fold_l f s is:
        fold_l f s x = f en (... (f e2 (f e1 x)))
      

      where e1, e2, ..., en are the elements of s
fold_left_s [Lwt_list]
fold_r [Lwt_sequence]
fold_r f s is:
        fold_r f s x = f e1 (f e2 (... (f en x)))
      

      where e1, e2, ..., en are the elements of s
fold_right_s [Lwt_list]
fold_s [Lwt_signal]
fold ?eq f initial event
fold_s [Lwt_event]
fold_s [Lwt_stream]
fold f s x fold_like function for streams.
for_all_p [Lwt_list]
for_all_s [Lwt_list]
fprint [Lwt_text]
fprint [Lwt_io]
fprintf [Lwt_text]
fprintf [Lwt_io]
fprintl [Lwt_text]
fprintl [Lwt_io]
fprintlf [Lwt_text]
fprintlf [Lwt_io]
from [Lwt_event]
from f creates an event which occurs each f () returns a value.
from [Lwt_stream]
from f creates an stream from the given input function.
fstat [Lwt_unix.LargeFile]
fstat [Lwt_unix]
Wrapper for Unix.fstat
ftruncate [Lwt_unix.LargeFile]
ftruncate [Lwt_unix]
Wrapper for Unix.ftruncate

G
get [Lwt_term.Draw]
get ~zone ~x ~y returns the point at relative position x and y.
get [Lwt_sequence]
Returns the contents of a node
get [Lwt_stream]
get st remove and returns the first element of the stream, if any.
get_available [Lwt_stream]
get_available l returns all available elements of l without blocking
get_available_up_to [Lwt_stream]
get_available_up_to l n returns up to n elements of l without blocking
get_bounds [Lwt_preemptive]
get_bounds () returns the minimum and the maximum number of preemptive threads.
get_credentials [Lwt_unix]
get_credentials fd returns credential informations from the given socket.
get_max_number_of_threads_queued [Lwt_preemptive]
Returns the size of the waiting queue, if no more threads are available
get_while [Lwt_stream]
get_while_s [Lwt_stream]
get_while f st returns the longest prefix of st where all elements satisfy f.
getaddrinfo [Lwt_lib]
Cooperative getaddrinfo with cache (using Lwt_preemptive.detach)
gethostbyname [Lwt_lib]
Cooperative gethostbyname with cache (using Lwt_preemptive.detach)
getnameinfo [Lwt_lib]
Cooperative getnameinfo with cache (using Lwt_preemptive.detach)
getpeername [Lwt_unix]
Wrapper for Unix.getpeername
getsockname [Lwt_unix]
Wrapper for Unix.getsockname
getsockopt [Lwt_unix]
Wrapper for Unix.getsockopt
getsockopt_error [Lwt_unix]
Wrapper for Unix.getsockopt_error
getsockopt_float [Lwt_unix]
Wrapper for Unix.getsockopt_float
getsockopt_int [Lwt_unix]
Wrapper for Unix.getsockopt_int
getsockopt_optint [Lwt_unix]
Wrapper for Unix.getsockopt_optint
goto_beginning_of_line [Lwt_term]
goto_beginning_of_line n put the cursor at the beginning of the nth previous line.
green [Lwt_term]

H
handle_unix_error [Lwt_unix]
Same as Unix.handle_unix_error but catches lwt-level exceptions
has_wait4 [Lwt_unix]
Whether the wait4 system call is available on this system.
height [Lwt_term.Zone]
hexdump [Lwt_text]
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_text]
hexdump_stream [Lwt_io]
hexdump_stream oc byte_stream produces the same output as the command hexdump -C.
hidden [Lwt_term]
hide [Lwt_read_line.Control]
Hides everything (prompt, user input, completion box) until Lwt_read_line.Control.show is called.
hide_cursor [Lwt_term]
hide_cursor () makes the cursor invisible

I
ignore_result [Lwt]
ignore_result t start the thread t and ignores its result value if the thread terminates sucessfully.
in_channel_of_descr [Lwt_ssl]
info [Lwt_log]
info_f [Lwt_log]
init [Lwt_read_line.Terminal]
Initial state
init [Lwt_read_line.Engine]
init history return a initial state using the given history
init [Lwt_glib]
Initialises glib and integrates the Lwt scheduler into the glib main loop.
init [Lwt_preemptive]
init min max log initialises this module.
inner [Lwt_term.Zone]
inner zone returns the inner part of zone
input [Lwt_io]
input input mode representation
inputs [Lwt_unix]
The set of action waiting for a file descriptor to become readable
interrupt [Lwt_read_line.Control]
accept instance = send_command instance Command.Break
inverse [Lwt_term]
io_vector [Lwt_unix]
Creates an io-vector
is_empty [Lwt_mutex]
is_empty mutex returns true if they are no thread waiting on the mutex, and false otherwise
is_empty [Lwt_sequence]
Returns true iff the given sequence is empty
is_empty [Lwt_stream]
is_empty enum returns wether the given stream is empty
is_locked [Lwt_mutex]
locked mutex returns whether mutex is currently locked
is_ssl [Lwt_ssl]
Are we using an SSL socket?
isatty [Lwt_unix]
Wrapper for Unix.isatty
iter [Lwt_stream]
iter_l [Lwt_sequence]
iter_l f s applies f on all elements of s starting from the left
iter_node_l [Lwt_sequence]
iter_l f s applies f on all nodes of s starting from the left
iter_node_r [Lwt_sequence]
iter_l f s applies f on all nodes of s starting from the right
iter_p [Lwt_list]
iter_p [Lwt_stream]
iter_r [Lwt_sequence]
iter_l f s applies f on all elements of s starting from the right
iter_s [Lwt_list]
iter_s [Lwt_stream]
iter f s iterates over all elements of the stream

J
join [Lwt]
join l wait for all threads in l to terminate.
junk [Lwt_stream]
junk st remove the first element of st.
junk_old [Lwt_stream]
junk_old st removes all elements that are ready to be read without yeilding from st.
junk_while [Lwt_stream]
junk_while_s [Lwt_stream]
junk_while f st removes all elements at the beginning of the streams which satisfy f.

K
key_backspace [Lwt_term]
key_backspace = Key_control '?'
key_enter [Lwt_term]
key_enter = Key_control 'j'
key_escape [Lwt_term]
key_escape = Key_control '['
key_tab [Lwt_term]
key_escape = Key_control 'i'

L
l1_s [Lwt_signal]
l2_s [Lwt_signal]
l3_s [Lwt_signal]
l4_s [Lwt_signal]
l5_s [Lwt_signal]
l6_s [Lwt_signal]
last_draw [Lwt_read_line.Terminal]
Draw for the last time, i.e.
last_new [Lwt_stream]
next_new st if no element are available on st without sleeping, then it is the same as next st.
lblack [Lwt_term]
lblue [Lwt_term]
lcyan [Lwt_term]
leave_drawing_mode [Lwt_term]
Restore the state of the terminal
length [Lwt_io]
Returns the length of the channel in bytes
level [Lwt_log.Section]
level section returns the logging level of section
lgreen [Lwt_term]
limit [Lwt_signal]
limit f signal limits the rate of signal update with f.
limit [Lwt_event]
limit f event limits the rate of event with f.
lines [Lwt_term]
Number of lines of the terminal
lines_of_file [Lwt_text]
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_text]
lines_to_file [Lwt_io]
lines_to_file name lines writes all lines of lines to files
listen [Lwt_unix]
Wrapper for Unix.listen
lmagenta [Lwt_term]
load_history [Lwt_read_line]
load_history filename loads history from filename.
lock [Lwt_mutex]
lock mutex lockcs the mutex, that is:
lockf [Lwt_unix]
Wrapper for Unix.lockf
log [Lwt_log]
log ?section ?logger ~level message logs a message.
log_f [Lwt_log]
log_f is the same as log except that it takes a format string
lookup [Lwt_read_line]
lookup word words lookup for completion of word into words.
lred [Lwt_term]
lseek [Lwt_unix.LargeFile]
lseek [Lwt_unix]
Wrapper for Unix.lseek
lwhite [Lwt_term]
lyellow [Lwt_term]

M
magenta [Lwt_term]
main [Lwt_log.Section]
The main section.
main_loop_iteration [Lwt_main]
The function doing one step of the main loop.
make [Lwt_read_line.Control]
Creates a new read-line instance with the given parameters.
make [Lwt_term.Zone]
Make a new zone where all points are initialized to Lwt_term.blank
make [Lwt_text]
make ?strict ?encoding ch creates a text channel from a byte channel.
make [Lwt_log.Section]
make name creates a section with the given name, with level initialised according to the LWT_LOG environment variable.
make [Lwt_log]
make ~output ~close creates a new logger.
make [Lwt_io]
make ?buffer_size ?close ~mode perform_io is the main function for creating new channels.
map [Lwt_term.Draw]
map ~zone ~x ~y f replace the point at coordinates (x, y) by the result of f applied on it.
map [Lwt_stream]
map [Lwt]
map f m map the result of a thread.
map_list [Lwt_stream]
map_list_s [Lwt_stream]
map_list f st applies f on each element of st and flattens the lists returned
map_p [Lwt_event]
map_p [Lwt_list]
map_s [Lwt_signal]
map_s ?eq f initial signal
map_s [Lwt_event]
map_s [Lwt_list]
map_s [Lwt_stream]
map f st maps the value returned by st with f
merge_s [Lwt_signal]
merge ?eq f initial signals
merge_s [Lwt_event]
min_timeout [Lwt_main]
min_timeout a b returns the smallest timeout of two timeouts.
mode [Lwt_io]
mode ch returns the mode of a channel

N
name [Lwt_log.Section]
name section returns the name of section
names [Lwt_read_line.Command]
names is the list of all commands (except Char ch) with their name.
nchoose [Lwt]
nchoose l returns the value of all that have succcessfully terminated.
next [Lwt_event]
next ev returns the next occurrence of ev
next [Lwt_stream]
next st remove and returns the next element of the stream, of fail with Lwt_stream.Empty if the stream is empty.
nget [Lwt_stream]
nget n st remove and returns at most the first n elements of st.
njunk [Lwt_stream]
njunk n st removes at most the first n elements of the stream.
notice [Lwt_log]
notice_f [Lwt_log]
notify [Lwt_signal]
notify f s calls f each time the value of s change
notify [Lwt_event]
notify f ev calls f x each time ev has a value x
notify_p [Lwt_signal]
notify_p f s is the same as notify except that f x is a thread.
notify_p [Lwt_event]
notify_p f ev is the same as notify except that f x is a thread.
notify_s [Lwt_signal]
notify_s f s is the same as notify except that f x is a thread.
notify_s [Lwt_event]
notify_s f ev is the same as notify except that f x is a thread.
npeek [Lwt_stream]
npeek n st returns at most the first n elements of st, without removing them.
npick [Lwt]
npick l is the same as Lwt.nchoose, except that it cancels all sleeping threads when one terminates.
null [Lwt_text]
null [Lwt_log]
Logger which drops everything
null [Lwt_io]
Output which drops everything

O
of_fd [Lwt_io]
of_fd ?buffer_size ?close ~mode fd creates a channel from a file descriptor.
of_key [Lwt_read_line.Command]
of_key key returns the command to which a key is mapped.
of_list [Lwt_stream]
of_list l creates a stream returns all elements of l
of_stream [Lwt_event]
of_stream stream creates an event which occurs each time a value is available on the stream.
of_string [Lwt_read_line.Command]
of_string cld tries to convert a command name to a command.
of_string [Lwt_io]
Create a channel from a string.
of_string [Lwt_stream]
of_string str creates a stream returning all characters of str
of_unix_fd [Lwt_io]
of_unix_fd ?buffer_size ?close ~mode fd is a short-hand for:
of_unix_file_descr [Lwt_unix]
Creates a lwt file descriptor from a unix one.
of_unix_file_descr_blocking [Lwt_unix]
Normally Lwt_unix uses file descriptors in non-blocking mode, but in certain cases, like for standard descriptors (Lwt_unix.stdin, Lwt_unix.stdout and Lwt_unix.stderr) we do not want that.
on_cancel [Lwt]
on_cancel t f executes f when t is canceled.
on_signal [Lwt_unix]
on_signal signum f calls f each time the signal with numnber signum is received by the process.
open_connection [Lwt_io]
open_connection ?buffer_size ~mode addr open a connection to the given address and returns two channels for using it.
open_file [Lwt_text]
open_file [Lwt_io]
open_file ?buffer_size ?flags ?perm ~mode filename open the file with name filename and returns a channel for reading/writing it.
open_process [Lwt_process]
open_process_full [Lwt_process]
open_process_in [Lwt_process]
open_process_none [Lwt_process]
open_process_out [Lwt_process]
opendir [Lwt_unix]
Open a descriptor on a directory
openfile [Lwt_unix]
Wrapper for Unix.openfile
out_channel_of_descr [Lwt_ssl]
output [Lwt_io]
output output mode representation
outputs [Lwt_unix]
The set of action waiting for a file descriptor to become writable

P
parse [Lwt_stream]
parse st f parses st with f.
parse_key_raw [Lwt_term]
parse_key_raw st recognize escape sequence in a stream of unicode character.
partition_p [Lwt_list]
partition_s [Lwt_list]
pause [Lwt]
pause () is a sleeping thread which is wake up on the next call to Lwt.wakeup_paused.
peek [Lwt_stream]
peek st returns the first element of the stream, if any, without removing it.
pick [Lwt]
pick l is the same as Lwt.choose, except that it cancels all sleeping threads when one terminates.
pipe [Lwt_io]
pipe ?buffer_size () creates a pipe using Lwt_unix.pipe and makes two channels from the two returned file descriptors
pipe [Lwt_unix]
pipe () creates pipe using Unix.pipe and returns two lwt file descriptors created from unix file_descriptor
pipe_in [Lwt_unix]
pipe_in () is the same as Lwt_unix.pipe but maps only the unix file descriptor for reading into a lwt one.
pipe_out [Lwt_unix]
pipe_out () is the inverse of Lwt_unix.pipe_in.
plain [Lwt_ssl]
pmap [Lwt_process]
pmap_chars [Lwt_process]
pmap_line [Lwt_process]
pmap_lines [Lwt_process]
points [Lwt_term.Zone]
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_text]
print [Lwt_io]
print_words [Lwt_read_line]
print_words oc columns strs pretty-prints a list of words.
printc [Lwt_term]
printc st prints the given styled text on standard output.
printf [Lwt_text]
printf [Lwt_io]
printl [Lwt_text]
printl [Lwt_io]
printlc [Lwt_term]
printlc st prints st, then reset styles and prints a newline
printlf [Lwt_text]
printlf [Lwt_io]
protected [Lwt]
protected thread creates a new cancelable thread which behave as thread except that cancelling it does not cancel thread.
put [Lwt_mvar]
put mvar value puts a value into a mailbox variable.
pwrite [Lwt_process]
pwrite_chars [Lwt_process]
pwrite_line [Lwt_process]
pwrite_lines [Lwt_process]

Q
quit [Lwt_glib]
Calls GMain.quit and remove the Lwt scheduler from the glib main loop

R
raw_mode [Lwt_term]
Returns wether the terminal is currently in raw mode
read [Lwt_text]
read [Lwt_ssl]
read [Lwt_io]
read ?count ic reads at most len characters from ic.
read [Lwt_unix]
read fd buf ofs len has the same semantic as Unix.read, but is cooperative
read_char [Lwt_text]
read_char [Lwt_io]
read_char ic reads the next character of ic.
read_char_opt [Lwt_text]
read_char_opt [Lwt_io]
Same as read_byte but does not raises End_of_file on end of input
read_chars [Lwt_text]
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_key [Lwt_term]
Get and decode a key from Lwt_term.standard_input
read_keyword [Lwt_read_line.Control]
read_keyword [Lwt_read_line]
read_keyword ?history ?case_sensitive ?mode ~prompt ~keywords () reads one word which is a member of words.
read_line [Lwt_read_line.Control]
read_line [Lwt_read_line]
readline ?history ?complete ?mode ?prompt () inputs some text from the user.
read_line [Lwt_text]
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_text]
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_text]
read_lines [Lwt_io]
read_lines ic returns a stream holding all lines of ic
read_password [Lwt_read_line.Control]
read_password [Lwt_read_line]
read_password ?clipboard ?clear ~prompt () inputs a password from the user.
read_value [Lwt_io]
read_value ic reads a marshaled value from ic
read_yes_no [Lwt_read_line.Control]
read_yes_no [Lwt_read_line]
read_yes_no ?history ?dynamic prompt () is the same as:
readdir [Lwt_unix]
Return the next entry in a directory.
recv [Lwt_unix]
Wrapper for Unix.recv
recv_msg [Lwt_unix]
recv_msg ~socket ~io_vectors receives data into a list of io-vectors, plus any file-descriptors that may accompany the message.
recvfrom [Lwt_unix]
Wrapper for Unix.recvfrom
red [Lwt_term]
register_action [Lwt_unix]
register_action set fd action registers action on fd.
remove [Lwt_sequence]
Removes a node from the sequence it is part of.
render [Lwt_term]
Render an offscreen array to the terminal.
render [Lwt_log]
render ~buffer ~template ~section ~level ~message instantiate all variables of template, and store the result in buffer.
render_state [Lwt_read_line.Control]
Return the rendering state of the given state
reset [Lwt_read_line.Engine]
reset state reset the given state, if the user was doing a selection, it is canceled
reset [Lwt_term]
resize_buffer [Lwt_io]
Resize the internal buffer to the given size
result [Lwt_read_line.Control]
Threads waiting for the read-line instance to terminates
return [Lwt_signal]
Same as React.S.const
return [Lwt]
return e is a thread whose return value is the value of the expression e.
rev_map_p [Lwt_list]
rev_map_s [Lwt_list]
rewinddir [Lwt_unix]
Reposition the descriptor to the beginning of the directory
run [Lwt_main]
run t calls the Lwt scheduler repeatedly until t terminates, then returns the value returned by the thread.
run_p [Lwt_event]
run_s [Lwt_signal]
run_s [Lwt_event]

S
sample_s [Lwt_signal]
sample f event signal
save_history [Lwt_read_line]
save_history filename history saves history to filename.
select_filters [Lwt_main]
The set of all select filters.
send [Lwt_unix]
Wrapper for Unix.send
send_command [Lwt_read_line.Control]
send_command instance command sends the given command to the read-line instance
send_msg [Lwt_unix]
send_msg ~socket ~io_vectors ~fds sends data from a list of io-vectors, accompanied with a list of file-descriptor.
sendto [Lwt_unix]
Wrapper for Unix.sendto
sequence_mapping [Lwt_term]
Mapping from sequence to keys
set [Lwt_term.Draw]
set ~zone ~x ~y ~popint sets point at relative position x and y.
set [Lwt_sequence]
Change the contents of a node
set_blocking [Lwt_unix]
set_blocking fd b puts fd in blocking or non-blocking mode.
set_bounds [Lwt_preemptive]
set_bounds (min, max) set the minimum and the maximum number of preemptive threads.
set_close_on_exec [Lwt_unix]
Wrapper for Unix.set_close_on_exec
set_color [Lwt_term]
set_color num (red, green, blue) sets the three components of the color number num
set_completion_mode [Lwt_top]
Change the completion mode
set_default_buffer_size [Lwt_io]
Change the default buffer size.
set_exn_handler [Lwt_timeout]
set the default handler for exception occurring after a timeout.
set_level [Lwt_log.Section]
set_level section sets the logging level of the given section
set_max_number_of_threads_queued [Lwt_preemptive]
Sets the size of the waiting queue, if no more preemptive threads are available.
set_position [Lwt_io]
set_position ch pos Sets the position in the output channel.
setsockopt [Lwt_unix]
Wrapper for Unix.setsockopt
setsockopt_float [Lwt_unix]
Wrapper for Unix.setsockopt_float
setsockopt_int [Lwt_unix]
Wrapper for Unix.setsockopt_int
setsockopt_optint [Lwt_unix]
Wrapper for Unix.setsockopt_optint
shell [Lwt_process]
A command executed with "/bin/sh"
show [Lwt_read_line.Control]
Un-hide everything
show_cursor [Lwt_term]
show_cursor () makes the cursor visible
shutdown [Lwt_ssl]
shutdown [Lwt_unix]
Wrapper for Unix.shutdown
shutdown_server [Lwt_io]
Shutdown the given server
signal [Lwt_condition]
signal condvar value notifies that a condition is ready.
simple_init [Lwt_preemptive]
simple_init () does a simple initialization.
size [Lwt_term]
Size of the terminal.
sleep [Lwt_unix]
sleep d is a threads which remain suspended for d seconds and then terminates.
socket [Lwt_unix]
socket domain type proto is the same as Unix.socket but maps the result into a lwt file descriptor
socketpair [Lwt_unix]
Wrapper for Unix.socketpair
ssl_accept [Lwt_ssl]
ssl_connect [Lwt_ssl]
ssl_shutdown [Lwt_ssl]
standard_input [Lwt_term]
The input stream used by Lwt_term.read_key
start [Lwt_timeout]
starts a timeout.
state [Lwt_unix]
state fd returns the state of fd
state [Lwt]
state t returns the state of a thread
stderr [Lwt_text]
stderr [Lwt_io]
The standard output for error messages, it writes data to Lwt_unix.stderr
stderr [Lwt_unix]
The standard file descriptor for printing error messages
stdin [Lwt_text]
stdin [Lwt_io]
The standard input, it reads data from Lwt_unix.stdin
stdin [Lwt_unix]
The standard file descriptor for input.
stdout [Lwt_text]
stdout [Lwt_io]
The standard output, it writes data to Lwt_unix.stdout
stdout [Lwt_unix]
The standard file descriptor for output
stop [Lwt_timeout]
stops a timeout.
string_of_key [Lwt_term]
string_of_key key string representation of a key
strip_styles [Lwt_term]
Drop all styles
styled_length [Lwt_term]
Returns the length (in unicode character) of the given styled text.
sub [Lwt_term.Zone]
sub ~zone ~x ~y ~width ~height creates a sub-zone of zone.
syslog [Lwt_log]
syslog ?template ?paths ~facility () creates an logger which send message to the system logger.
system [Lwt_unix]
Wrapper for Unix.system
system_byte_order [Lwt_io]
The byte order used by the computer running the program

T
take [Lwt_mvar]
take mvar will take any currently available value from the mailbox variable.
take_l [Lwt_sequence]
take_l x s remove and returns the leftmost element of s
take_opt_l [Lwt_sequence]
take_opt_l x s remove and returns Some x where x is the leftmost element of s or None if s is empty
take_opt_r [Lwt_sequence]
take_opt_l x s remove and returns Some x where x is the rightmost element of s or None if s is empty
take_r [Lwt_sequence]
take_l x s remove and returns the rightmost element of s
task [Lwt]
task () is the same as wait () except that threads created with task can be canceled.
tcdrain [Lwt_unix]
Wrapper for Unix.tcdrain
tcflow [Lwt_unix]
Wrapper for Unix.tcflow
tcflush [Lwt_unix]
Wrapper for Unix.tcflush
tcgetattr [Lwt_unix]
Wrapper for Unix.tcgetattr
tcsetattr [Lwt_unix]
Wrapper for Unix.tcsetattr
text [Lwt_term.Draw]
Draw the given text at the given positon
text [Lwt_term]
textc [Lwt_term.Draw]
Same as Lwt_term.Draw.text but takes a text with styles
textf [Lwt_term.Draw]
Same as Lwt_term.Draw.text but uses a format string
textf [Lwt_term]
textf fmt formats a texts with fmt and returns Text txt
timeout [Lwt_unix]
timeout d is a threads which remain suspended for d seconds then fail with Lwt_unix.Timeout
to_list [Lwt_stream]
Returns the list of elements of the given stream
to_stream [Lwt_event]
Creates a stream holding all values occurring on the given event
to_string [Lwt_read_line.Command]
to_string cmd returns a string representation of a command
to_string [Lwt_stream]
Returns the word composed of all characters of the given stream
transfer_l [Lwt_sequence]
transfer_l s1 s2 removes all elements of s1 and add them at the left of s2.
transfer_r [Lwt_sequence]
transfer_r s1 s2 removes all elements of s1 and add them at the right of s2.
try_bind [Lwt]
try_bind t f g behaves as bind (t ()) f if t does not fail.

U
underlined [Lwt_term]
unix_file_descr [Lwt_unix]
Returns the underlying unix file descriptor.
unlock [Lwt_mutex]
unlock mutex unlock the mutex if no threads is waiting on it.
update [Lwt_read_line.Engine]
update ~state ?clipboard ~command () update an engine state by processing the given command.
use [Lwt_pool]
use p f takes one free member of the pool p and gives it to the function f.

W
wait [Lwt_unix]
Wrapper for Unix.wait
wait [Lwt_throttle.S]
wait [Lwt_condition]
wait mutex condvar will cause the current thread to block, awaiting notification for a condition variable, condvar.
wait [Lwt]
wait () is a pair of a thread which sleeps forever (unless it is resumed by one of the functions wakeup, wakeup_exn below) and the corresponding wakener.
wait4 [Lwt_unix]
wait4 flags pid returns (pid, status, rusage) where (pid, status) is the same result as Unix.waitpid flags pid, and rusage contains accounting information about the child.
wait_read [Lwt_ssl]
wait_read [Lwt_unix]
waits (without blocking other threads) until there is something to read on the file descriptor
wait_write [Lwt_ssl]
wait_write [Lwt_unix]
waits (without blocking other threads) until it is possible to write on the file descriptor
waitpid [Lwt_unix]
Wrapper for Unix.waitpid
wakeup [Lwt]
wakeup t e makes the sleeping thread t terminate and return the value of the expression e.
wakeup_exn [Lwt]
wakeup_exn t e makes the sleeping thread t fail with the exception e.
wakeup_paused [Lwt]
wakeup_paused () wakes up all threads which suspended themselves with Lwt.pause.
warning [Lwt_log]
warning_f [Lwt_log]
white [Lwt_term]
width [Lwt_term.Zone]
with_connection [Lwt_io]
with_connection ?buffer_size ~mode addr f open a connection to the given address and passes the channels to f
with_file [Lwt_text]
with_file [Lwt_io]
with_file ?buffer_size ?flags ?perm ~mode filename f open a file and passes the channel to f.
with_finaliser [Lwt_signal]
with_finaliser f signal returns a signal signal' which behave as signal, except that f is called when signal' is garbage collected.
with_finaliser [Lwt_event]
with_finaliser f event returns an event event' which behave as event, except that f is called when event' is garbage collected.
with_lock [Lwt_mutex]
with_lock lock f is used to lock a mutex within a block scope.
with_process [Lwt_process]
with_process_full [Lwt_process]
with_process_in [Lwt_process]
with_process_none [Lwt_process]
with_process_out [Lwt_process]
with_raw_mode [Lwt_term]
with_raw_mode f executes f while the terminal is in ``raw mode''.
with_timeout [Lwt_unix]
with_timeout d f is a short-hand for:
wrap_syscall [Lwt_unix]
wrap_syscall set fd action wrap an action on a file descriptor.
write [Lwt_text]
write [Lwt_ssl]
write [Lwt_io]
write oc str writes all characters of str on oc
write [Lwt_unix]
read fd buf ofs len has the same semantic as Unix.write, but is cooperative
write_char [Lwt_text]
write_char [Lwt_io]
write_char oc char writes char on oc
write_chars [Lwt_text]
write_chars [Lwt_io]
write_chars oc chars writes all characters of chars on oc
write_float32 [Lwt_io.NumberIO]
Writes an IEEE single precision floating point value
write_float64 [Lwt_io.NumberIO]
Writes an IEEE double precision floating point value
write_from [Lwt_io]
write_from oc buffer offset length writes up to length bytes to oc, from buffer at offset offset and returns the number of bytes actually written
write_from_exactly [Lwt_io]
write_from_exactly oc buffer offset length writes all length bytes from buffer at offset offset to oc
write_int [Lwt_io.NumberIO]
Writes an ocaml int as a 32-bits integer
write_int16 [Lwt_io.NumberIO]
write_int32 [Lwt_io.NumberIO]
write_int64 [Lwt_io.NumberIO]
write_line [Lwt_text]
write_line [Lwt_io]
write_line oc str writes str on oc followed by a new-line.
write_lines [Lwt_text]
write_lines [Lwt_io]
write_lines oc lines writes all lines of lines to oc
write_styled [Lwt_term]
write_styled oc st writes st on oc using escape sequences.
write_value [Lwt_io]
write_value oc ?flags x marshals the value x to oc

X
x [Lwt_term.Zone]

Y
y [Lwt_term.Zone]
yellow [Lwt_term]
yield [Lwt_unix]
yield () is a threads which suspends itself and then resumes as soon as possible and terminates.

Z
zero [Lwt_text]
zero [Lwt_io]
Inputs which returns always '\x00'