Index of values

t <&> t' is the same as join [t; t']

t <?> t' is the same as choose [t; t']

f =<< t is t >>= f

f =|< m is map f m

t >>= f is an alternative notation for bind t f.

m >|= f is map f m

abort ch abort current operations and close the channel immediatly.

abort fd exn makes all current and further uses of the file descriptor fail with the given exception.

accept instance = send_command instance Command.Accept_line

Wrapper for Unix.accept

accept_n fd count accepts up to count connection in one time.

accum ?eq event_f initial

add_entry line history returns the history history plus line at the beginning.

add_l x s adds x to the left of the sequence s

add_l x s adds x to the right of the sequence s

Returns the current complete user input.

Same as notify but does not return a notifier

Same as notify but does not return a notifier

Same as notify_p but does not return a notifier

Same as notify_p but does not return a notifier

Same as notify_s but does not return a notifier

Same as notify_s but does not return a notifier

app_s ?eq signal_f initial signal_x

append s1 s2 returns a stream which returns all elements of s1, then all elements of s2

apply_filters select apply all the filters on the given select function.

at_exit hook adds hook at the left of exit_hooks

atomic f transforms a sequence of io operations into one single atomic io operation.

auto_yield timeout returns a function f which will yield every timeout seconds.

bg col = Background col

bind signal f is initially f x where x is the current value of signal.

Wrapper for Unix.bind

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.

A space with default color and styles

block ch size f pass to f the internal buffer and an offset.

blocking fd returns whether fd is used in blocking or non-blocking mode.

broadcast loggers is a logger which send messages to all the given loggers.

broadcast condvar value notifies all waiting threads.

Returns the size of the internal buffer.

buffered oc returns the number of bytes in the buffer

byte_channel ch returns the underlying byte channel of a text channel

cancel t cancels the threads t.

catch t f is a thread that behaves as the thread t () if this thread succeeds.

changes the duration of a timeout.

channel ?template ~close_mode ~channel () creates a logger from a channel.

chars_of_file name returns a stream of all characters of the file with name name.

chars_to_file name chars writes all characters of chars to name

check_descriptor fd raise an exception if fd is not in the state Open

choose l creates an stream from a list of streams.

choose l behaves as the first thread in l to terminate.

Wrapper for Unix.clear_close_on_exec

clear_line () clears the current line

clear_screen () clears the entire screen

The global clipboard.

clone st clone the given stream.

Close the underlying byte channel

Close the given logger

close ch closes the given channel.

Close a file descriptor.

Close a directory descriptor.

Number of columns of the terminal

combine s1 s2 combine two streams.

complete ?suffix before word after words basic completion functions.

Return the current completion mode.

concat st returns the concatenation of all streams of st.

Wrapper for Unix.connect

Mapping from control key codes to character codes.

create n f defines a new timeout with n seconds duration.

create () creates a new condition variable.

create n f creates a new pool with at most n members.

create () creates a new mutex, which is initially unlocked

create v creates a new mailbox variable containing value v.

create () creates a new empty sequence

create () returns a new stream and a push function

create () creates a new empty mailbox variable.

Put the current running process into daemon mode.

Decode a key.

The default logger.

Return the default size for buffers.

The default iteration function.

The default select function.

detaches a computation to a preemptive thread.

diff_s f signal

direct_access ch f pass to f a Lwt_io.direct_access structure.

disable notif stops the corresponding signal to be monitored

disable notif stops the corresponding event to be monitored

Stops receiving this signal

dispatch f is a logger which dispatch logging instructions to different logger according to their level and/or section.

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.

Wrapper for Unix.dup

Wrapper for Unix.dup2

Returns the edition state of a state, whatever its mode is.

encoding ch returns the character encoding of a channel.

Return the engine state of the given state

Put the terminal into drawing mode

Same as printc but prints on stderr.

Same as printlc but prints on stderr

erase ~columns ~render_state () returns a text which will erase everything (the prompt, user input, completion, ...).

