| (<&>) [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_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
immediatly.
|
| 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 [Lwt_read_line.Control] | accept instance = send_command instance Command.Accept_line
|
| accept_n [Lwt_unix] | accept_n fd count accepts up to count connection in one time.
|
| access [Lwt_unix] |
Wrapper for
Unix.access
|
| accum_s [Lwt_react.S] | |
| accum_s [Lwt_react.E] | |
| accum_s [Lwt_signal] | |
| accum_s [Lwt_event] | |
| add [Lwt_pqueue.S] | |
| add_entry [Lwt_read_line] | add_entry line history returns the history history plus
line at the beginning.
|
| add_hook [Lwt_switch] | |
| add_hook_or_exec [Lwt_switch] | add_hook_or_exec switch f is the same as Lwt_switch.add_hook except
that if the switch is already off, then f is called
immediatly.
|
| 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] | 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.
|
| all_input [Lwt_read_line.Engine] |
Returns the current complete user input.
|
| always_notify [Lwt_signal] | |
| always_notify [Lwt_event] | |
| always_notify_p [Lwt_signal] | |
| always_notify_p [Lwt_event] | |
| always_notify_s [Lwt_signal] | |
| always_notify_s [Lwt_event] | |
| app_p [Lwt_react.E] | |
| app_p [Lwt_event] | |
| app_s [Lwt_react.S] | |
| app_s [Lwt_react.E] | |
| app_s [Lwt_signal] | |
| app_s [Lwt_event] | |
| append [Lwt_stream] | append s1 s2 returns a stream which returns all elements of
s1, then all elements of s2
|
| append_rule [Lwt_log] | 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.
|
| atomic [Lwt_text] | |
| 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_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_signal] | |
| 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.
|
| black [Lwt_term] | |
| blank [Lwt_term] |
A space with default color and styles
|
| blink [Lwt_term] | |
| blit [Lwt_bytes] | blit buf1 ofs1 buf2 ofs2 len copy len bytes from buf1
starting at offset ofs1 to buf2 starting at offset ofs2.
|
| blit_bytes_string [Lwt_bytes] |
Same as blit but the second buffer is a string instead of a byte
array.
|
| blit_string_bytes [Lwt_bytes] |
Same as blit but the first 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.
|
| 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
|
| 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_of_file [Lwt_text] | |
| chars_to_file [Lwt_io] | chars_to_file name chars writes all characters of chars to
name
|
| chars_to_file [Lwt_text] | |
| 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 raise 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
|
| 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_unix] |
Close a file descriptor.
|
| close [Lwt_log] |
Close the given logger
|
| close [Lwt_io] | close ch closes the given channel.
|
| close [Lwt_text] |
Close the underlying byte channel
|
| close [Lwt_ssl] | |
| close_in [Lwt_chan] | |
| close_out [Lwt_chan] | |
| closedir [Lwt_unix] |
Wrapper for
Unix.closedir
|
| columns [Lwt_term] |
Number of columns of the terminal
|
| combine [Lwt_stream] | combine s1 s2 combine two streams.
|
| compare [Lwt_pqueue.OrderedType] | |
| 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.
|
| 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.
|
| 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_log] |
The default logger.
|
| default [Lwt_term] | |
| 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.
|
| delay [Lwt_signal] | |
| delay [Lwt_event] | |
| detach [Lwt_preemptive] |
detaches a computation to a preemptive thread.
|
| diff_s [Lwt_react.S] | |
| diff_s [Lwt_react.E] | |
| diff_s [Lwt_signal] | |
| diff_s [Lwt_event] | |
| direct_access [Lwt_io] | |
| disable [Lwt_signal] | |
| disable [Lwt_event] | |
| 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.
|
| embed_socket [Lwt_ssl] | |
| empty [Lwt_pqueue.S] | |
| 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
|
| enter_iter_hooks [Lwt_main] |
Functions that are called before the main iteration.
|
| eprint [Lwt_io] | |
| eprint [Lwt_text] | |
| eprintc [Lwt_term] |
Same as
printc but prints on stderr.
|
| eprintf [Lwt_io] | |
| eprintf [Lwt_text] | |
| eprintl [Lwt_io] | |
| eprintl [Lwt_text] | |
| eprintlc [Lwt_term] |
Same as
printlc but prints on stderr
|
| eprintlf [Lwt_io] | |
| eprintlf [Lwt_text] | |
| 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.
|
| 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.
|
| fake_event [Lwt_engine] |
Event which does nothing when stopped.
|
| fake_io [Lwt_engine] |
Simulates activity on the given file descriptor.
|
| fatal [Lwt_log] | |
| fatal_f [Lwt_log] | |
| 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.
|
| 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
|
| 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_s [Lwt_stream] | filter_map f st filter and map st at the same time
|
| filter_p [Lwt_react.E] | |
| filter_p [Lwt_event] | |
| filter_p [Lwt_list] | |
| filter_s [Lwt_react.S] | |
| filter_s [Lwt_react.E] | |
| filter_s [Lwt_signal] | |
| filter_s [Lwt_event] | |
| 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 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_min [Lwt_pqueue.S] | |
| 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 [Lwt_text] |
Flush the underlying byte channel
|
| flush_all [Lwt_io] | flush_all () flushes all open output channels
|
| fmap_p [Lwt_react.E] | |
| fmap_p [Lwt_event] | |
| fmap_s [Lwt_react.S] | |
| fmap_s [Lwt_react.E] | |
| fmap_s [Lwt_signal] | |
| fmap_s [Lwt_event] | |
| fold [Lwt_stream] | |
| fold_l [Lwt_sequence] | fold_l f s is:
where e1, e2, ..., en are the elements of s
|
| fold_left [Lwt_util] |
Similar to
List.fold_left.
|
| fold_left_s [Lwt_list] | |
| fold_r [Lwt_sequence] | fold_r f s is:
where e1, e2, ..., en are the elements of s
|
| fold_right_s [Lwt_list] | |
| fold_s [Lwt_react.S] | |
| fold_s [Lwt_react.E] | |
| fold_s [Lwt_signal] | |
| 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] | |
| fork [Lwt_unix] | fork () does the same as Unix.fork.
|
| fprint [Lwt_io] | |
| fprint [Lwt_text] | |
| fprintf [Lwt_io] | |
| fprintf [Lwt_text] | |
| fprintl [Lwt_io] | |
| fprintl [Lwt_text] | |
| fprintlf [Lwt_io] | |
| fprintlf [Lwt_text] | |
| from [Lwt_react.E] | from f creates an event which occurs each time f ()
returns a value.
|
| from [Lwt_event] | |
| 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_term.Draw] | get ~zone ~x ~y returns the point at relative position x
and y.
|
| 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 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_unix] |
Wrapper for
Unix.getaddrinfo
|
| getaddrinfo [Lwt_lib] |
Cooperative getaddrinfo with cache (using Lwt_preemptive.detach)
|
| 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
|
| gethostbyname [Lwt_lib] |
Cooperative gethostbyname with cache (using Lwt_preemptive.detach)
|
| gethostname [Lwt_unix] |
Wrapper for
Unix.gethostname
|
| getlogin [Lwt_unix] |
Wrapper for
Unix.getlogin
|
| getnameinfo [Lwt_unix] |
Wrapper for
Unix.getnameinfo
|
| getnameinfo [Lwt_lib] |
Cooperative getnameinfo with cache (using Lwt_preemptive.detach)
|
| 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
|
| 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
|
| have [Lwt_sys] |
Test whether the given feature is available on the current
system.
|
| height [Lwt_term.Zone] | |
| hexdump [Lwt_io] | hexdump oc str = hexdump_stream oc (Lwt_stream.of_string str)
|
| hexdump [Lwt_text] | |
| 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.
|
| hexdump_stream [Lwt_text] | |
| 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 | |
| ign_debug [Lwt_log] | |
| ign_debug_f [Lwt_log] | |
| ign_error [Lwt_log] | |
| ign_error_f [Lwt_log] | |
| ign_fatal [Lwt_log] | |
| ign_fatal_f [Lwt_log] | |
| ign_info [Lwt_log] | |
| ign_info_f [Lwt_log] | |
| ign_log [Lwt_log] |
Same as
Lwt_log.log but ignore the resulting thread.
|
| ign_log_f [Lwt_log] |
Same as
Lwt_log.log_f but ignore the resulting thread.
|
| ign_notice [Lwt_log] | |
| ign_notice_f [Lwt_log] | |
| ign_warning [Lwt_log] | |
| ign_warning_f [Lwt_log] | |
| 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] | |
| 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_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
|
| 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.
|
| interrupt [Lwt_read_line.Control] | accept instance = send_command instance Command.Break
|
| inverse [Lwt_term] | |
| 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_util] | iter f l start a thread for each element in l.
|
| 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] | |
| iter_serial [Lwt_util] |
Similar to
iter but wait for one thread to terminate before
starting the next one.
|
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.
|
| 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_react.S] | |
| l1_s [Lwt_signal] | |
| l2_s [Lwt_react.S] | |
| l2_s [Lwt_signal] | |
| l3_s [Lwt_react.S] | |
| l3_s [Lwt_signal] | |
| l4_s [Lwt_react.S] | |
| l4_s [Lwt_signal] | |
| l5_s [Lwt_react.S] | |
| l5_s [Lwt_signal] | |
| l6_s [Lwt_react.S] | |
| l6_s [Lwt_signal] | |
| last_draw [Lwt_read_line.Terminal] |
Draw for the last time, i.e.
|
| 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.
|
| lblack [Lwt_term] | |
| lblue [Lwt_term] | |
| lcyan [Lwt_term] | |
| leave_drawing_mode [Lwt_term] |
Restore the state of the terminal
|
| 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.Section] | level section returns the logging level of section.
|
| lgreen [Lwt_term] | |
| 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.
|
| limit [Lwt_signal] | |
| limit [Lwt_event] | |
| lines [Lwt_term] |
Number of lines of the terminal
|
| lines_of_file [Lwt_io] | lines_of_file name returns a stream of all lines of the file
with name name.
|
| lines_of_file [Lwt_text] | |
| lines_to_file [Lwt_io] | lines_to_file name lines writes all lines of lines to
files
|
| lines_to_file [Lwt_text] | |
| link [Lwt_unix] |
Wrapper for
Unix.link
|
| listen [Lwt_unix] |
Wrapper for
Unix.listen
|
| lmagenta [Lwt_term] | |
| load_history [Lwt_read_line] | load_history filename loads history from filename.
|
| location_key [Lwt_log] |
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] | 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.
|
| lookup_min [Lwt_pqueue.S] | |
| lred [Lwt_term] | |
| 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
|
| lwhite [Lwt_term] | |
| lyellow [Lwt_term] | |
M | |
| madvise [Lwt_bytes] | madvise buffer pos len advice advise the kernel about how the
program is going to use the part of the memory mapped file
between pos and pos + len.
|
| magenta [Lwt_term] | |
| main [Lwt_log.Section] |
The main section.
|
| make [Lwt_log.Section] | make name creates a section with the given name.
|
| 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.
|
| 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_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_region [Lwt_util] | make_region sz create a region of size sz.
|
| make_value [Lwt] | value x creates a result containing the value x.
|
| 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_util] | map f l apply f to each element in l and collect the
results of the threads thus created.
|
| map [Lwt_stream] | |
| map [Lwt] | map f m map 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_event] | |
| map_p [Lwt_list] | |
| map_s [Lwt_react.S] | |
| map_s [Lwt_react.E] | |
| map_s [Lwt_signal] | |
| map_s [Lwt_event] | |
| map_s [Lwt_stream] | map f st maps the value returned by st with f
|
| map_s [Lwt_list] | |
| map_serial [Lwt_util] |
Similar to
map but wait for one thread to terminate before
starting the next one.
|
| map_with_waiting_action [Lwt_util] | map_with_waiting_action f wa l apply f to each element
in l and collect the results of the threads thus created.
|
| mapped [Lwt_bytes] | mapped buffer returns true iff buffer is a memory mapped
file.
|
| merge_s [Lwt_react.S] | |
| merge_s [Lwt_react.E] | |
| merge_s [Lwt_signal] | |
| merge_s [Lwt_event] | |
| 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.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.
|
| 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_event] | |
| 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] | |
| notice_f [Lwt_log] | |
| notify [Lwt_signal] | |
| notify [Lwt_event] | |
| notify_p [Lwt_signal] | |
| notify_p [Lwt_event] | |
| notify_s [Lwt_signal] | |
| notify_s [Lwt_event] | |
| 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_log] |
Logger which drops everything
|
| null [Lwt_io] |
Output which drops everything
|
| null [Lwt_text] | |
O | |
| of_array [Lwt_stream] | of_array a creates a stream returning all elements of a
|
| of_bytes [Lwt_io] |
Create a channel from a byte array.
|
| 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 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_stream [Lwt_event] | |
| of_string [Lwt_bytes] | of_string str returns a newly allocated byte array with the
same contents as str.
|
| of_string [Lwt_read_line.Command] | of_string cld tries to convert a command name to a
command.
|
| 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.
|
| 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_terminate 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 ?buffer_size ~mode addr open a connection to
the given address and returns two channels for using it.
|
| open_connection [Lwt_chan] | |
| 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_file [Lwt_text] | |
| open_in [Lwt_chan] | |
| open_in_gen [Lwt_chan] | |
| open_out [Lwt_chan] | |
| open_out_gen [Lwt_chan] | |
| open_process [Lwt_process] | |
| open_process_full [Lwt_process] | |
| open_process_in [Lwt_process] | |
| open_process_none [Lwt_process] | |
| open_process_out [Lwt_process] | |
| opendir [Lwt_unix] |
Wrapper for
Unix.opendir
|
| openfile [Lwt_unix] |
Wrapper for
Unix.openfile.
|
| out_channel_of_descr [Lwt_chan] | |
| out_channel_of_descr [Lwt_ssl] | |
| output [Lwt_io] | output output mode representation
|
| output [Lwt_chan] | |
| output_binary_int [Lwt_chan] | |
| output_char [Lwt_chan] | |
| output_string [Lwt_chan] | |
| output_value [Lwt_chan] | |
P | |
| page_size [Lwt_bytes] |
Size of pages.
|
| parse [Lwt_stream] | parse st f parses st with f.
|
| 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.
|
| 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 ?buffer_size () 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] | |
| points [Lwt_term.Zone] | |
| 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] | |
| print [Lwt_text] | |
| 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_io] | |
| printf [Lwt_text] | |
| printl [Lwt_io] | |
| printl [Lwt_text] | |
| printlc [Lwt_term] | printlc st prints st, then reset styles and prints a
newline
|
| printlf [Lwt_io] | |
| printlf [Lwt_text] | |
| 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 | |
| raw_mode [Lwt_term] |
Returns wether the terminal is currently in raw mode
|
| 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_text] | |
| read [Lwt_ssl] | |
| read_bytes [Lwt_ssl] | |
| read_char [Lwt_io] | read_char ic reads the next character of ic.
|
| read_char [Lwt_text] | |
| read_char_opt [Lwt_io] |
Same as
read_byte but does not raises End_of_file on end of
input
|
| read_char_opt [Lwt_text] | |
| read_chars [Lwt_io] | read_chars ic returns a stream holding all characters of
ic
|
| read_chars [Lwt_text] | |
| 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_io] | read_line ic reads one complete line from ic and returns it
without the end of line.
|
| 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_opt [Lwt_io] |
Same as
Lwt_io.read_line but do not raise End_of_file on end of
input.
|
| read_line_opt [Lwt_text] | |
| read_lines [Lwt_io] | read_lines ic returns a stream holding all lines of ic
|
| read_lines [Lwt_text] | |
| 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:
|
| 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.dir
|
| 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
message.
|
| recvfrom [Lwt_bytes] | |
| recvfrom [Lwt_unix] |
Wrapper for
Unix.recvfrom
|
| red [Lwt_term] | |
| 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] | render ~buffer ~template ~section ~level ~message instantiate
all variables of template, and store the result in
buffer.
|
| render [Lwt_term] |
Render an offscreen array to the terminal.
|
| render_state [Lwt_read_line.Control] |
Return the rendering state of the given state
|
| render_update [Lwt_term] | render_update displayed to_display does the same as render
to_display but assumes that displayed contains the current
displayed text.
|
| reset [Lwt_read_line.Engine] | reset state reset the given state, if the user was doing a
selection, it is canceled
|
| reset [Lwt_term] | |
| reset_level [Lwt_log.Section] | reset_level section resets the level of section to its
default value, i.e.
|
| resize_buffer [Lwt_io] |
Resize the internal buffer to the given size
|
| resize_region [Lwt_util] | resize_region reg sz resize the region reg to size sz.
|
| result [Lwt_read_line.Control] |
Threads waiting for the read-line instance to terminates
|
| return [Lwt_react.S] |
Same as
const.
|
| return [Lwt_signal] | |
| 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_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
|
| 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_in_region [Lwt_util] | run_in_region reg size f execute the thread produced by the
function f in the region reg.
|
| run_job [Lwt_unix] | run_job ?async_method job starts job and wait for its
termination.
|
| run_p [Lwt_react.E] | |
| run_p [Lwt_event] | |
| run_s [Lwt_react.S] | |
| run_s [Lwt_react.E] | |
| run_s [Lwt_signal] | |
| run_s [Lwt_event] | |
S | |
| sample_s [Lwt_react.S] | |
| sample_s [Lwt_signal] | |
| save_history [Lwt_read_line] | save_history filename history saves history to
filename.
|
| send [Lwt_bytes] | |
| 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_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-descriptor.
|
| send_notification [Lwt_unix] | send_notification id sends a notification.
|
| sendto [Lwt_bytes] | |
| sendto [Lwt_unix] |
Wrapper for
Unix.sendto
|
| sequence_mapping [Lwt_term] |
Mapping from sequence to keys
|
| 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_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_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_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_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.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.
|
| show [Lwt_read_line.Control] |
Un-hide everything
|
| show_cursor [Lwt_term] | show_cursor () makes the cursor visible
|
| 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_term] |
Size of the terminal.
|
| size [Lwt_pqueue.S] | |
| 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] | |
| ssl_socket [Lwt_ssl] |
Returns the underlying SSL socket used for this wrapper.
|
| standard_input [Lwt_term] |
The input stream used by
Lwt_term.read_key
|
| 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
|
| stderr [Lwt_text] | |
| stdin [Lwt_unix] |
The standard file descriptor for input.
|
| stdin [Lwt_io] |
The standard input, it reads data from
Lwt_unix.stdin
|
| stdin [Lwt_text] | |
| stdout [Lwt_unix] |
The standard file descriptor for output
|
| stdout [Lwt_io] |
The standard output, it writes data to
Lwt_unix.stdout
|
| stdout [Lwt_text] | |
| 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_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.
|
| 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
|
| 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
|
| thread_count [Lwt_unix] |
The number of system threads running (excluding this one).
|
| thread_waiting_count [Lwt_unix] |
The number threads waiting for a job.
|
| timeout [Lwt_unix] | |
| timer_count [Lwt_engine] |
Returns the number of registered timers.
|
| to_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_stream [Lwt_event] | |
| to_string [Lwt_bytes] | to_string buf returns a newly allocated string with the same
contents as buf.
|
| 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.
|
| 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 | |
| underlined [Lwt_term] | |
| 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_bytes_string [Lwt_bytes] |
Same as
Lwt_bytes.blit_bytes_string but without bound checking.
|
| unsafe_blit_string_bytes [Lwt_bytes] |
Same as
Lwt_bytes.blit_string_bytes but without bound checking.
|
| unsafe_fill [Lwt_bytes] |
Same as
Lwt_bytes.fill but without bound checking.
|
| unsafe_get [Lwt_bytes] |
Same as
Lwt_bytes.get but without bound checking.
|
| unsafe_set [Lwt_bytes] |
Same as
Lwt_bytes.set but without bound checking.
|
| 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] | 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 in the the 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] | |
| 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] | |
| warning_f [Lwt_log] | |
| white [Lwt_term] | |
| width [Lwt_term.Zone] | |
| 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 ?buffer_size ~mode addr f open a connection to
the given address and passes the channels to f
|
| with_file [Lwt_io] | with_file ?buffer_size ?flags ?perm ~mode filename f open a
file and passes the channel to f.
|
| with_file [Lwt_text] | |
| 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_finaliser [Lwt_signal] | |
| with_finaliser [Lwt_event] | |
| 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:
|
| with_value [Lwt] | with_value key value f executes f with value associated to
key.
|
| wrap [Lwt] | wrap f calls f and transform the result into a monad.
|
| 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] | read 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_text] | |
| write [Lwt_ssl] | |
| write_bytes [Lwt_ssl] | |
| write_char [Lwt_io] | write_char oc char writes char on oc
|
| write_char [Lwt_text] | |
| write_chars [Lwt_io] | write_chars oc chars writes all characters of chars on
oc
|
| write_chars [Lwt_text] | |
| write_float32 [Lwt_io.NumberIO] |
Writes an IEEE single precision floating point value
|
| write_float64 [Lwt_io.NumberIO] |
Writes an IEEE double precision floating point value
|
| write_from [Lwt_io] | write_from oc buffer offset length writes up to length bytes
to oc, from buffer at offset offset and returns the number
of bytes actually written
|
| write_from_exactly [Lwt_io] | write_from_exactly oc buffer offset length writes all length
bytes from buffer at offset offset to oc
|
| write_int [Lwt_io.NumberIO] |
Writes an ocaml int as a 32-bits integer
|
| write_int16 [Lwt_io.NumberIO] | |
| write_int32 [Lwt_io.NumberIO] | |
| write_int64 [Lwt_io.NumberIO] | |
| write_line [Lwt_io] | write_line oc str writes str on oc followed by a
new-line.
|
| write_line [Lwt_text] | |
| write_lines [Lwt_io] | write_lines oc lines writes all lines of lines to oc
|
| write_lines [Lwt_text] | |
| 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.
|
| 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'
|
| zero [Lwt_text] |