Index of values

Syntax for Lwt_result.both.

Syntax for Lwt.both.

Syntax for Lwt_result.bind.

Syntax for Lwt.bind.

p1 <&> p2 is the same as Lwt.join[p1; p2].

p1 <?> p2 is the same as Lwt.choose[p1; p2].

p >>= f is the same as Lwt.bindp f.

p >|= f is the same as Lwt.mapf p.

Causes promises created with Lwt.pause and Lwt_main.yield to remain forever pending.

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

abort ch abort current operations and close the channel immediately.

abort_jobs exn make all pending jobs to fail with exn.

Wrapper for Unix.accept

accept_n fd count accepts up to count connections at one time.

Wrapper for Unix.access

add e q evaluates to a new priority queue, which contains all the elements of q, and the additional element e.

Adds a hook to the hook sequence underlying this module, to be run first, before any other hooks already added.

add_hook switch f registers f so it will be called when Lwt_switch.turn_off is invoked.

add_hook_or_exec switch f is the same as Lwt_switch.add_hook except that if the switch is already off, f is called immediately.

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

Adds a hook to the hook sequence underlying this module, to be run last, after any other hooks already added.

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

Like Lwt.add_task_r, but the equivalent code calls Lwt_sequence.add_l instead.

Lwt.add_task_r sequence is equivalent to

Lwt.all ps is like Lwt.joinps: it waits for all promises in the list ps to become resolved.

Syntax for Lwt_result.both.

Syntax for Lwt.both.

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

append xs ys is the sequence xs followed by the sequence ys

append_bigarray vs buffer offset length appends a slice of the Bigarray buffer buffer beginning at offset and with length length to the I/O vector sequence vs.

append_bytes vs buffer offset length appends a slice of the bytes buffer buffer beginning at offset and with length length to the I/O vector sequence vs.

Lwt.async f applies f (), which returns a promise, and then makes it so that if the promise is rejected, the exception is passed to !Lwt.async_exception_hook.

Reference to a function, to be called on an "unhandled" exception.

async_method () returns the async method used in the current thread.

The key for storing the local async method.

Lwt_main.at_exit hook is the same as ignore (Lwt_main.Exit_hooks.add_first hook).

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

auto_pause timeout returns a function f, and f () has the following behavior:

Binds an address to the given socket.

bind ?eq s f is initially f x where x is the current value of s.

See Lwt_result.bind.

See Lwt.bind.

See Lwt.bind.

Lwt.bind p_1 f makes it so that f will run when p_1 is fulfilled.

Old version of Lwt_unix.bind.

Since Lwt 3.0.0, this is just an alias for Lwt_unix.bind.

Same as Lwt_react.S.bind except that f returns a promise.

blit buf1 ofs1 buf2 ofs2 len copies len bytes from buf1 starting at offset ofs1 to buf2 starting at offset ofs2.

Same as Lwt_bytes.blit but the first buffer is a Bytes.t instead of a byte array.

Same as Lwt_bytes.blit but the first buffer is a String.t instead of a byte array.

Same as Lwt_bytes.blit but the second buffer is a Bytes.t instead of a byte array.

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

blocking fd indicates whether Lwt is internally using blocking or non-blocking I/O with fd.

See Lwt_result.both.

Lwt.both p_1 p_2 returns a promise that is pending until both promises p_1 and p_2 become resolved.

See Lwt.both.

See Lwt.both.

Lwt.both p_1 p_2 returns a promise that is pending until both promises p_1 and p_2 become resolved.

broadcast condvar value notifies all waiting threads.

broadcast_exn condvar exn fails all waiting threads with exception exn.

Returns the size of the internal buffer.

buffered oc returns the number of bytes in the buffer

byte_count vs is the total number of bytes in vs.

The byte order used by the computer running the program.

Call the handler associated to the given notification.

Lwt.cancel p attempts to cancel the pending promise p, without needing access to its resolver.

cancel_jobs () is the same as abort_jobs Lwt.Canceled.

catch x behaves like return y if x evaluates to y, and like fail e if x raises e

Lwt.catch f h applies f (), which returns a promise, and then makes it so that h (“handler”) will run when that promise is rejected.

Changes the duration of the given timeout.

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

Wrapper for Unix.chdir

check switch does nothing if switch is None or contains an switch that is currently on, and raises Lwt_switch.Off otherwise.

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

Wrapper for Unix.chmod

choose l creates an stream from a list of streams.

Lwt.choose ps is the same as Lwt.pickps, except that it does not try to cancel pending promises in ps.

Wrapper for Unix.chown