establich_server ?buffer_size ?backlog sockaddr f creates a server which will listen for incomming connections.

Executes the given command and returns its exit status.

Sets of functions executed just before the program exit.

fail e is a thread that fails with the exception e.

Wrapper for Unix.fchmod

Wrapper for Unix.fchown

fg col = Foreground col

desf_file ?template ?mode ?perm ~file_name () creates an logger which will write messages to file_name.

Returns the length of a file

filter_map f st filter and map st at the same time

filter_s ?eq f initial signal

filter f st keeps only value x such that f x is true

finalise f x calls f x when x is garbage collected.

finalise_or_exit f x call f x when x is garbage collected or (exclusively) when the program exit.

finalize f g returns the same result as f () whether it fails or not.

find f s find and map at the same time.

find f s find an element in a stream.

flatten st = map_list (fun l -> l) st

Flush the underlying byte channel

flush oc performs all pending writes on oc

fmap ?eq f initial signal

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_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 ?eq f initial event

fold f s x fold_like function for streams.

from f creates an event which occurs each f () returns a value.

from f creates an stream from the given input function.

Wrapper for Unix.fstat

Wrapper for Unix.ftruncate

get ~zone ~x ~y returns the point at relative position x and y.

Returns the contents of a node

get st remove and returns the first element of the stream, if any.

get_available l returns all available elements of l without blocking

get_available_up_to l n returns up to n elements of l without blocking

get_bounds () returns the minimum and the maximum number of preemptive threads.

get_credentials fd returns credential informations from the given socket.

Returns the size of the waiting queue, if no more threads are available

get_while f st returns the longest prefix of st where all elements satisfy f.

Cooperative getaddrinfo with cache (using Lwt_preemptive.detach)

Cooperative gethostbyname with cache (using Lwt_preemptive.detach)

Cooperative getnameinfo with cache (using Lwt_preemptive.detach)

Wrapper for Unix.getpeername

Wrapper for Unix.getsockname

Wrapper for Unix.getsockopt

Wrapper for Unix.getsockopt_error

Wrapper for Unix.getsockopt_float

Wrapper for Unix.getsockopt_int

Wrapper for Unix.getsockopt_optint

goto_beginning_of_line n put the cursor at the beginning of the nth previous line.

Same as Unix.handle_unix_error but catches lwt-level exceptions

Whether the wait4 system call is available on this system.

hexdump oc str = hexdump_stream oc (Lwt_stream.of_string str)

hexdump byte_stream returns a stream which is the same as the output of hexdump -C.

hexdump_stream oc byte_stream produces the same output as the command hexdump -C.

Hides everything (prompt, user input, completion box) until Lwt_read_line.Control.show is called.

hide_cursor () makes the cursor invisible

ignore_result t start the thread t and ignores its result value if the thread terminates sucessfully.

Initial state

init history return a initial state using the given history

Initialises glib and integrates the Lwt scheduler into the glib main loop.

init min max log initialises this module.

inner zone returns the inner part of zone

input input mode representation

The set of action waiting for a file descriptor to become readable

accept instance = send_command instance Command.Break

Creates an io-vector

is_empty mutex returns true if they are no thread waiting on the mutex, and false otherwise

Returns true iff the given sequence is empty

is_empty enum returns wether the given stream is empty

locked mutex returns whether mutex is currently locked

Are we using an SSL socket?

Wrapper for Unix.isatty

iter_l f s applies f on all elements of s starting from the left

iter_l f s applies f on all nodes of s starting from the left

iter_l f s applies f on all nodes of s starting from the right

iter_l f s applies f on all elements of s starting from the right

iter f s iterates over all elements of the stream

join l wait for all threads in l to terminate.

junk st remove the first element of st.

junk_old st removes all elements that are ready to be read without yeilding from st.

junk_while f st removes all elements at the beginning of the streams which satisfy f.

key_backspace = Key_control '?'

key_enter = Key_control 'j'

key_escape = Key_control '['

key_escape = Key_control 'i'

