# Index of values

( !* ) [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_parser.Op] | The zero-or-more operator.
(!$) [Cf_lex.Expr_Op_T] | Regular expression string.
(!+) [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 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.
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.
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_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
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
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`.
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_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_gadget] | Use `connect m` to construct a new matching pair of `rx` and `tx` objects from the wire returned by `m`.
connectpair [Cf_gadget] | Use `connectpair m` to construct a new duplex communication channel, composed with the wire pair returned by `m`.
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_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 `pad` 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 `pad` to obtain a continuation monad that evaluates to the initial state of a machine.
cscanf [Cf_scan_parser] | This is the primitive function in the module.
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.
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.
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
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.
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.
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.
G
get [Cf_dfa.Symbol_T] | The engine uses `get m s` to get the state transition from map `m` for the symbol `s`.
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
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`.
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.
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.
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.
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`.
N
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`.
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.
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.
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 wire that discards every message transmitted without ever delivering it.
O
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_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_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.
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.
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.
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.
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`.
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 matching pair of `rx` and `tx` objects.
singleton [Cf_set.T] | Use `singleton e` to compose a new set containing only the element `e`.
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`.
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.
test [Cf_regex] | Use `test r s` to test whether the string `s` matches the regular expression `r`.
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_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_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_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.
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.
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.
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.
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.