Wrapper for Unix.chroot

Removes all nodes from the given sequence.

clear p will clear all elements in p, calling the dispose function associated with p on each of the cleared elements.

Wrapper for Unix.clear_close_on_exec

clone st clone the given stream.

Close a file descriptor.

close ch closes the given channel.

closed st returns a thread that will sleep until the stream has been closed.

Closes a directory handle.

combine s1 s2 combines two streams.

concat st returns the concatenation of all streams of st.

Wrapper for Unix.connect

cons x xs is the sequence containing the element x followed by the sequence xs

cons x xs is the sequence containing the element promised by x followed by the sequence xs

copy buffer creates a copy of the given byte array.

Creates an empty I/O vector sequence.

Lwt_timeout.create n f creates a new timeout object with duration n seconds.

Creates a rate limiter.

Creates a new byte array of the given size.

create () creates a new switch.

create () returns a new stream and a push function.

create () creates a new empty sequence

create n ?check ?validate ?dispose f creates a new pool with at most n elements.

create v creates a new mailbox variable containing value v.

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

create () creates a new condition variable.

create_bounded size returns a new stream and a bounded push source.

create () creates a new empty mailbox variable.

Creates a temporary directory, and returns a promise that resolves to its path.

create_with_reference () returns a new stream and a push function.

Returns the default async method.

Return the default size for buffers.

delay promise is an event which does not occur until promise resolves.

detach f x runs the computation f x in a separate preemptive thread.

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

Stops receiving this signal

Lwt.dont_wait f handler applies f (), which returns a promise, and then makes it so that if the promise is rejected, the exception is passed to handler.

drop vs n adjusts the I/O vector sequence vs so that it no longer includes its first n bytes.

Wrapper for Unix.dup

Wrapper for Unix.dup2

The empty sequence, containing no elements.

The empty priority queue.

%! does nothing here.

Returns a promise that prints on the standard error.

%! does nothing here.

Like establish_server_with_client_address, but does not pass the client address or fd to the callback f.

Old version of Lwt_io.establish_server.

Since Lwt 3.0.0, this is just an alias for Lwt_io.establish_server.

Like Lwt_io.establish_server_with_client_socket, but passes two buffered channels to the connection handler f.

establish_server_with_client_socket listen_address f creates a server which listens for incoming connections on listen_address.

Executes the given command and returns its exit status.

extract buffer offset length creates a new byte array of length length and copy the length bytes of buffer at offset into it.

Lwt.fail exn is like Lwt.return, except the new promise that is already rejected with exn.

Lwt.invalid_arg s is an abbreviation for

Lwt.fail_with s is an abbreviation for

Event which does nothing when stopped.

Simulates activity on the given file descriptor.

Wrapper for Unix.fchmod

Wrapper for Unix.fchown

Synchronise all data (but not metadata) of the file descriptor with the disk.

file_exists name tests if a file named name exists.

file_exists name tests if a file named name exists.

Retrieves the length of the file at the given path.

files_of_directory dir returns the stream of all files of dir.

fill buffer offset length value puts value in all length bytes of buffer starting at offset offset.

Remove from the sequence the elements that do not satisfy the given predicate.

Apply the function to every element; if f x = None then x is dropped; if f x = Some y then y is returned.

filter_map f st filter and map st at the same time

filter_map_s is like filter but the predicate returns a promise.

filter f st keeps only values, x, such that f x is true

filter_s is like filter but the predicate returns a promise.

finalise f x ensures f x is evaluated after x has been garbage collected.

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

Lwt.finalize f c applies f (), which returns a promise, and then makes it so c (“cleanup”) will run when that promise is resolved.

find_map f s find and map at the same time.

find_min q evaluates to the minimum element of q if it is not empty, and raises Not_found otherwise.

find_node_l f s returns the first node of s starting from the left that satisfies f or raises Not_found if none exists.

find_node_opt_l f s returns Some x, where x is the first node of s starting from the left that satisfies f or None if none exists.

find_node_opt_r f s returns Some x, where x is the first node of s starting from the right that satisfies f or None if none exists.

find_node_r f s returns the first node of s starting from the right that satisfies f or raises Not_found if none exists.

find f s find an element in a stream.

Map each element to a subsequence, then return each element of this sub-sequence in turn.

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

flush oc performs all pending writes on oc

flush fmt flushes the formatter (as with Format.pp_print_flush) and executes all the printing action on the underlying channel.

flush_all () flushes all open output channels

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

Traverse the sequence from left to right, combining each element with the accumulator using the given function.