Draw for the last time, i.e.

next_new st if no element are available on st without sleeping, then it is the same as next st.

Restore the state of the terminal

Returns the length of the channel in bytes

level section returns the logging level of section

limit f signal limits the rate of signal update with f.

limit f event limits the rate of event with f.

Number of lines of the terminal

lines_of_file name returns a stream of all lines of the file with name name.

lines_to_file name lines writes all lines of lines to files

Wrapper for Unix.listen

load_history filename loads history from filename.

lock mutex lockcs the mutex, that is:

Wrapper for Unix.lockf

log ?section ?logger ~level message logs a message.

log_f is the same as log except that it takes a format string

lookup word words lookup for completion of word into words.

Wrapper for Unix.lseek

The main section.

The function doing one step of the main loop.

Creates a new read-line instance with the given parameters.

Make a new zone where all points are initialized to Lwt_term.blank

make ?strict ?encoding ch creates a text channel from a byte channel.

make name creates a section with the given name, with level initialised according to the LWT_LOG environment variable.

make ~output ~close creates a new logger.

make ?buffer_size ?close ~mode perform_io is the main function for creating new channels.

map ~zone ~x ~y f replace the point at coordinates (x, y) by the result of f applied on it.

map f m map the result of a thread.

map_list f st applies f on each element of st and flattens the lists returned

map_s ?eq f initial signal

map f st maps the value returned by st with f

merge ?eq f initial signals

min_timeout a b returns the smallest timeout of two timeouts.

mode ch returns the mode of a channel

name section returns the name of section

names is the list of all commands (except Char ch) with their name.

nchoose l returns the value of all that have succcessfully terminated.

next ev returns the next occurrence of ev

next st remove and returns the next element of the stream, of fail with Lwt_stream.Empty if the stream is empty.

nget n st remove and returns at most the first n elements of st.

njunk n st removes at most the first n elements of the stream.

notify f s calls f each time the value of s change

notify f ev calls f x each time ev has a value x

notify_p f s is the same as notify except that f x is a thread.

notify_p f ev is the same as notify except that f x is a thread.

notify_s f s is the same as notify except that f x is a thread.

notify_s f ev is the same as notify except that f x is a thread.

npeek n st returns at most the first n elements of st, without removing them.

npick l is the same as Lwt.nchoose, except that it cancels all sleeping threads when one terminates.

Logger which drops everything

Output which drops everything

of_fd ?buffer_size ?close ~mode fd creates a channel from a file descriptor.

of_key key returns the command to which a key is mapped.

of_list l creates a stream returns all elements of l

of_stream stream creates an event which occurs each time a value is available on the stream.

of_string cld tries to convert a command name to a command.

Create a channel from a string.

of_string str creates a stream returning all characters of str

of_unix_fd ?buffer_size ?close ~mode fd is a short-hand for:

Creates a lwt file descriptor from a unix one.

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 t f executes f when t is canceled.

on_signal signum f calls f each time the signal with numnber signum is received by the process.

open_connection ?buffer_size ~mode addr open a connection to the given address and returns two channels for using it.

open_file ?buffer_size ?flags ?perm ~mode filename open the file with name filename and returns a channel for reading/writing it.

Open a descriptor on a directory

Wrapper for Unix.openfile

output output mode representation

The set of action waiting for a file descriptor to become writable

parse st f parses st with f.

parse_key_raw st recognize escape sequence in a stream of unicode character.

pause () is a sleeping thread which is wake up on the next call to Lwt.wakeup_paused.

peek st returns the first element of the stream, if any, without removing it.

pick l is the same as Lwt.choose, except that it cancels all sleeping threads when one terminates.

pipe ?buffer_size () creates a pipe using Lwt_unix.pipe and makes two channels from the two returned file descriptors

pipe () creates pipe using Unix.pipe and returns two lwt file descriptors created from unix file_descriptor

pipe_in () is the same as Lwt_unix.pipe but maps only the unix file descriptor for reading into a lwt one.

