Index of values


(!$) [Cf_lex.Expr_Op_T]
Regular expression string.
(!*) [Cf_lex.Expr_Op_T]
Star composition.
(!*) [Cf_dfa.T.Expr_Op_T]
Use !*a to compose an expression that matches zero or more occurances of a in the symbol stream.
(!+) [Cf_lex.Expr_Op_T]
Plus composition.
(!+) [Cf_dfa.T.Expr_Op_T]
Use !+a to compose an expression that matches one or more occurances of a in the symbol stream.
(!:) [Cf_lex.Expr_Op_T]
Character literal.
(!:) [Cf_dfa.T.Expr_Op_T]
Use !:sym to compose an expression that matches the symbol sym in the symbol stream.
(!?) [Cf_lex.Expr_Op_T]
Optional composition.
(!?) [Cf_dfa.T.Expr_Op_T]
Use !?a to compose an expression that matches zero or one occurance of a in the symbol stream.
(!@) [Cf_lex.X.Op]
Rule aggregation.
(!@) [Cf_lex.Op]
Rule aggregation.
(!@) [Cf_dfa.T.X.Op_T]
Use this operator to combine a list of "cursor woven" rules into a single rule.
(!@) [Cf_dfa.T.Op_T]
Use this operator to combine a list of rules into a single rule.
(!^) [Cf_lex.Expr_Op_T]
Character set.
(!^) [Cf_dfa.T.Expr_Op_T]
Use !^f to compose an expression that matches any symbol in the symbol stream for which applying the function f returns true.
(!~) [Cf_lex.Expr_Op_T]
Regular expression sequence.
(!~) [Cf_dfa.T.Expr_Op_T]
Use !~z to compose an expression that matches the sequence of symbols z in the symbol stream.
($&) [Cf_lex.Expr_Op_T]
Serial composition.
($&) [Cf_dfa.T.Expr_Op_T]
Use a $& b to compose an expression that matches a followed by b in the symbol stream.
($=) [Cf_lex.X.Op]
Literal token rule.
($=) [Cf_lex.Op]
Literal token rule.
($=) [Cf_dfa.T.X.Op_T]
Use e $= x to compose a rule that produces x when the symbols in the symbol stream match the expression e.
($=) [Cf_dfa.T.Op_T]
Use e $= x to compose a rule that produces x when the symbols in the symbol stream match the expression e.
($>) [Cf_lex.X.Op]
String token rule.
($>) [Cf_lex.Op]
String token rule.
($>) [Cf_dfa.T.X.Op_T]
Use e $> f to compose a rule that applies the tokenizer function f to the sequence of input symbols in the symbol/cursor stream recognized by the expression e to produce an output token.
($>) [Cf_dfa.T.Op_T]
Use e $> f to compose a rule that applies the tokenizer function f to the sequence of input symbols in the stream recognized by the expression e to produce an output token.
($@) [Cf_lex.X.Op]
Advanced token rule.
($@) [Cf_lex.Op]
Advanced token rule.
($@) [Cf_dfa.T.X.Op_T]
Use e $@ f to compose a rule that applies the scanning function f to the symbol/cursor input stream when the symbol sequence is recognized by the expression e.
($@) [Cf_dfa.T.Op_T]
Use e $@ f to compose a rule that applies the scanning function f to the input stream when it is recognized by the expression e.
($|) [Cf_lex.Expr_Op_T]
Alternating composition.
($|) [Cf_dfa.T.Expr_Op_T]
Use a $| b to compose an expression that matches either a or b in the symbol stream.
(%=) [Cf_parser.Op]
The serial composition operator.
(-&-) [Cf_flow.Op]
Sequential composition.
(-*-) [Cf_flow.Op]
Broadcasting parallel composition.
(-+-) [Cf_flow.Op]
Tagged parallel composition.
(-=-) [Cf_flow.Op]
Serial composition.
(-@-) [Cf_flow.Op]
Serial loop through right.
(>>=) [Cf_parser.Op]
The binding operator.
(>>=) [Cf_scmonad.Op]
Use m >>= f to produce a monad that applies f to the result of evaluating m.
(>>=) [Cf_cmonad.Op]
Use m >>= f to produce a monad that applies f to the result of evaluating m.
(>>=) [Cf_smonad.Op]
Use m >>= f to produce a monad that applies f to the result of evaluating m.
(~:) [Cf_parser.Op]
The return operator.
(~@) [Cf_flow.Op]
Serial loop composition.
(~@<) [Cf_flow.Op]
Serial loop left.
? [Cf_parser.Op]
The unit operator.
?$ [Cf_lex.X.Op]
String parser.
?$ [Cf_lex.Op]
String parser.
?* [Cf_parser.Op]
The zero-or-more operator.
?+ [Cf_parser.Op]
The one-or-more operator.
?/ [Cf_parser.Op]
The option operator.
?: [Cf_parser.Op]
The unit operator with a cursor.
?~ [Cf_lex.X.Op]
String parser.
?~ [Cf_lex.Op]
String parser.

A
abort [Cf_state_gadget]
Use abort to abort processing and return to the scheduler.
abort [Cf_gadget]
Use abort to abort gadgeting and return to the scheduler.
accept [Cf_socket]
Use accept sock to accept a connected request on the listening socket sock.
accumulate [Cf_seq.SC]
Use accumulate z to compose a monad that binds all of the monads in the sequence z in the order specified, accumulating all of the values returned into a list.
accumulate [Cf_seq.C]
Use accumulate z to compose a monad that binds all of the monads in the sequence z in the order specified, accumulating all of the values returned into a list.
accumulate [Cf_seq.S]
Use accumulate z to compose a monad that binds all of the monads in the sequence z in the order specified, accumulating all of the values returned into a list.
add [Cf_tai64n]
Add seconds to a TAI64N value.
add [Cf_tai64]
Add seconds to a TAI64 value.
add_int32 [Cf_tai64]
Add seconds to a TAI64 value.
add_int64 [Cf_tai64]
Add seconds to a TAI64 value.
addrinfo_default_hint [Cf_nameinfo]
The default hints value for the to_address function, .
addrinfo_hint [Cf_nameinfo]
Construct a hints value for the to_address function.
all_hosts_group [Cf_ip4_addr]
The all-hosts group multicast address, i.e.
all_routers_group [Cf_ip4_addr]
The all-routers group multicast address, i.e.
alt [Cf_parser]
Use alt plist to create a parser that produces the output from the first parser in the list plist that recognizes a pattern in the input.
altz [Cf_parser]
Use altz pseq to create a parser that produces the output from the first parser in the lazy sequence pseq that recognizes a pattern in the input.
any [Cf_ip4_addr]
The unspecified IPv4 address, i.e.
any_utf_to_ucs4 [Cf_unicode]
A flow that transcodes any Unicode encoded character stream into a stream of 31-bit UCS4 integer codes.
atomic [Cf_unicode.Transcoding_T]
Use atomic str to convert a string in the input encoding into a string in the output encoding.

B
bind [Cf_socket]
Use bind sock sa to bind the local endpoint address of the socket sock to the socket address sa.
broadcast [Cf_ip4_addr]
The link-local broadcast IPv4 address, i.e.
broadcast [Cf_flow]
Use broadcast ws to construct a stream processor that combines the input and output of every stream processor in the list ws by first rendering all the output from each stream in turn, then ingesting all the input to each stream in turn, until all streams are completed.