fold_left_s is like fold_left but the function returns a promise.

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 f s x fold_like function for streams.

fork () does the same as Unix.fork.

Called internally by Lwt_unix.fork to make sure we don't get strange behaviour

%! does nothing here.

%! does nothing here.

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

from f creates a stream from the given input function.

from_direct f does the same as Lwt_stream.from but with a function that does not return a thread.

Wrapper for Unix.LargeFile.fstat

Wrapper for Unix.fstat

Synchronise all data and metadata of the file descriptor with the disk.

Wrapper for Unix.LargeFile.ftruncate

Wrapper for Unix.ftruncate

get () returns the engine currently in use.

get buffer offset returns the byte at offset offset in buffer.

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

Returns the contents of a node

Retrieves the value currently associated with the given implicit callback argument key.

get_affinity ?pid () returns the list of CPUs the process with pid pid is allowed to run on.

get_available st returns all available elements of l without blocking.

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

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

get_cpu () returns the number of the CPU the current thread is running on.

get_credentials fd returns credentials information from the given socket.

get_exn is the opposite of Lwt_result.catch: it unwraps the result type, returning the value in case of success, calls Lwt.fail in case of error.

get_formatter fmt returns the underlying Format.formatter.

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.

Wrapper for Unix.getaddrinfo

Wrapper for Unix.getcwd

Wrapper for Unix.getgrgid

Wrapper for Unix.getgrnam

Wrapper for Unix.gethostbyaddr

Wrapper for Unix.gethostbyname

Wrapper for Unix.gethostname

Wrapper for Unix.getlogin

Wrapper for Unix.getnameinfo

Wrapper for Unix.getpeername

Wrapper for Unix.getprotobyname

Wrapper for Unix.getprotobynumber

Wrapper for Unix.getpwnam

Wrapper for Unix.getpwuid

Wrapper for Unix.getservbyname

Wrapper for Unix.getservbyport

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

Same as Unix.handle_unix_error but catches lwt-level exceptions

Test whether the given feature is available on the current 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.

An obsolete variant of Lwt.async.

init min max log initialises this module.

input input mode representation

is_busy channel returns whether the given channel is currently busy.

is_closed channel returns whether the given channel is currently closed.

is_closed st returns whether the given stream has been closed.

is_empty vs is true if and only if vs has no I/O vectors, or all I/O vectors in vs have zero bytes.

is_empty st returns whether the given stream is empty.

Returns true iff the given sequence is empty

is_empty q evaluates to true iff q is empty.

is_empty mvar indicates if put mvar can be called without blocking.

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

locked mutex returns whether mutex is currently locked

is_on switch returns true if the switch is currently on, and false otherwise.

Lwt.is_sleeping p is equivalent to Lwt.statep = Lwt.Sleep.

Wrapper for Unix.isatty

iter block performs one iteration of the main loop.

Iterate on the sequence, calling the (imperative) function on every element.

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

iter_n ?max_concurrency f s iterates over all elements of the stream s.

iter_n ~max_concurrency f s

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

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

Iterate on the sequence, calling the (imperative) function on every element.

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

iter f s iterates over all elements of the stream.

iter_s is like iter but the function returns a promise.

Lwt.join ps returns a promise that is pending until all promises in the list ps become resolved.

junk st removes the first element of st.

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

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

keep s keeps a reference to s so it will never be garbage collected.

keep e keeps a reference to e so it will never be garbage collected.

last_new st returns the last element that can be obtained without sleeping, or wait for one if none is available.

Returns the length of the channel in bytes

Returns the length of the given byte array.

Returns the number of elements in the given sequence.

Syntax for Lwt_result.map.

Syntax for Lwt.map.

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

limit f e limits the rate of e with f.

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 file with name name.

Wrapper for Unix.link

Wrapper for Unix.listen

lock mutex lockcs the mutex, that is:

Wrapper for Unix.lockf

lookup_min q evaluates to Some e, where e is the minimum element of q, if q is not empty, and evaluates to None otherwise.

Wrapper for Unix.LargeFile.lseek

Wrapper for Unix.lseek

Wrapper for Unix.LargeFile.lstat

Wrapper for Unix.lstat

madvise buffer pos len advice advises the kernel how the program will use the memory mapped file between pos and pos + len.

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

Lwt.make_error exn is equivalent to Error exn since OCaml 4.03.

make_formatter ~commit ~fmt creates a new lwt formatter based on the Format.formatter fmt.

make_notification ?once f registers a new notifier.

make_stream () returns a formatter and a stream of all the writing order given on that stream.