pipe_out () is the inverse of Lwt_unix.pipe_in.

position ch Returns the current position in the channel.

print_words oc columns strs pretty-prints a list of words.

printc st prints the given styled text on standard output.

printlc st prints st, then reset styles and prints a newline

protected thread creates a new cancelable thread which behave as thread except that cancelling it does not cancel thread.

put mvar value puts a value into a mailbox variable.

Calls GMain.quit and remove the Lwt scheduler from the glib main loop

Returns wether the terminal is currently in raw mode

read ?count ic reads at most len characters from ic.

read fd buf ofs len has the same semantic as Unix.read, but is cooperative

read_char ic reads the next character of ic.

Same as read_byte but does not raises End_of_file on end of input

read_chars ic returns a stream holding all characters of ic

Reads an IEEE single precision floating point value

Reads an IEEE double precision floating point value

Reads a 32-bits integer as an ocaml int

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 ic buffer offset length reads exactly length bytes and stores them in buffer at offset offset.

Get and decode a key from Lwt_term.standard_input

read_keyword ?history ?case_sensitive ?mode ~prompt ~keywords () reads one word which is a member of words.

readline ?history ?complete ?mode ?prompt () inputs some text from the user.

read_line ic reads one complete line from ic and returns it without the end of line.

Same as Lwt_io.read_line but do not raise End_of_file on end of input.

read_lines ic returns a stream holding all lines of ic

read_password ?clipboard ?clear ~prompt () inputs a password from the user.

read_value ic reads a marshaled value from ic

read_yes_no ?history ?dynamic prompt () is the same as:

Return the next entry in a directory.

Wrapper for Unix.recv

recv_msg ~socket ~io_vectors receives data into a list of io-vectors, plus any file-descriptors that may accompany the message.

Wrapper for Unix.recvfrom

register_action set fd action registers action on fd.

Removes a node from the sequence it is part of.

Render an offscreen array to the terminal.

render ~buffer ~template ~section ~level ~message instantiate all variables of template, and store the result in buffer.

Return the rendering state of the given state

reset state reset the given state, if the user was doing a selection, it is canceled

Resize the internal buffer to the given size

Threads waiting for the read-line instance to terminates

Same as React.S.const

return e is a thread whose return value is the value of the expression e.

Reposition the descriptor to the beginning of the directory

run t calls the Lwt scheduler repeatedly until t terminates, then returns the value returned by the thread.

sample f event signal

save_history filename history saves history to filename.

The set of all select filters.

Wrapper for Unix.send

send_command instance command sends the given command to the read-line instance

send_msg ~socket ~io_vectors ~fds sends data from a list of io-vectors, accompanied with a list of file-descriptor.

Wrapper for Unix.sendto

Mapping from sequence to keys

set ~zone ~x ~y ~popint sets point at relative position x and y.

Change the contents of a node

set_blocking fd b puts fd in blocking or non-blocking mode.

set_bounds (min, max) set the minimum and the maximum number of preemptive threads.

Wrapper for Unix.set_close_on_exec

set_color num (red, green, blue) sets the three components of the color number num

Change the completion mode

Change the default buffer size.

set the default handler for exception occurring after a timeout.

set_level section sets the logging level of the given section

Sets the size of the waiting queue, if no more preemptive threads are available.

set_position ch pos Sets the position in the output channel.

Wrapper for Unix.setsockopt

Wrapper for Unix.setsockopt_float

Wrapper for Unix.setsockopt_int

Wrapper for Unix.setsockopt_optint

A command executed with "/bin/sh"

Un-hide everything

show_cursor () makes the cursor visible

Wrapper for Unix.shutdown

Shutdown the given server

signal condvar value notifies that a condition is ready.

simple_init () does a simple initialization.

Size of the terminal.

sleep d is a threads which remain suspended for d seconds and then terminates.

socket domain type proto is the same as Unix.socket but maps the result into a lwt file descriptor

Wrapper for Unix.socketpair

