(!$) [Cf_lexer.Op] |
Use
!$lit to compose an expression that matches the string literal
lit .
|
(!*) [Cf_lexer.Op] |
Star composition.
|
(!*) [Cf_dfa.T.Op] |
Use
!*a to compose an expression that matches zero or more
occurances of a in the symbol stream.
|
(!+) [Cf_lexer.Op] |
Plus composition.
|
(!+) [Cf_dfa.T.Op] |
Use
!+a to compose an expression that matches one or more
occurances of a in the symbol stream.
|
(!:) [Cf_lexer.Op] |
Use
!:c to compose an expression that matches the character c .
|
(!:) [Cf_dfa.T.Op] |
Use
!:sym to compose an expression that matches the symbol sym
in the symbol stream.
|
(!?) [Cf_lexer.Op] |
Optional composition.
|
(!?) [Cf_dfa.T.Op] |
Use
!?a to compose an expression that matches zero or one
occurance of a in the symbol stream.
|
(!@) [Cf_lexer.Op] |
Rule aggregation.
|
(!@) [Cf_dfa.T.Op] |
Use this operator to combine a list of rules into a single rule.
|
(!^) [Cf_lexer.Op] |
Use
!^f to compose an expression that matches any character for which
the satisfier function f returns true .
|
(!^) [Cf_dfa.T.Op] |
Use
!^f to compose an expression that matches any symbol in the
symbol stream for which applying the function f returns true .
|
(!~) [Cf_lexer.Op] |
Use
!~z to compose an expression that matches the sequence of
characters z .
|
(!~) [Cf_dfa.T.Op] |
Use
!~z to compose an expression that matches the sequence of
symbols z in the symbol stream.
|
($&) [Cf_lexer.Op] |
Serial composition.
|
($&) [Cf_dfa.T.Op] |
Use
a $& b to compose an expression that matches a followed by
b in the symbol stream.
|
($=) [Cf_lexer.Op] |
Literal token rule.
|
($=) [Cf_dfa.T.Op] |
Use
e $= x to compose a rule that produces x when the symbols
in the symbol stream match the expression e .
|
($>) [Cf_lexer.Op] |
Character sequence token rule.
|
($>) [Cf_dfa.T.Op] |
Use
e $> f to compose a rule that applies the tokenizer function
f to the sequence of symbols in the symbol stream recognized by
the expression e to produce an output token.
|
($@) [Cf_lexer.Op] |
Advanced token rule.
|
($@) [Cf_dfa.T.Op] |
Use
e $@ f to compose a rule that applies the scanning function
f to the input symbol stream when it is recognized by the
expression e .
|
($^) [Cf_lexer.Op] |
String token rule.
|
($|) [Cf_lexer.Op] |
Alternating composition.
|
($|) [Cf_dfa.T.Op] |
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_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.
|
A | |
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.
|
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.
|
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 .
|
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_lexer] |
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_lexer] |
Use
create ?xf r to compose a lexical analyzer from the rule r .
|
create [Cf_dfa.T] |
Use
create r to compose a new DFA from the rule r .
|
create [Cf_message] |
Use
create s to obtain a new message composed of a flattened message
containing the string s .
|
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_unit_sockaddr [Cf_socket] |
Use
domain_of_unit_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_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.
|
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_gadget] |
Use
duplex to construct a new duplex communication channel, composed of
two wires each in opposite flowl.
|
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] |
Use
err f to compose parser that applies the input token stream to the
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_gadget] |
Use
eval y s to obtain a new flow by evaluating the gadget monad y with
a state initializer of a .
|
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.
|
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.
|
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] | fold f a0 d is f (... (f (f a0 e0) e1) ...) en when e0..en are the
elements of the deque d in left-to-right order.
|
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 .
|
fsimplex [Cf_gadget] |
Use
fsimplex ~f to construct a new wire and apply it to the constructor
function f to pass along a new matching pair of rx and tx objects.
|
G | |
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_gadget] |
Use
guard m to receive the next message guard 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_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_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_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_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_lexer] |
The lexer expression that recognizes the empty input sequence, 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_deque] |
The empty deque.
|
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_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_int [Cf_dfa.Symbol_T] |
A function to map an integer number to its symbol.
|
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_seq] | of_list s converts a 'a list value into a sequence.
|
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_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_sockaddr [Cf_socket.AF] |
Use
of_sockaddr sa to create an address corresponding to the abstract
socket address value sa .
|
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 | |
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_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_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 .
|
R | |
raise_exn [Cf_lexer] |
An optional exception handler function for use in streams woven with
cursors of the
#line_cursor class type.
|
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.
|
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.
|
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 .
|
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.
|
shutdown [Cf_socket] |
Use
shutdown sock cmd to shutdown either sending or receiving (or both)
on the socket sock .
|
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_dfa.Symbol_T] |
The size of an array containing an element for every symbol.
|
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_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_gadget] |
Bind the result of
start y s to start a new process evaluating the gadget
y with a state initializer s .
|
stderr [Cf_journal] |
A basic agent, initially set with a limit of
`Warn , and with with one
basic archiver for the Pervasives.stderr channel.
|
stdout [Cf_journal] |
A basic agent, initially set with a limit of
`Warn , and with with one
basic archiver for the Pervasives.stdout channel.
|
store [Cf_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.
|
to_address [Cf_nameinfo] |
Use
to_address ?hint arg to obtain a list of address information records
associated with the host name and/or service name provided in the argument
arg and using the optional hints provided in the ?hint argument.
|
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_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_int [Cf_dfa.Symbol_T] |
A function to map a symbol to its integer number.
|
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_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_message] |
Use
to_seq2 m to obtain the sequence of characters in message m with
each character associated with the remainder of the message.
|
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 .
|
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_gadget] |
Bind
wire to create a new wire object for sending messages of type 'x .
|
wrap [Cf_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).
|
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.
|