Lwt.make_value v is equivalent to Ok v since OCaml 4.03.

map f seq returns a new sequence whose elements are the elements of seq, transformed by f.

See Lwt_result.map.

See Lwt.map.

See Lwt.map.

Lwt.map f p_1 is similar to Lwt.bindp_1 f, but f is not expected to return a promise.

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 ~fd ?pos ~shared ?size () maps the file descriptor fd to an array of bytes.

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

map f st maps the value returned by st with f

map_s f seq is like map f seq but f is a function that returns a promise.

mapped buffer returns true iff buffer is a memory mapped file.

mcast_add_membership fd ~ifname addr joins the multicast group addr on the network interface ifname.

mcast_drop_membership fd ~ifname addr leaves the multicast group addr on the network interface ifname.

Whether sent multicast messages are received by the sending host

Set TTL/hops value

mincore buffer offset states tests whether the given pages are in the system memory (the RAM).

Wrapper for Unix.mkdir

Wrapper for Unix.mkfifo

mode ch returns the mode of a channel

Lwt.nchoose ps is the same as Lwt.npickps, except that it does not try to cancel pending promises in ps.

Lwt.nchoose_split ps is the same as Lwt.nchooseps, except that when multiple promises in ps are fulfilled simultaneously (and none are rejected), the result promise is fulfilled with both the list of values of the fulfilled promises, and the list of promises that are still pending.

Creates a fresh implicit callback argument key.

next e returns the next occurrence of e.

next st removes and returns the next element of the stream or fails with Lwt_stream.Empty, if the stream is empty.

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

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

Lwt.no_cancel p creates a non-cancelable promise p'.

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

Lwt.npick ps is similar to Lwt.pickps, the difference being that when multiple promises in ps are fulfilled simultaneously (and none are rejected), the result promise is fulfilled with the list of values the promises were fulfilled with.

Output which drops everything

of_array a creates a stream returning all elements of a.

Create a channel from a byte array.

of_bytes buf returns a newly allocated byte array with the same contents as buf.

of_channel oc creates a formatter that writes to the channel oc.

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

of_list l creates a stream returning all elements of l.

Convert a list to a sequence, preserving order.

of_lwt_seq s creates a stream returning all elements of s.

Lwt.of_result r converts an r to a resolved promise.

of_seq s creates a stream returning all elements of s.

Convert from 'a Stdlib.Seq.t to 'a Lwt_seq.t.

Convert from 'a Lwt.t Stdlib.Seq.t to 'a Lwt_seq.t.

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

of_string buf returns a newly allocated byte array with the same contents as buf.

of_string str creates a stream returning all characters of str.

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

Wraps a Unix file descriptor fd in an Lwt_unix.file_descr fd'.

Lwt.on_any p f g makes it so that:

Lwt.on_cancel p f makes it so that f will run when p becomes canceled.

Lwt.on_failure p f makes it so that f will run when p is rejected.

on_readable fd f calls f each time fd becomes readable.

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

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.

Lwt.on_success p f makes it so that f will run when p is fulfilled.

Same as Lwt_stream.on_termination.

on_termination st f executes f when the end of the stream st is reached.

Lwt.on_termination p f makes it so that f will run when p is resolved – that is, fulfilled or rejected.

on_timer delay repeat f calls f one time after delay seconds.

on_readable fd f calls f each time fd becomes writable.

open_connection ?fd ?in_buffer ?out_buffer addr opens a connection to the given address and returns two channels for using it.

Lwt_io.open_file ~mode file opens the given file, either for reading (with ~mode:Input) or for writing (with ~mode:Output).

open_temp_file () starts creating a new temporary file, and evaluates to a promise for the pair of the file's name, and an output channel for writing to the file.

Opens a directory for listing.

Wrapper for Unix.openfile.

output output mode representation

Size of pages.

parse st f parses st with f.

Lwt.pause () creates a pending promise that is fulfilled after Lwt finishes calling all currently ready callbacks, i.e.

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

Lwt.pick ps returns a promise that is pending until one promise in the list ps becomes resolved.

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

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

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.

Maximum number of system threads that can be started.

position ch Returns the current position in the channel.

pread fd buf ~file_offset ofs len on file descriptors allowing seek, reads up to len bytes from fd at offset file_offset from the beginning of the file, and writes them to buf, starting at offset ofs.

%! does nothing here.

Returns a promise that prints on the standard output.

%! does nothing here.

Lwt.protected p creates a cancelable promise p'.

proxy buffer offset length creates a ``proxy''.

put mvar value puts a value into a mailbox variable.