The input stream used by Lwt_term.read_key

starts a timeout.

state fd returns the state of fd

state t returns the state of a thread

The standard output for error messages, it writes data to Lwt_unix.stderr

The standard file descriptor for printing error messages

The standard input, it reads data from Lwt_unix.stdin

The standard file descriptor for input.

The standard output, it writes data to Lwt_unix.stdout

The standard file descriptor for output

stops a timeout.

string_of_key key string representation of a key

Drop all styles

Returns the length (in unicode character) of the given styled text.

sub ~zone ~x ~y ~width ~height creates a sub-zone of zone.

syslog ?template ?paths ~facility () creates an logger which send message to the system logger.

Wrapper for Unix.system

The byte order used by the computer running the program

take mvar will take any currently available value from the mailbox variable.

take_l x s remove and returns the leftmost element of s

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_l x s remove and returns Some x where x is the rightmost element of s or None if s is empty

take_l x s remove and returns the rightmost element of s

task () is the same as wait () except that threads created with task can be canceled.

Wrapper for Unix.tcdrain

Wrapper for Unix.tcflow

Wrapper for Unix.tcflush

Wrapper for Unix.tcgetattr

Wrapper for Unix.tcsetattr

Draw the given text at the given positon

Same as Lwt_term.Draw.text but takes a text with styles

Same as Lwt_term.Draw.text but uses a format string

textf fmt formats a texts with fmt and returns Text txt

timeout d is a threads which remain suspended for d seconds then fail with Lwt_unix.Timeout

Returns the list of elements of the given stream

Creates a stream holding all values occurring on the given event

to_string cmd returns a string representation of a command

Returns the word composed of all characters of the given stream

transfer_l s1 s2 removes all elements of s1 and add them at the left of s2.

transfer_r s1 s2 removes all elements of s1 and add them at the right of s2.

try_bind t f g behaves as bind (t ()) f if t does not fail.

Returns the underlying unix file descriptor.

unlock mutex unlock the mutex if no threads is waiting on it.

update ~state ?clipboard ~command () update an engine state by processing the given command.

use p f takes one free member of the pool p and gives it to the function f.

Wrapper for Unix.wait

wait mutex condvar will cause the current thread to block, awaiting notification for a condition variable, condvar.

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 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.

waits (without blocking other threads) until there is something to read on the file descriptor

waits (without blocking other threads) until it is possible to write on the file descriptor

Wrapper for Unix.waitpid

wakeup t e makes the sleeping thread t terminate and return the value of the expression e.

wakeup_exn t e makes the sleeping thread t fail with the exception e.

wakeup_paused () wakes up all threads which suspended themselves with Lwt.pause.

with_connection ?buffer_size ~mode addr f open a connection to the given address and passes the channels to f

with_file ?buffer_size ?flags ?perm ~mode filename f open a file and passes the channel to f.

with_finaliser f signal returns a signal signal' which behave as signal, except that f is called when signal' is garbage collected.

with_finaliser f event returns an event event' which behave as event, except that f is called when event' is garbage collected.

with_lock lock f is used to lock a mutex within a block scope.

with_raw_mode f executes f while the terminal is in ``raw mode''.

with_timeout d f is a short-hand for:

wrap_syscall set fd action wrap an action on a file descriptor.

write oc str writes all characters of str on oc

read fd buf ofs len has the same semantic as Unix.write, but is cooperative

write_char oc char writes char on oc

write_chars oc chars writes all characters of chars on oc

Writes an IEEE single precision floating point value

Writes an IEEE double precision floating point value

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 oc buffer offset length writes all length bytes from buffer at offset offset to oc

Writes an ocaml int as a 32-bits integer

write_line oc str writes str on oc followed by a new-line.

write_lines oc lines writes all lines of lines to oc

write_styled oc st writes st on oc using escape sequences.

write_value oc ?flags x marshals the value x to oc

yield () is a threads which suspends itself and then resumes as soon as possible and terminates.

Inputs which returns always '\x00'