C
category [Cf_ip4_addr]
Use category a to obtain the category of an opaque IPv4 address.
catenate [Cf_deque]
catenate d1 d2 returns a new deque composed by joining the right end of d1 to the left end of d2.
clear [Cf_set.T]
Use clear e s to obtain a new set produced by deleting the element in the set s ordinally equal to the element e.
close [Cf_socket]
Use close sock to close a socket descriptor.
cmp [Cf_seq]
cmp a b is the same as fcmp Pervasives.compare a b.
combine [Cf_seq]
combine a b returns the sequence composed of the pairs of elements produced by combining each element from a and the corresponding element from b in a pair (a, b) until all the elements from one or both sequences are exhausted.
commute [Cf_flow]
Use commute w z to produce an output sequence from a flow w that ingests its input from the sequence z.
commute_string [Cf_flow]
Use commute_string w s to commute the sequence of characters in the string s with the flow w and compose a new string from the resulting sequence.
compare [Cf_ip6_addr]
Use compare a1 a2 to compare the ordinality of two IPv6 addresses.
compare [Cf_ip4_addr]
Use compare a1 a2 to compare the ordinality of two IPv4 addresses.
compare [Cf_set.T]
Use compare s1 s2 to compare the sequence of elements in the set s1 and the sequence of elements in the set s2 in order of increasing ordinality.
compare [Cf_tai64n]
A total ordering function, defined so that the Cf_tai64n module has the signature of the Cf_ordered.Total_T module type.
compare [Cf_tai64]
A total ordering function, defined so that the Cf_tai64 module has the signature of the Cf_ordered.Total_T module type.
compare [Cf_ordered.Total_T]
compare a b compares the total ordering of a and b, and it returns zero if the two values are of equal total order, a negative integer if a follows b, and a positive integer if a precedes b in the total ordering.
compose [Cf_tai64n]
Use compose s ns to compose a TAI64N value from a TAI64 value s and an offset of ns nanoseconds.
concat [Cf_seq]
concat a b returns the sequence of all the elements in a followed by all the elements in b.
connect [Cf_socket]
Use connect sock sa to connect the remote endpoint address of the socket sock to the socket address sa.
constrain [Cf_seq]
constrain f s evaluates the sequence s by applying f to each element while the result is true.
constrain2 [Cf_seq]
constrain2 f a b is like constrain f s, except it operates on a pair of sequences simultaneously, until one or both sequences reaches its end or the constrain returns false.
cont [Cf_scmonad]
Use cont f to produce a monad that passes the calling continuation to the function f and returns the unit value as an intermediate result.
cont [Cf_cmonad]
Use cont f to produce a monad that passes the calling continuation to the function f and returns the unit value as an intermediate result.
contents [Cf_message]
Use contents m to create a new string containing the entire text of the message m.
copy [Cf_message]
Use copy m to create a new message with a deep copy of the contents of m, i.e.
counter_zero [Cf_lex]
The initial value of a cursor position counter.
create [Cf_poll]
Use create () to construct a new polling mux.
create [Cf_sock_common.T]
Use create () to create a new socket.
create [Cf_socket]
Use create dom st p to create a new socket descriptor with the socket domain dom, the socket type st and the protocol identifier p.
create [Cf_lex.X]
Use create r to compose a lexical analyzer from the rule r.
create [Cf_lex]
Use create r to compose a lexical analyzer from the rule r.
create [Cf_dfa.T.X]
Use create r to construct a parser that recognizes the longest sequence that matches the rule r.
create [Cf_dfa.T]
Use create r to construct a parser that recognizes the longest sequence that matches the rule r.
create [Cf_message]
Use create s to obtain a new message composed of a flattened message containing the string s.
create [Cf_gadget]
Use create f to create a duplex channel, and apply f to the resulting plug to obtain the initial state of a machine.
createM [Cf_gadget]
Use createM f to create a duplex channel, and apply f to the resulting plug to obtain a continuation monad that evaluates to the initial state of a machine.
createpair [Cf_sock_common.T]
Use createpair () to create a pair of new sockets that are connected to one another.
createpair [Cf_socket]
Use createpair dom st p to create a pair of new socket descriptors that are already bound and connected to one another, using the socket domain dom, the socket type st and the protocol identifier p.
cscanf [Cf_scan_parser]
This is the primitive function in the module.
cycle [Cf_poll]
Use cycle p to wait until one or more of the I/O event objects loaded into the mux p is ready to be serviced, then service them (which includes invoking their obj#service method).

D
decompose [Cf_tai64n]
Use decompose x to separate the TAI64N value x into a TAI64 value and an offset in nanoseconds.
delete [Cf_map.T]
Use delete k m to obtain a new tree produced by deleting the key k from the tree m.
diff [Cf_set.T]
Use diff s1 s2 to obtain a new set from the difference of the sets s1 and s2.
dncase [Cf_flow]
A stream processor that converts lowercase US-ASCII characters into uppercase characters.
domain [Cf_socket.AF]
The value of the socket domain identifier.
domain_of_sockaddr [Cf_socket]
Use domain_of_sockaddr sa to obtain the socket domain identifier associated with a socket address of unknown address family.
down [Cf_scmonad]
Use down m s to produce a stateless continuation monad from a state-continuation monad and an initial state.
drain [Cf_message]
Use drain q to convert the entire substring deque q into a message.
drain [Cf_flow]
Use drain w to produce an output sequence comprised of all the values output from the stream processor w until the first input is required.
drain_seq [Cf_message]
Use drain_seq q to convert the substring deque q into a character sequence.
dup [Cf_socket]
Use dup sock to create a duplicate of socket descriptor sock.
dup2 [Cf_socket]
Use dup2 sock sock2 to create a duplicate of socket descriptor sock by overwriting the descriptor sock2.
duplex [Cf_state_gadget]
Use duplex to construct a new duplex communication channel, composed of two wires each in opposite flow.
duplex [Cf_gadget]
Use duplex to construct a new duplex communication channel, composed of two wires each in opposite flow.

E
emit_abs_special [Cf_uri]
Use emit_abs_special pp abs to print the absolute URI specialization abs with the formatter pp.
emit_authority [Cf_uri]
Use emit_authority pp auth to print the name authority part of a URI authority with the formatter pp.
emit_host [Cf_uri]
Use emit_host pp host to print the host part of a URI host with the formatter pp.
emit_path [Cf_uri]
Use emit_path pp path to print the path component of a URI path with the formatter pp.
emit_server [Cf_uri]
Use emit_server pp server to print the server part of a URI server with the formatter pp.
emit_uri [Cf_uri]
Use emit_uri pp uri to print the URI uri with the formatter pp.
emit_uri_reference [Cf_uri]
Use emit_uri_reference pp uriref to print the URI reference uriref with the formatter pp.
empty [Cf_set.T]
Use empty s to test whether the set s is the empty set.
empty [Cf_map.T]
Use empty m to test whether the tree m is empty.
empty [Cf_pqueue.T]
Use empty q to test whether the priority queue q is empty.
empty [Cf_heap.T]
Use empty h to test whether the heap h is empty.
empty [Cf_deque]
Returns true if the deque is the empty deque.
empty_group [Cf_ip4_addr]
The empty group multicast address, i.e.
equal [Cf_ip6_addr]
Use equal a1 a2 to compare two IPv6 addresses for equality.
equal [Cf_ip4_addr]
Use equal a1 a2 to compare two IPv4 addresses for equality.
equal [Cf_seq]
equal a b returns true, if every element in both sequences a and b are logically equivalent, as with the built-in (=) comparison operator.
err [Cf_parser.X]
Use err ?f () to compose parser that applies the input token stream to the optional function f to obtain an Objective Caml exception, then raises the exception.
err [Cf_parser]
Use err ?f () to compose parser that applies the input token stream to the optional function f to obtain an Objective Caml exception, then raises the exception.
escape [Cf_uri]
Use escape ?allow s to obtain a new string by replacing all the unreserved and "mark" characters in the string s with the equivalent URI escape sequence.
eval [Cf_state_gadget]
Use eval y s to obtain a new flow by evaluating the gadget monad y with a state initializer of a.
eval [Cf_gadget]
Use eval y to obtain a new flow by evaluating the gadget monad y.
eval [Cf_cmonad]
Use eval m to evaluate the continuation monad to produce a function from initial continuation context to final continuation context.
evalC [Cf_flow]
Use evalC m to evaluate the continuation monad m, computing the encapsulated flow.
evalC [Cf_seq]
Use evalC m to evaluate the continuation monad m to compute the sequence it encapsulates.
evalSC [Cf_flow]
Use evalSC m s to evaluate the state-continuation monad m with the initial state s, computing the encapsulated flow.
evalSC [Cf_seq]
Use evalSC m s to evaluate the state-continuation monad m with the initial state s, computing the encapsulated sequence.
expr_of_seq [Cf_regex]
Use expr_of_seq z to evaluate the character sequence z as a regular expression and produce the corresponding DFA expression.
expr_of_string [Cf_regex]
Use expr_of_string s to evaluate the string s as a regular expression and produce the corresponding DFA expression.
expr_parse [Cf_regex]
A parser combinator on character streams that recognizes a regular expression and produces a DFA expression for it.
extract [Cf_map.T]
Use extract k m to obtain the value associated with the key k in the tree m and a new tree with the key deleted from the tree.

F
fcmp [Cf_seq]
fcmp f a b compares two sequences by applying f to the elements of each sequence in turn until the result is non-zero, or the end of one or both sequences is reached.
field [Cf_scmonad]
Use field f to produce a monad that returns the result of applying f to the value of the encapsulated state.
field [Cf_smonad]
Use field f to produce a monad that returns the result of applying f to the value of the encapsulated state.
filter [Cf_parser]
Use filter f p to produce a parser that applies f to each output symbol of p and ignores all those for which the result is false.
filter [Cf_set.T]
Use filter f s to produce a new set comprised of all the elements of the set s that satisfy the filtering function f, applying the elements in an arbitrary order (not increasing or decreasing).
filter [Cf_map.T]
Use filter f m to obtain a new tree comprised of all the key-value pairs in the tree m that satisfy the filtering function f.
filter [Cf_pqueue.T]
Use filter f q to apply f to each element in the priority queue q in an arbitrary order (not to top bottom), and produce a new heap that contains only those elements for which f pair returned true.
filter [Cf_heap.T]
Use filter f h to apply f to each element in the heap h in an arbitrary order (not to top bottom), and produce a new heap that contains only those elements for which f pair returned true.
filter [Cf_flow]
Use filter f to construct a stream processor that applies f to every input value and outputs only those for which the function result is true.
filter [Cf_deque]
filter f d returns a new deque composed by applying f to every element in d, including only those elements for which the result is true.
filter [Cf_seq]
filter f s returns the sequence produced by applying f to every element of s and taking all the elements for which the result is true.
filter2 [Cf_seq]
filter2 f a b is like filter f s, except it operates on a pair of sequences simultaneously, until one or both sequences reaches its end.
fin [Cf_parser]
A parser that produces the unit value when it recognizes the end of the input token sequence.
first [Cf_seq]
first s returns the sequence of elements composed by taking only the first object in an element pair.
first [Cf_tai64n]
The earliest TAI epoch representable in the TAI64N format.
first [Cf_tai64]
The earliest TAI epoch representable in the TAI64 format.
flatten [Cf_message]
Use flatten m to reduce a message list of two or more substrings to a single substring.
flatten [Cf_seq]
flatten a returns the sequence of all the elements in the sequence of sequences by concatenating them.
flush [Cf_flow]
Use flush w to discard all the output from the flow w until the first input is required.
fold [Cf_set.T]
Use fold f a s to fold the elements of the set s into the folding function f with the initial state a, by applying the elements in an arbitrary order (not increasing or decreasing).
fold [Cf_map.T]
Use fold f s m to fold the every key-value pair in the tree m into the state s with the folding function f, visiting the elements in an arbitrary order (not increasing or decreasing).
fold [Cf_pqueue.T]
Use fold f s q to produce the result of folding a value s into the elements of priority queue q with the folding function f in an arbitrary order (not top to bottom).
fold [Cf_heap.T]
Use fold f s h to produce the result of folding a value s into the elements of heap h with the folding function f in an arbitrary order (not top to bottom).
fold [Cf_deque.Direction_T]
fold f a0 d is f (... (f (f a0 e0) e1) ...) en when e0..en are the elements of the deque d.
fold [Cf_seq]
fold f a s is like List.fold_left and is the result of applying f to the elements in sequence, i.e.
fold2 [Cf_seq]
fold2 f a s1 s2 is like fold f a s, except it operates on a pair of sequences simultaneously, until one or both sequences reaches its end.
format [Cf_ip6_addr]
Use format a to obtain the address format of the IPv6 address a.

G
get [Cf_dfa.Symbol_T]
The engine uses get m s to get the state transition from map m for the symbol s.
getpeername [Cf_socket]
Use getpeername sock to create a new socket address corresponding to the connected remote endpoint of the socket sock.
getsockname [Cf_socket]
Use getsockname sock to create a new socket address corresponding to the local bound endpoint of the socket sock.
getsockopt [Cf_socket]
Use getsockopt sock opt to obtain the value associated with the socket option opt for the socket descriptor sock.
guard [Cf_state_gadget]
Use guard m to receive the next message guarded by m.
guard [Cf_gadget]
Use guard m to receive the next message guarded by m.

H
head [Cf_pqueue.T]
Use head q to obtain the element on the top of the priority queue q.
head [Cf_heap.T]
Use head h to obtain the element on the top of the heap h.
head [Cf_deque.Direction_T]
head d returns the element at the end of the deque d.
head [Cf_seq]
Returns the first element in the sequence.

I
icmp [Cf_ip_common]
The Internet Control and Management Protocol.
indextoname [Cf_netif]
Use indextoname index to get the index for the interface name.
ingestor [Cf_flow]
A stream processor that copies to its output every element of its input sequences.
init [Cf_scmonad]
Use init x to produce a monad that discards the current intermediate result and returns x as the continuation context.
init [Cf_cmonad]
Use init x to produce a monad that discards the current intermediate result and returns x as the continuation context.
insert [Cf_message]
Use insert ~pos ~m m1 to return a new message with all the text in message m inserted into the message m1 at the position pos.
insert [Cf_map.T]
Use insert p m to insert the key-value pair p into the tree m, producing a new tree with the inserted element and, if the key k is already present in m, the value replaced by the insertion.
intersect [Cf_set.T]
Use interset s1 s2 to obtain a new set from the intersection of the sets s1 and s2.
ip_add_membership [Cf_ip4_proto]
Add the socket to the membership of a multicast group.
ip_drop_membership [Cf_ip4_proto]
Drop the socket from the membership of a multicast group.
ip_multicast_if [Cf_ip4_proto]
The primary network interface address for sending to multicast destinations.
ip_multicast_loop [Cf_ip4_proto]
Enable multicast loopback on the socket.
ip_multicast_ttl [Cf_ip4_proto]
The multicast hop count for the socket.
ip_ttl [Cf_ip4_proto]
Set the unicast hop count for the socket.
ipv4 [Cf_ip_common]
The Internet Protocol (version 4) for tunneling.
ipv6 [Cf_ip_common]
The Internet Protocol (version 6) for tunneling.
ipv6_join_group [Cf_ip6_proto]
Add the socket to the membership of a multicast group.
ipv6_leave_group [Cf_ip6_proto]
Drop the socket from the membership of a multicast group.
ipv6_multicast_hops [Cf_ip6_proto]
The multicast hop count for the socket.
ipv6_multicast_if [Cf_ip6_proto]
The primary network interface address for sending to multicast destinations.
ipv6_multicast_loop [Cf_ip6_proto]
Enable multicast loopback on the socket.
ipv6_unicast_hops [Cf_ip6_proto]
Set the unicast hop count for the socket.
ipv6_v6only [Cf_ip6_proto]
Set the unicast hop count for the socket.
is_experimental [Cf_ip4_addr]
Use is_experimental a to validate that an IPv4 address is an experimental address.
is_multicast [Cf_ip6_addr]
Use is_multicast a to validate that the IPv6 address a is a multicast address.
is_multicast [Cf_ip4_addr]
Use is_multicast a to validate that an IPv4 address is a multicast address.
is_specific_domain [Cf_nameinfo]
Returns true if the socket address is of the specific domain.
is_specific_socktype [Cf_nameinfo]
Returns true if the socket types are equivalent.
is_unicast [Cf_ip6_addr]
Use is_unicast a to validate that the IPv6 address a is a unicast address.
is_unicast [Cf_ip4_addr]
Use is_unicast a to validate that an IPv4 address is a unicast address.
is_v4compat [Cf_ip6_addr]
Use is_v4compat a to obtain the opaque IPv4 address corresponding to the v4-compat IPv6 address.
is_v4mapped [Cf_ip6_addr]
Use is_v4mapped a to obtain the opaque IPv4 address corresponding to the v4-mapped IPv6 address.
is_valid [Cf_gregorian]
is_valid ~year ~month ~day returns true if year, month and day arguments specify a valid Gregorian date.
iterate [Cf_set.T]
Use iterate f s to apply the iterator function f to every element in the set s in arbitrary order (not increasing or decreasing).
iterate [Cf_map.T]
Use iterate f m to apply the function f to each key-value pair in the tree m in an arbitrary order (not increasing or decreasing).
iterate [Cf_pqueue.T]
Use iterate f q to apply f to every element in the priority queue q in an arbitrary order (not top to bottom).
iterate [Cf_heap.T]
Use iterate f h to apply f to every element in the heap h in an arbitrary order (not top to bottom).
iterate [Cf_deque]
iterate f d applies f to every element in d in left-to-right order.
iterate [Cf_seq]
iterate f s evaluates the entire sequence s, applying f to each element in order until the end of the sequence is reached.
iterate2 [Cf_seq]
iterate2 f a b is like iterate f s, except it operates on a pair of sequences simultaneously, until one or both sequences reaches its end.

L
last [Cf_flow.Transcode]
Use last w z to produce the final sequence of output values obtained by executing the transcoder stream processor w after ingesting the "end of input" indication.
last [Cf_tai64n]
The latest TAI epoch representable in the TAI64N format.
last [Cf_tai64]
The latest TAI epoch representable in the TAI64 format.
length [Cf_message]
Use length m to compute the length of the message m.
length [Cf_deque]
length d computes the number elements contained in the deque d.
length [Cf_seq]
Evaluates the entire sequence and returns the number elements.
lift [Cf_scmonad]
Use lift m to lift a stateless continuation monad into a state-continuation monad.
limit [Cf_seq]
limit n s returns the sequence of all the elements in s, up to n elements in number and no more.
link_local_all_nodes [Cf_ip6_addr]
The link-local all-nodes multicast address, i.e.
link_local_all_routers [Cf_ip6_addr]
The link-local all-routers multicast address, i.e.
listen [Cf_socket]
Use listen sock n to set the socket sock into the mode of listening for connections with a backlog queue n spaces deep.
listmap [Cf_flow]
Use listmap f to construct a stream processor that applies f to every input value and outputs every element of the resulting list.
listmap [Cf_deque]
listmap f d returns a new deque composed by applying f to every element in d in left-to-right order, taking all the resulting lists of elements in order.
listmap [Cf_seq]
listmap f s returns the sequence produced by applying f to every element of s and taking all the resulting lists of elements in order.
listmap2 [Cf_seq]
listmap2 f a b is like listmap f s, except it operates on a pair of sequences simultaneously, until one or both sequences reaches its end.
lit [Cf_parser.X]
Use lit s obj to obtain a parser on character input sequences that produces the output obj when it recognizes the literal s in the input.
lit [Cf_parser]
Use lit s obj to obtain a parser on character input sequences that produces the output obj when it recognizes the literal s in the input.
load [Cf_state_gadget]
Bind load to get the current state encapsulated in the process.
load [Cf_scmonad]
A monad that returns the encapsulate state as an intermediate result.
load [Cf_smonad]
A monad that returns the encapsulate state.
loopback [Cf_ip6_addr]
The default loopback IPv6 unicast address, i.e.
loopback [Cf_ip4_addr]
The default loopback host address, i.e.

M
machine [Cf_flow]
Use machine f s with an initial state value s and a folding function f to construct a stream processor that folds the state into every input value to produce either a sequence of values to output and a new state or the end of stream processing.
map [Cf_dfa.Symbol_T]
The engine uses map f to construct a map from symbols to state transitions.
map [Cf_parser]
Use map f p to produce a parser that transforms each output symbol of p by applying f to its value.
map [Cf_map.T]
Use map f m to obtain a new tree produced by applying the mapping function f to the key and the value of each key-value pair in the tree m and associating the resulting value to the key in the new tree.
map [Cf_pqueue.T]
Use map f q to obtain a new heap by applying the mapping function f to the key and the value of every element in the priority queue q to obtain a mapped element with the same key and a new value.
map [Cf_flow]
Use map f to construct a stream processor that applies f to every input value and outputs the result.
map [Cf_deque]
map f d returns a new deque composed by applying f to every element in d in left-to-right order.
map [Cf_seq]
map f s returns the sequence produced by transforming every element in s by applying it to f.
map2 [Cf_seq]
map2 f a b is like map f s, except it operates on a pair of sequences simultaneously, until one or both sequences reaches its end.
mapstate [Cf_flow]
Use mapstate f s with an initial state value s and a folding function f to construct a stream processor that folds the state into every input value to produce an output value and a new state.
max [Cf_set.T]
Use min s to return the ordinally greatest element in the set s.
max [Cf_map.T]
Use max m to obtain the key-value pair with the ordinally maximum key in the tree m.
member [Cf_set.T]
Use member e s to test whether the element e is a member of the set s.
member [Cf_map.T]
Use member k m to test whether the tree m contains the key k.
merge [Cf_pqueue.T]
Use merge q1 q2 to obtain a new priority queue that is the result of merging all the elements of q1 and q2 into a single heap.
merge [Cf_heap.T]
Use merge h1 h2 to obtain a new heap that is the result of merging all the elements of h1 and h2 into a single heap.
message_of_uri [Cf_uri]
Use message_of_uri uri to produce a message containing the formatted URI string produced by emitting uri into a string.
message_of_uri_reference [Cf_uri]
Use message_of_uri_reference uriref to produce a message containing the formatted URI reference string produced by emitting uriref into a string.
message_to_absolute_uri [Cf_uri]
Use message_to_absolute_uri ~base m to create an absolute URI by parsing the contents of the message m and using base as the absolute URI for reference in parsing relative URI.
message_to_absolute_uri_reference [Cf_uri]
Use message_to_absolute_uri_reference ~base m to create a URI reference to an absolute URI by parsing the contents of the message m and using base as the absolute URI for reference parsing relative URI.
message_to_uri [Cf_uri]
Use message_to_uri m to create a URI by parsing the contents of the message m.
message_to_uri_reference [Cf_uri]
Use message_to_uri_reference m to create a URI reference by parsing the contents of the message m.
min [Cf_set.T]
Use min s to return the ordinally least element in the set s.
min [Cf_map.T]
Use min m to obtain the key-value pair with the ordinally minimum key in the tree m.
modify [Cf_state_gadget]
Bind the result of modify f to apply f to the current encapsulated state of the process and store the resulting new state.
modify [Cf_map.T]
Use modify k f m to obtain a new tree produced by replacing the value in the tree m associated with the key k with the result of applying it to the continuation function f.
modify [Cf_scmonad]
Use modify f to produce a monad that applies f to the encapsulated state to obtain a new state value, and which returns the unit value as its intermediate result.
modify [Cf_smonad]
Use modify f to produce a monad that applies f to the encapsulated state to obtain a new state value, and which returns the unit value as its result when evaluated.
more [Cf_flow.Transcode]
Use more w z to produce an intermediate sequence of output values obtained by executing the transcoder stream processor w to ingest all the elements of the sequence z.
msg_flags_none [Cf_socket]
The default value of the message flags structure, i.e.
multicast_realm [Cf_ip4_addr]
Use multicast realm a to identify the address of the multicast address a.

N
nameindex [Cf_netif]
Use nameindex () to obtain the current list of network interfaces, by index and name.
nametoindex [Cf_netif]
Use nametoindex name to get the index for the interface name.
nearest_decr [Cf_set.T]
Use nearest_decr k s to obtain the key-value pair ordinally less than or equal to the key k in the set s.
nearest_decr [Cf_map.T]
Use nearest_decr k m to obtain the key-value pair ordinally less than or equal to the key k in the map m.
nearest_incr [Cf_set.T]
Use nearest_incr k s to obtain the element ordinally greater than or equal to the key k in the set s.
nearest_incr [Cf_map.T]
Use nearest_incr k m to obtain the key-value pair ordinally greater than or equal to the key k in the map m.
net_broadcast [Cf_ip4_addr]
Use net_broadcast n to produce the IPv4 address conventionally used to identify the broadcast address for the network or subnet.
net_create [Cf_ip4_addr]
Use net_create ?subnet a to create an IPv4 network identifier that contains the address a in its logical scope, optional constraining the network to subnetwork of width subnet.
net_decreasing [Cf_ip4_addr]
Use net_decreasing n to obtain the sequence of unicast IPv4 addresses belong to the network n in decreasing order.
net_increasing [Cf_ip4_addr]
Use net_increasing n to obtain the sequence of unicast IPv4 addresses belong to the network n in increasing order.
net_mask [Cf_ip4_addr]
Use net_mask n to return a string representation of the subnet mask for the network n in traditional dot-quad format.
net_member [Cf_ip4_addr]
Use net_member n a to test whether the address a is in the scope of the network n.
net_number [Cf_ip4_addr]
Use net_number n to produce the IPv4 address conventionally used to identify the network.
net_prefix [Cf_ip4_addr]
Use net_prefix to obtain the number of bits in the subnet mask.
nil [Cf_lex]
Epsilon, i.e.
nil [Cf_dfa.T]
The expression that matches the empty symbol sequence.
nil [Cf_parser]
A parser that never recognizes any input, i.e.
nil [Cf_set.T]
The empty set.
nil [Cf_map.T]
The empty tree.
nil [Cf_pqueue.T]
The empty priority queue.
nil [Cf_heap.T]
The empty heap.
nil [Cf_flow]
A stream processor that reads no input and writes no output.
nil [Cf_deque]
The empty deque.
nil [Cf_seq]
An empty sequence.
nil [Cf_scmonad]
A monad that returns unit and performs no operation.
nil [Cf_cmonad]
A monad that returns unit and performs no operation.
nil [Cf_smonad]
A monad that returns unit and performs no operation.
node_local_all_nodes [Cf_ip6_addr]
The node-local all-nodes multicast address, i.e.
nop [Cf_flow]
A stream processor that outputs every input value without change.
normalize [Cf_message]
Use normalize m to discard empty substrings from the list.
now [Cf_tai64n]
Returns the current time in TAI64N, obtained by reading the current time from the POSIX gettimeofday() function, and adjusting for leap seconds.
now [Cf_tai64]
Returns the current time in TAI64, obtained by reading the current time from the POSIX time() function, and adjusting for leap seconds.
ntop [Cf_ip6_addr]
Use ntop a to obtain a string representation of the IPv6 address a in canonical numeric format.
ntop [Cf_ip4_addr]
Use ntop a to obtain a string representation of the IPv4 address a in dot-quad format.
null [Cf_state_gadget]
Use null to construct a rx object that produces gates that never receive any messages, and a tx object that discards every message transmitted without deliver it.
null [Cf_gadget]
Use null to construct a rx object that produces gates that never receive any messages, and a tx object that discards every message transmitted without deliver it.

O
of_address [Cf_nameinfo]
Use of_address ?host ?serv ?flags sa to resolve the name of the host and the service associated with the socket address sa.
of_address_default_flags [Cf_nameinfo]
The default value of flags for the of_address function below (all flags set to false).
of_array [Cf_seq]
of_array v is like of_string s, except that it operates on an 'a array value instead of a string value.
of_channel [Cf_seq]
of_channel c returns the sequence of characters produced by reading them on demand from the channel c.
of_cjd [Cf_gregorian]
of_cjd ?wday ?yday cjd returns a 3-tuple (year, month, day) with the year, month and day of the corresponding Gregorian date represented in integer form.
of_expression [Cf_regex]
Use of_expression x to produce a regular expression from the DFA expression x.
of_extended [Cf_parser]
Use of_extended c p to convert the parser p that requires position information in the input stream into a parser that assumes the input begins at the position of the cursor c.
of_function [Cf_seq]
of_function f returns a sequence produced by applying f () repeatedly until Not_found is raised.
of_label [Cf_tai64n]
Interprets the argument as a TAI64N label and returns the corresponding TAI64N value.
of_label [Cf_tai64]
Interprets the argument as a TAI64 label and returns the corresponding TAI64 value.
of_list [Cf_set.T]
Use of_list s to iterate a list of elements and compose a new set by inserting them in order.
of_list [Cf_map.T]
Use of_list s to compose a tree by iterating the list of key-value pairs s and inserting them in order into a new tree.
of_list [Cf_pqueue.T]
Use of_list s to construct a priority queue from a list of elements.
of_list [Cf_heap.T]
Use of_list s to construct a heap from a list of elements.
of_list [Cf_deque.Direction_T]
Use of_list s to construct a deque from a list of elements.
of_list [Cf_seq]
of_list s converts a 'a list value into a sequence.
of_list_decr [Cf_set.T]
Use of_list_decr s to compose the set with elements in the ordered list s.
of_list_decr [Cf_map.T]
Use of_list_decr s to compose a tree with the key-value pairs in the ordered list s.
of_list_incr [Cf_set.T]
Use of_list_incr s to compose the set with elements in the ordered list s.
of_list_incr [Cf_map.T]
Use of_list_incr s to compose a tree with the key-value pairs in the ordered list s.
of_multicast_components [Cf_ip6_addr]
Use of_multicast_components scope flags gid to compose an IPv6 multicast address from the scope, flags and gid components.
of_seq [Cf_regex]
Use of_seq z to ingest the whole character sequence z, parse it and produce a regular expression.
of_seq [Cf_set.T]
Use of_seq z to evaluate a sequence of elements and compose a new set by inserting them in order.
of_seq [Cf_map.T]
Use of_seq z to compose a tree by evaluating the entire sequence of key-value pairs z and inserting them in order into a new tree.
of_seq [Cf_pqueue.T]
Use of_seq z to construct a priority queue from a sequence of elements.
of_seq [Cf_heap.T]
Use of_seq z to construct a heap from a sequence of elements.
of_seq [Cf_flow]
Use of_seq z to convert a sequence into the equivalent stream processor (which never ingests any input).
of_seq [Cf_deque.Direction_T]
Use of_seq z to construct a deque from a sequence of elements.
of_seq_decr [Cf_set.T]
Use of_seq_decr z to compose the set with elements in the ordered sequence z.
of_seq_decr [Cf_map.T]
Use of_seq_decr z to compose a tree with the key-value pairs in the ordered sequence z.
of_seq_incr [Cf_set.T]
Use of_seq_incr z to compose the set with elements in the ordered sequence z.
of_seq_incr [Cf_map.T]
Use of_seq_incr z to compose a tree with the key-value pairs in the ordered sequence z.
of_sockaddr [Cf_socket.AF]
Use of_sockaddr sa to create an address corresponding to the abstract socket address value sa.
of_string [Cf_regex]
Use of_string s to produce a regular expression from the string s.
of_string [Cf_seq]
of_string s returns the sequence of characters produced by extracting them on demand from the string s with String.unsafe_get.
of_subarray [Cf_seq]
of_subarray v pos is like of_substring s pos, except that it operates on an 'a array value instead of a string value.
of_substring [Cf_seq]
of_substring s pos returns the sequence of characters produced by extracting them on demand from the string s with String.unsafe_get.
of_ucs4 [Cf_unicode.Encoding_T]
A flow that reads a stream of 31-bit UCS4 integer codes and writes them as a stream of encoded characters.
of_unix_time [Cf_tai64n]
Converts a value consistent with the result of calling the Unix.gettimeofday function into a TAI64N value.
of_unix_time [Cf_tai64]
Converts a value consistent with the result of calling the Unix.time function into a TAI64 value.
optmap [Cf_parser]
Use optmap f p to produce a parser that transforms each output symbol of p by applying f to its value and ignoring all those for which the result is None.
optmap [Cf_map.T]
Use optmap f m to obtain a new tree produced by applying the mapping function f to the key and the value of each key-value pair in the tree m and associating the resulting value to the key in the new tree.
optmap [Cf_pqueue.T]
Use optmap f q to obtain a new heap by applying the mapping function f to the key and the value of every element in priority queue q to obtain a mapped element with the same key and a new value.
optmap [Cf_flow]
Use optmap f to construct a stream processor that applies f to every input value and outputs the result if there is one.
optmap [Cf_deque]
optmap f d returns a new deque composed by applying f to every element in d in left-to-right order, including only those elements of d for which f returns Some value.
optmap [Cf_seq]
optmap f s returns the sequence produced by applying f to every element of s and taking all the Some a results in order.
optmap2 [Cf_seq]
optmap2 f a b is like optmap f s, except it operates on a pair of sequences simultaneously, until one or both sequences reaches its end.

P
parse [Cf_regex]
Use parse r to produce a parser that matches the input stream to the regular expression r and returns the corresponding string value.
parsex [Cf_regex]
Use parse r to produce a parser that matches the input stream to the regular expression r and returns the corresponding string value.
partition [Cf_set.T]
Use partition f s to produce two new sets by applying the partitioning function f to every element in the set s in an arbitrary order (not increasing or decreasing).
partition [Cf_map.T]
Use partition f m to obtain a pair of new trees produced by applying the partitioning function f to all the elements in the tree m in an arbitrary order (not increasing or descreasing).
partition [Cf_pqueue.T]
Use partition f q to obtain a pair of new priority queues that are the result of applying the partitioning function f to each element in the queue q in an arbitrary order (not top to bottom).
partition [Cf_heap.T]
Use partition f h to obtain a pair of new heaps that are the result of applying the partitioning function f to each element in the heap h in an arbitrary order (not top to bottom).
partition [Cf_deque]
partition f s returns two deques.
partition [Cf_seq]
partition f s returns two sequences.
pop [Cf_message]
Use pop ~len q to pop a message of length no larger than len from the B end of the substring deque q.
pop [Cf_pqueue.T]
Use pop q to obtain the head and the tail of a priority queue q in one operation.
pop [Cf_heap.T]
Use pop h to obtain the head and the tail of a heap h in one operation.
pop [Cf_deque.Direction_T]
pop d returns None if d is the empty deque, otherwise it returns Some (x, d') where x is the element on the end of the deque, and d' is the remainder of d with the element x removed.
predicate [Cf_set.T]
Use predicate f s to test whether all the elements in the set s satisfy the predicate function f, visiting the elements in an arbitrary order (not increasing or decreasing) until f returns false or all elements are tested.
predicate [Cf_map.T]
Use predicate f m to test whether all the key-value pairs in the tree m satisfy the predicate function f.
predicate [Cf_pqueue.T]
Use predicate f q to test whether all the elements in priority queue q satisfy the predicate function f.
predicate [Cf_heap.T]
Use predicate f h to test whether all the elements in heap h satisfy the predicate function f.
predicate [Cf_deque]
predicate f d returns true if the result of applying f to every element in the deque d is true, or if d is the empty deque.
predicate [Cf_seq]
predicate f s evaluates as much of the sequence s as necessary to determine that every element satisfy the predicate function f.
predicate2 [Cf_seq]
predicate2 f a b is like predicate f s, except it operates on a pair of sequences simultaneously, until one or both sequences reaches its end.
protocol [Cf_socket.P]
The abstract protocol identifier.
pton [Cf_ip6_addr]
Use pton s to convert the string s containing an IPv6 address in numeric format to its equivalent opaque IPv6 address.
pton [Cf_ip4_addr]
Use pton s to convert the string s containing an IPv4 address in dot-quad format to its equivalent opaque IPv4 address.
push [Cf_message]
Use push m q to push the message m into the A end of the substring queue q.
push [Cf_deque.Direction_T]
push x d adds the element x to the end of the deque d.
put [Cf_set.T]
Use put e s to obtain a new set produced by inserting the element e into the set s.
put [Cf_pqueue.T]
Use put e q to obtain a new priority queue that is the result of inserting the element e into the queue q.
put [Cf_heap.T]
Use put e h to obtain a new heap that is the result of inserting the element e into the heap h.

Q
quote [Cf_regex]
A character flow that quotes all the special characters in the input so that the output may be used in a regular expression to match the input exactly.

R
read [Cf_state_gadget]
Bind read to get the next input value from the external stream.
read [Cf_gadget]
Bind read to get the next input value from the external stream.
readC [Cf_flow]
The continuation monad that returns a value obtained from the flow produced by its evaluation.
readSC [Cf_flow]
The state-continuation monad that returns a value obtained from the flow produced by its evaluation.
recv [Cf_socket]
Use recv sock buf pos len flags to receive len octets into the string buf starting at position pos on the socket sock with the flags indicated by flags.
recvfrom [Cf_socket]
Use recvfrom sock buf pos len flags to receive len octets into the string buf starting at position pos on the socket sock with the flags indicated by flags.
refer_to_base [Cf_uri]
Use refer_to_base ~base ~rel to compose an absolute URI by directing the relative URI rel from the base absolute URI base.
replace [Cf_map.T]
Use replace p m to obtain a new tree produced by inserting the key-value pair p into the tree m, replacing any existing pair associated to the same key.
req [Cf_parser.X]
Use req ?f p to create a parser that requires the input stream to match the parser p or it will be passed to the parser err ?f () instead.
req [Cf_parser]
Use req f p to create a parser that requires the input stream to match the parser p or it will be passed to the parser err f instead.
return [Cf_scmonad]
Use return a to produce a monad that returns a as an intermediate result from the current continuation.
return [Cf_cmonad]
Use return a to produce a monad that returns a as an intermediate result from the current continuation.
return [Cf_smonad]
Use return a to produce a monad that returns a when evaluated.
reverse [Cf_seq]
reverse s evaluates the entire sequence and composes a list of the elements in reverse order.

S
sat [Cf_parser.X]
Use sat f to create a parser that recognizes, shifts and reduces input tokens for which the satisfier function f returns true.
sat [Cf_parser]
Use sat f to create a parser that recognizes, shifts and reduces input tokens for which the satisfier function f returns true.
scanf [Cf_scan_parser]
Use scanf fmt rf to construct a lexical parser that scans the input text according to the scanning format fmt and produces the value returned by the return continuation.
scanfx [Cf_scan_parser]
Use scanfx in place of scanf to construct a parser with a cursor weaved into the input stream.
search [Cf_regex]
Use search r z to search the character sequence z for a pattern that matches the regular expression r.
search [Cf_map.T]
Use search k m to obtain the value associated with the key k in the tree m.
search [Cf_seq]
search f s evaluates the sequence s until the result of applying f is true and returns the number of elements applied that resulted in a false result.
second [Cf_seq]
second s returns the sequence of elements composed by taking only the second object in an element pair.
send [Cf_socket]
Use send sock buf pos len flags to send len octets from the string buf starting at position pos on the socket sock with the flags indicated by flags.
sendto [Cf_socket]
Use sendto sock buf pos len flags sa to send len octets from the string buf starting at position pos on the socket sock with the flags indicated by flags to the socket address sa.
sentinel [Cf_seq]
sentinel x s returns a sequence identical to s except that x is raised by evaluating to the end.
separate [Cf_regex]
Use separate r z to map the character sequence z into the sequence of sequences found between matches for the regular expression r.
seqmap [Cf_flow]
Use listmap f to construct a stream processor that applies f to every input value and outputs every element of the resulting sequence.
seqmap [Cf_deque]
seqmap f d returns a new deque composed by applying f to every element in d in left-to-right order, taking all the resulting sequences of elements in order.
seqmap [Cf_seq]
seqmap f s returns the sequence produced by applying f to every element of s and taking all the resulting sequences of elements in order.
seqmap2 [Cf_seq]
seqmap2 f a b is like seqmap f s, except it operates on a pair of sequences simultaneously, until one or both sequences reaches its end.
sequence [Cf_seq.SC]
Use sequence z to compose a monad that binds all of the monads in the sequence z in the order specified.
sequence [Cf_seq.C]
Use sequence z to compose a monad that binds all of the monads in the sequence z in the order specified.
sequence [Cf_seq.S]
Use sequence z to compose a monad that binds all of the monads in the sequence z in the order specified.
setsockopt [Cf_socket]
Use setsockopt sock opt v to set the value associated with the socket option opt for the socket descriptor sock to the value v.
shift [Cf_message]
Use shift ~pos m to return a new message with all the text in message m before the position pos removed.
shift [Cf_seq]
shift n s returns the sequence of all the elements in s after the first n elements are discarded.
shiftq [Cf_message]
Use shiftq ~len q to discard the first len octets from the B end of the substring deque q.
shutdown [Cf_socket]
Use shutdown sock cmd to shutdown either sending or receiving (or both) on the socket sock.
simplex [Cf_state_gadget]
Use simplex to construct a new maching pair of rx and tx objects.
simplex [Cf_gadget]
Use simplex to construct a new maching pair of rx and tx objects.
singleton [Cf_set.T]
Use singleton e to compose a new set containing only the element e.
siocgifaddr [Cf_ip4_proto]
Use siocgifaddr sock name with any `AF_INET address family socket sock to get the primary IP address for the name interface.
size [Cf_set.T]
Use size s to compute the size of the set s.
size [Cf_map.T]
Use size m to count the number of elements in the tree m.
size [Cf_pqueue.T]
Use size q to count the number of elements in the priority queue q.
size [Cf_heap.T]
Use size h to count the number of elements in the heap h.
so_broadcast [Cf_socket]
Enables permission to transmit broadcast messages.
so_debug [Cf_socket]
Enables recording of debugging information.
so_dontroute [Cf_socket]
Enables routing bypass for outgoing messages.
so_error [Cf_socket]
Get and clear the error on the socket (get only).
so_keepalive [Cf_socket]
Enables connection keep-alives.
so_linger [Cf_socket]
Enables linger on close if data present.
so_nosigpipe [Cf_socket]
Do not generate SIGPIPE.
so_oobinline [Cf_socket]
Enables in-band reception of out-of-band/expedited messages.
so_rcvbuf [Cf_socket]
Set buffer size for input.
so_rcvlowat [Cf_socket]
Set minimum octet count for input.
so_rcvtimeo [Cf_socket]
Set timeout for input.
so_reuseaddr [Cf_socket]
Enables local address reuse.
so_reuseport [Cf_socket]
Enables duplicate address and port bindings.
so_sndbuf [Cf_socket]
Set buffer size for output.
so_sndlowat [Cf_socket]
Set minimum octet count for output.
so_sndtimeo [Cf_socket]
Set timeout for output.
socktype [Cf_socket.ST]
The value of the socket type identifier.
specialize_sockaddr [Cf_nameinfo]
Use specialize_sockaddr sa d to specialize a socket address sa from the unspecified (or unknown) address family into a socket address of the address family associated with the socket domain d.
split [Cf_regex]
Use split r s to produce a list of strings by searching s left to right for blocks of characters between patterns that match the regular expression r.
split [Cf_message]
Use split ~pos m to return two new messages, the first containing all the text in message m before the position pos, and the second containing all the remaining text in message m.
split [Cf_seq]
split s is equivalent to (first s, second s).
start [Cf_state_gadget]
Bind the result of start y s to start a new process evaluating the gadget y with a state initializer s.
start [Cf_gadget]
Use start y to start a new gadget evaluating the gadget y.
stderr [Cf_journal]
A basic agent, initially set with a limit of `Notice, and with with one basic archiver for the Pervasives.stderr channel.
stdout [Cf_journal]
A basic agent, initially set with a limit of `Notice, and with with one basic archiver for the Pervasives.stdout channel.
store [Cf_state_gadget]
Bind the result of store obj to store the state obj as the encapsulated state for the current monad.
store [Cf_scmonad]
Use store s to produce a monad with s as the value of its encapsulated state.
store [Cf_smonad]
Use store s to produce a monad with s as the value of its encapsulated state.
sub [Cf_tai64n]
Subtract one TAI64N value from another.
sub [Cf_tai64]
Subtract one TAI64 value from another.
subset [Cf_set.T]
Use subset s1 s2 to test whether the set s1 is a subset of s2.

T
tail [Cf_pqueue.T]
Use tail q to obtain the heap produced by discarding the element on the top of the priority queue q.
tail [Cf_heap.T]
Use tail h to obtain the heap produced by discarding the element on the top of heap h.
tail [Cf_deque.Direction_T]
tail d is discards the element at the end of the deque d.
tail [Cf_seq]
Discards the first element in the sequence and returns the sequence of remaining elements.
tcp [Cf_ip_common]
The Internet Transmission Control Protocol.
tcp_nodelay [Cf_ip_common]
Disables the Nagle algorithm for TCP connections.
test [Cf_regex]
Use test r s to test whether the string s matches the regular expression r.
to_address_default_flags [Cf_nameinfo]
The default value of ai_flags record field for the hints provided to the to_address function below (all flags set to false).
to_addresses [Cf_nameinfo]
Use to_addresses hint arg to obtain a list of address information records associated with the host name and/or service name provided in the argument arg, using the hints provided in the hint argument.
to_all_addresses [Cf_nameinfo]
Use to_all_address arg to obtain a list of address information records associated with the host name and/or service name provided in the argument arg.
to_array [Cf_seq]
to_array v is like to_string s, except that it constructs an 'a array value instead of a string value.
to_buffer [Cf_seq]
to_buffer s b is like to_channel s c except that characters are output to a Buffer object, instead of an out_channel object.
to_channel [Cf_seq]
to_channel s c evaluates the entire character sequence s and puts each character produced into the out_channel object in a tail-recursive loop.
to_cjd [Cf_gregorian]
to_cjd ~year ~month ~day returns the Chronological Julian Day number of the specified Gregorian date.
to_cjd_unsafe [Cf_gregorian]
to_cjd_unsafe ~year ~month ~day is the same as to_cjd ~year ~month ~day, except the parameters are not checked for boundaries and that the date is a valid Gregorian date.
to_extended [Cf_parser]
Use to_extended p to convert the parser p into an extended parser that ignores the position information woven into the input stream.
to_function [Cf_message]
to_function m returns a function that returns successive characters from the message m each time it is called, until it raises x when there are no more characters.
to_function [Cf_seq]
to_function s returns a function that evaluates the next value in the sequence each time it's called.
to_label [Cf_tai64n]
Returns a string of 8 characters containing the TAI64N label corresponding to the TAI64N value of its argument.
to_label [Cf_tai64]
Returns a string of 8 characters containing the TAI64 label corresponding to the TAI64 value of its argument.
to_list [Cf_deque.Direction_T]
to_list d returns the elements in the deque in the order they would appear by successive calls of pop d.
to_list [Cf_seq]
to_list s is the same as List.rev (reverse s).
to_list_decr [Cf_set.T]
Use to_list_decr s to produce the list of elements in the set s in order of decreasing ordinality.
to_list_decr [Cf_map.T]
Use to_list_decr m to obtain a sequence of the key-value pairs in the tree m in order of descreasing ordinality.
to_list_incr [Cf_set.T]
Use to_list_incr s to produce the list of elements in the set s in order of increasing ordinality.
to_list_incr [Cf_map.T]
Use to_list_incr m to obtain a sequence of the key-value pairs in the tree m in order of increasing ordinality.
to_multicast_components [Cf_ip6_addr]
Use to_multicast_components a to obtain the scope, flags and group id of the IPv6 multicast address a.
to_seq [Cf_message]
Use to_seq m to obtain the sequence of characters in message m.
to_seq [Cf_pqueue.T]
Use to_seq q to produce a sequence of elements in top to bottom order from the priority queue q.
to_seq [Cf_heap.T]
Use to_seq h to produce a sequence of elements in top to bottom order from the heap h.
to_seq [Cf_flow]
Use to_seq w to convert a stream processor w into the equivalent sequence.
to_seq [Cf_deque.Direction_T]
to_seq d returns a lazily evaluated sequence of the elements in the deque in the order they would appear by successive calls of pop d.
to_seq2 [Cf_pqueue.T]
Use to_seq2 q to produce a sequence of elements from the priority queue q, where the first element of each pair is a key-value pair obtained from the head of the queue, and the second element of the pair is the corresponding tail of the queue.
to_seq2 [Cf_heap.T]
Use to_seq2 h to produce a sequence of elements from the heap h where the first element of each pair is a key-value pair obtained from the head of the heap, and the second element of the pair is the corresponding tail of the heap.
to_seq2 [Cf_deque.Direction_T]
to_seq2 d returns a lazily evaluated sequence of the pairs (hd, tl) obtained by successively calling of pop d.
to_seq_decr [Cf_set.T]
Use to_seq_decr s to produce the sequence of elements in the set s in order of decreasing ordinality.
to_seq_decr [Cf_map.T]
Use to_seq_decr m to obtain a sequence of the key-value pairs in the tree m in order of descreasing ordinality.
to_seq_incr [Cf_set.T]
Use to_seq_incr s to produce the sequence of elements in the set s in order of increasing ordinality.
to_seq_incr [Cf_map.T]
Use to_seq_incr m to obtain a sequence of the key-value pairs in the tree m in order of increasing ordinality.
to_sockaddr [Cf_socket.AF]
Use to_sockaddr a to create an abstract socket address value corresponding to the address a.
to_string [Cf_seq]
to_string s evaluates the entire character sequence s and composes a string value containing the characters in order.
to_subarray [Cf_seq]
to_subarray s v pos len is like to_substring s str pos len, except that it overwrites an 'a array value instead of a string value.
to_substring [Cf_seq]
to_substring s str pos len overwrites the substring of str starting at pos and running for len characters, with the first len characters from the sequence s.
to_ucs4 [Cf_unicode.Encoding_T]
A flow that transcodes an encoded character stream into a stream of 31-bit UCS4 integer codes.
to_unix_file_descr [Cf_socket]
Use to_unix_file_descr sock to obtain the file descriptor to use with functions in the Unix library that corresponds to the socket descriptor sock.
to_unix_time [Cf_tai64n]
Converts a TAI64 value to a value consistent with the result of calling the Unix.gettimeofday function.
to_unix_time [Cf_tai64]
Converts a TAI64 value to a value consistent with the result of calling the Unix.gettimeofday function.
to_v4compat [Cf_ip6_addr]
Use to_v4compat a to convert the unicast IPv4 address a to its v4-compat IPv6 address.
to_v4mapped [Cf_ip6_addr]
Use to_v4mapped a to convert the unicast IPv4 address a to its v4-mapped IPv6 address.
tok [Cf_parser.X]
Use tok f to recognize and shift input tokens for which the tokenizer function f reduces an output value.
tok [Cf_parser]
Use tok f to recognize and shift input tokens for which the tokenizer function f reduces an output value.
transcode [Cf_unicode.Transcoding_T]
Use transcode i to convert a sequence of characters in the input encoding into a sequence of characters in the output encoding.
transcode [Cf_flow]
Use transcode w z to produce the sequence of output values obtained by executing the transcoder stream processor w to ingest every element of the sequence z.
transcoder [Cf_unicode.Transcoding_T]
A transcoder flow.
truncate [Cf_message]
Use truncate ~pos m to return a new message containing all the text in message m before the position pos.

U
ucs4_to_utf16 [Cf_unicode]
Use ucs4_to_utf16 endian to compose a flow that reads a stream of 31-bit UCS4 integer codes and writes a stream comprised of the barker code followed by a stream of UTF16 characters in the 'endian' mode specified.
udp [Cf_ip_common]
The Internet User Datagram Protocol.
unescape [Cf_uri]
Use unescape s to obtain a new string by replacing all the URI escape sequences in the string s with the actual character they denote.
unfold [Cf_parser.X]
Use unfold p i to create a sequence of output values recognized by applying the input token sequence i to the parser p until no more input is recognized.
unfold [Cf_parser]
Use unfold p i to create a sequence of output values recognized by applying the input token sequence i to the parser p until no more input is recognized.
unfold [Cf_seq]
unfold f a returns the sequence composed of the results of applying f according to the following rule: the first application of f is with a as the argument; if the result is None then the empty sequence is returned; else, the result is Some (hd, tl) and the sequence returned is composed of an element hd followed by the sequence produced by looping through applications of f tl until None is returned to signal the end of the sequence.
unfold2 [Cf_seq]
unfold2 f a is like unfold f a above, except that the sequence returned has elements which are pairs of output values and the input values that correspond to them.
unicast_format [Cf_ip6_addr]
Use unicast_format a to obtain the unicast format of the unicast IPv6 address a.
unicast_realm [Cf_ip4_addr]
Use unicast_realm a to identify the address realm of the unicast address a.
union [Cf_set.T]
Use union s1 s2 to obtain a new set from the union of the sets s1 and s2.
unquote [Cf_regex]
A character flow that unquotes all the quoted special characters in the input so that the output may by used in a regular expression to match the specified pattern.
unspecified [Cf_ip6_addr]
The unspecified IPv6 address, i.e.
unspecified [Cf_socket.AF]
The unspecified socket address, used for binding to arbitrary local endpoint addresses.
upcase [Cf_flow]
A stream processor that converts uppercase US-ASCII characters into lowercase characters.
utc_of_tai64 [Cf_stdtime]
Convert from TAI64 to UTC time.
utc_to_tai64 [Cf_stdtime]
Convert from UTC time to TAI64.
utc_to_tai64_unsafe [Cf_stdtime]
This is the same as utc_to_tai64, except it assumes the input is a valid UTC time value.

W
weave [Cf_parser.X]
Use weave ~c i with an initial cursor c and an input sequence i to create an input sequence with accompanying cursor.
wire [Cf_state_gadget]
Use wire to return a new wire for carrying messages of type 'x.
wire [Cf_gadget]
Use wire to return a new wire for carrying messages of type 'x.
wirepair [Cf_state_gadget]
Use wirepair to return a pair of new wires for carrying messages of type 'x and 'y.
wirepair [Cf_gadget]
Use wirepair to return a pair of new wires for carrying messages of type 'x and 'y.
wrap [Cf_state_gadget]
Use wrap rx tx w to start a new process that wraps the flow w, so that it reads output from the flow (copying it to tx object) and writes input to the flow (copying it from the rx object).
wrap [Cf_gadget]
Use wrap rx tx w to start a new gadget that wraps the flow w, so that it reads output from the flow (copying it to tx object) and writes input to the flow (copying it from the rx object).
write [Cf_state_gadget]
Bind the result of write obj to put the next output value into the external stream.
write [Cf_gadget]
Bind the result of write obj to put the next output value into the external stream.
writeC [Cf_flow]
Use writeC x to compose a continuation monad that puts x into the flow produced by evaluation and returns the unit value.
writeC [Cf_seq]
Use write x to compose a continuation monad that puts x into the sequence produced by evaluation and returns the unit value.
writeSC [Cf_flow]
Use writeSC x to compose a state-continuation monad that puts x into the flow produced by evaluation and returns the unit value.
writeSC [Cf_seq]
Use writeSC x to compose a state-continuation monad that puts x into the sequence produced by evaluation and returns the unit value.

Z
zero [Cf_ip_common]
The unspecified Internet protocol identifier.