pwrite fd buf ~file_offset ofs len on file descriptors allowing seek, writes up to len bytes to fd from buf, starting at buffer offset ofs.

See Lwt_unix.pwrite.

read fd buf ofs len reads up to len bytes from fd, and writes them to buf, starting at offset ofs.

If ~count is specified, read ~count ic reads at most ~count bytes from ic in one read operation.

read_char ic reads the next character of ic.

Same as Lwt_io.read_char, but does not raise 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.

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_value channel reads a marshaled value from channel; it corresponds to the standard library's Marshal.from_channel.

Returns whether the given file descriptor is currently readable.

Returns the number of events waiting for a file descriptor to become readable.

Reads the next directory entry from the given directory.

readdir_n handle count reads at most count entries from the given directory.

Wrapper for Unix.readlink

readv fd vs reads bytes from fd into the buffer slices vs.

Wrapper for Unix.recv.

Not implemented on Windows.

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

Not implemented on Windows.

Since Lwt 5.0.0, this is an alias for Lwt_unix.recv_msg.

Wrapper for Unix.recvfrom.

Not implemented on Windows.

register_action set fd action registers action on fd.

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

Removes a hook added by Lwt_main.Hooks.add_first or Lwt_main.Hooks.add_last.

Removes a node from the sequence it is part of.

Removes all hooks from the hook sequence underlying this module.

remove_min q evaluates to a new priority queue, which contains all the elements of q except for its minimum element.

Wrapper for Unix.rename

Resize the internal buffer to the given size

Same as const.

return a creates a stream containing the value a and being immediately closed stream (in the sense of Lwt_stream.is_closed).

The singleton sequence containing only the given element.

See Lwt_result.return.

See Lwt.return.

See Lwt.return.

Lwt.return v creates a new promise that is already fulfilled with value v.

Like Lwt.return_some, this function performs no optimization.

Lwt.return_false is like Lwt.return_unit, but for Lwt.returnfalse.

return_lwt l creates a stream returning the value that l resolves to.

The singleton sequence containing only the given promised element.

Lwt.return_nil is like Lwt.return_unit, but for Lwt.return[].

Lwt.return_none is like Lwt.return_unit, but for Lwt.returnNone.

Like Lwt.return_some, this function performs no optimization.

Counterpart to Lwt.return_none.

Lwt.return_true is like Lwt.return_unit, but for Lwt.returntrue.

Lwt.return_unit is defined as Lwt.return(), but this definition is evaluated only once, during initialization of module Lwt, at the beginning of your program.

Resets the given directory handle, so that directory listing can be restarted.

Wrapper for Unix.rmdir

Lwt_main.run p calls the Lwt scheduler, performing I/O until p resolves.

run_in_main f can be called from a detached computation to execute f () in the main preemptive thread, i.e.

run_job ?async_method job starts job and wait for its termination.

Wrapper for Unix.send.

Not implemented on Windows.

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

Not implemented on Windows.

Since Lwt 5.0.0, this is an alias for Lwt_unix.send_msg.

send_msgto ~socket ~io_vectors ~fds ~dest is similar to send_msg but takes an additional dest argument to set the address when using a connection-less socket.

send_notification id sends a notification.

Wrapper for Unix.sendto.

Not implemented on Windows.

set ?transfer ?destroy engine replaces the current engine by the given one.

get buffer offset value changes the value of the byte at offset offset in buffer to value.

Change the contents of a node

set_affinity ?pid cpus sets the list of CPUs the given process is allowed to run on.

set_blocking fd b causes Lwt to internally use blocking or non-blocking I/O with fd, according to the value of b.

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

Wrapper for Unix.set_close_on_exec

Sets the default async method.

Change the default buffer size.

Lwt_timeout.set_exn_handler f sets the handler to be used for exceptions raised by timeout actions.

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

set_notification id f replace the function associated to the notification by f.

Change the size of the pool.

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

Wrapper for Unix.shutdown

Closes the given server's listening socket.

Old version of Lwt_io.shutdown_server.

Since Lwt 3.0.0, this is just an alias for Lwt_io.shutdown_server.

signal condvar value notifies that a condition is ready.

Returns the number of registered signal handler.

simple_init () checks if the library is not yet initialized, and if not, does a simple initialization.

size q evaluates to the number of elements in q.

sleep d is a promise that remains in a pending state for d seconds and after which it is resolved with value ().

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

Wrapper for Unix.socketpair

Starts the given timeout.

Wrapper for Unix.LargeFile.stat

Wrapper for Unix.stat

state fd returns the state of fd