Index of values

Star composition.

Use !*a to compose an expression that matches zero or more occurances of a in the symbol stream.

The zero-or-more operator.

Regular expression string.

Plus composition.

Use !+a to compose an expression that matches one or more occurances of a in the symbol stream.

Character literal.

Use !:sym to compose an expression that matches the symbol sym in the symbol stream.

Optional composition.

Use !?a to compose an expression that matches zero or one occurance of a in the symbol stream.

Rule aggregation.

Rule aggregation.

Use this operator to combine a list of "cursor woven" rules into a single rule.

Use this operator to combine a list of rules into a single rule.

Character set.

Use !^f to compose an expression that matches any symbol in the symbol stream for which applying the function f returns true.

Regular expression sequence.

Use !~z to compose an expression that matches the sequence of symbols z in the symbol stream.

Serial composition.

Use a $& b to compose an expression that matches a followed by b in the symbol stream.

Literal token rule.

Literal token rule.

Use e $= x to compose a rule that produces x when the symbols in the symbol stream match the expression e.

Use e $= x to compose a rule that produces x when the symbols in the symbol stream match the expression e.

String token rule.

String token rule.

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.

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.

Advanced token rule.

Advanced token rule.

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.

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.

Alternating composition.

Use a $| b to compose an expression that matches either a or b in the symbol stream.

The serial composition operator.

Sequential composition.

Broadcasting parallel composition.

Tagged parallel composition.

Serial composition.

Serial loop through right.

The binding operator.

Use m >>= f to produce a monad that applies f to the result of evaluating m.

Use m >>= f to produce a monad that applies f to the result of evaluating m.

Use m >>= f to produce a monad that applies f to the result of evaluating m.

The return operator.

Serial loop composition.

Serial loop left.

The unit operator.

String parser.

String parser.

The one-or-more operator.

The option operator.

The unit operator with a cursor.

String parser.

String parser.

Use abort to abort processing and return to the scheduler.

Use abort to abort gadgeting and return to the scheduler.

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.

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.

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 seconds to a TAI64N value.

Add seconds to a TAI64 value.

Add seconds to a TAI64 value.

Add seconds to a TAI64 value.

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.

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.

A flow that transcodes any Unicode encoded character stream into a stream of 31-bit UCS4 integer codes.

Use atomic str to convert a string in the input encoding into a string in the output encoding.

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.

catenate d1 d2 returns a new deque composed by joining the right end of d1 to the left end of d2.

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 a b is the same as fcmp Pervasives.compare a b.

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.

Use commute w z to produce an output sequence from a flow w that ingests its input from the sequence z.

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.

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.

A total ordering function, defined so that the Cf_tai64n module has the signature of the Cf_ordered.Total_T module type.

A total ordering function, defined so that the Cf_tai64 module has the signature of the Cf_ordered.Total_T module type.

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.

Use compose s ns to compose a TAI64N value from a TAI64 value s and an offset of ns nanoseconds.

concat a b returns the sequence of all the elements in a followed by all the elements in b.

Use connect m to construct a new matching pair of rx and tx objects from the wire returned by m.

Use connectpair m to construct a new duplex communication channel, composed with the wire pair returned by m.

constrain f s evaluates the sequence s by applying f to each element while the result is true.

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.

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.

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.

Use contents m to create a new string containing the entire text of the message m.

Use copy m to create a new message with a deep copy of the contents of m, i.e.

The initial value of a cursor position counter.

Use create r to compose a lexical analyzer from the rule r.

Use create r to compose a lexical analyzer from the rule r.

Use create r to construct a parser that recognizes the longest sequence that matches the rule r.

Use create r to construct a parser that recognizes the longest sequence that matches the rule r.

Use create s to obtain a new message composed of a flattened message containing the string s.

Use create f to create a duplex channel, and apply f to the resulting pad to obtain the initial state of a machine.

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.

This is the primitive function in the module.

Use decompose x to separate the TAI64N value x into a TAI64 value and an offset in nanoseconds.

Use delete k m to obtain a new tree produced by deleting the key k from the tree m.

Use diff s1 s2 to obtain a new set from the difference of the sets s1 and s2.

A stream processor that converts lowercase US-ASCII characters into uppercase characters.

Use down m s to produce a stateless continuation monad from a state-continuation monad and an initial state.

Use drain q to convert the entire substring deque q into a message.

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.

Use drain_seq q to convert the substring deque q into a character sequence.

Use duplex to construct a new duplex communication channel, composed of two wires each in opposite flow.

Use duplex to construct a new duplex communication channel, composed of two wires each in opposite flow.

Use empty s to test whether the set s is the empty set.

Use empty m to test whether the tree m is empty.

Use empty q to test whether the priority queue q is empty.

Use empty h to test whether the heap h is empty.

Returns true if the deque is the empty deque.

equal a b returns true, if every element in both sequences a and b are logically equivalent, as with the built-in (=) comparison operator.

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.

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.

Use eval y s to obtain a new flow by evaluating the gadget monad y with a state initializer of a.

Use eval y to obtain a new flow by evaluating the gadget monad y.

Use eval m to evaluate the continuation monad to produce a function from initial continuation context to final continuation context.

Use evalC m to evaluate the continuation monad m, computing the encapsulated flow.

Use evalC m to evaluate the continuation monad m to compute the sequence it encapsulates.

Use evalSC m s to evaluate the state-continuation monad m with the initial state s, computing the encapsulated flow.

Use evalSC m s to evaluate the state-continuation monad m with the initial state s, computing the encapsulated sequence.

Use expr_of_seq z to evaluate the character sequence z as a regular expression and produce the corresponding DFA expression.

Use expr_of_string s to evaluate the string s as a regular expression and produce the corresponding DFA expression.

A parser combinator on character streams that recognizes a regular expression and produces a DFA expression for it.

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.

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.

Use field f to produce a monad that returns the result of applying f to the value of the encapsulated state.

Use field f to produce a monad that returns the result of applying f to the value of the encapsulated state.

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.

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

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.

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.

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.

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

A parser that produces the unit value when it recognizes the end of the input token sequence.

first s returns the sequence of elements composed by taking only the first object in an element pair.

The earliest TAI epoch representable in the TAI64N format.

The earliest TAI epoch representable in the TAI64 format.

Use flatten m to reduce a message list of two or more substrings to a single substring.

flatten a returns the sequence of all the elements in the sequence of sequences by concatenating them.

Use flush w to discard all the output from the flow w until the first input is required.

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

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

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

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 f a0 d is f (... (f (f a0 e0) e1) ...) en when e0..en are the elements of the deque d.

fold f a s is like List.fold_left and is the result of applying f to the elements in sequence, i.e.

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.

The engine uses get m s to get the state transition from map m for the symbol s.

Use guard m to receive the next message guarded by m.

Use guard m to receive the next message guarded by m.

Use head q to obtain the element on the top of the priority queue q.

Use head h to obtain the element on the top of the heap h.

head d returns the element at the end of the deque d.

Returns the first element in the sequence.

A stream processor that copies to its output every element of its input sequences.

Use init x to produce a monad that discards the current intermediate result and returns x as the continuation context.

Use init x to produce a monad that discards the current intermediate result and returns x as the continuation context.

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.

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.

Use interset s1 s2 to obtain a new set from the intersection of the sets s1 and s2.

is_valid ~year ~month ~day returns true if year, month and day arguments specify a valid Gregorian date.

Use iterate f s to apply the iterator function f to every element in the set s in arbitrary order (not increasing or decreasing).

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

Use iterate f q to apply f to every element in the priority queue q in an arbitrary order (not top to bottom).

Use iterate f h to apply f to every element in the heap h in an arbitrary order (not top to bottom).

iterate f d applies f to every element in d in left-to-right order.

iterate f s evaluates the entire sequence s, applying f to each element in order until the end of the sequence is reached.

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.

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.

The latest TAI epoch representable in the TAI64N format.

The latest TAI epoch representable in the TAI64 format.

Use length m to compute the length of the message m.

length d computes the number elements contained in the deque d.

Evaluates the entire sequence and returns the number elements.

Use lift m to lift a stateless continuation monad into a state-continuation monad.

limit n s returns the sequence of all the elements in s, up to n elements in number and no more.

Use listmap f to construct a stream processor that applies f to every input value and outputs every element of the resulting list.

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

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.

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.

Bind load to get the current state encapsulated in the process.

A monad that returns the encapsulate state as an intermediate result.

A monad that returns the encapsulate state.

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.

The engine uses map f to construct a map from symbols to state transitions.

Use map f p to produce a parser that transforms each output symbol of p by applying f to its value.

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.

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.

Use map f to construct a stream processor that applies f to every input value and outputs the result.

map f d returns a new deque composed by applying f to every element in d in left-to-right order.

map f s returns the sequence produced by transforming every element in s by applying it to f.

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.

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.

Use min s to return the ordinally greatest element in the set s.

Use max m to obtain the key-value pair with the ordinally maximum key in the tree m.

Use member e s to test whether the element e is a member of the set s.

Use member k m to test whether the tree m contains the key k.

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.

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.

Use min s to return the ordinally least element in the set s.

Use min m to obtain the key-value pair with the ordinally minimum key in the tree m.

Bind the result of modify f to apply f to the current encapsulated state of the process and store the resulting new state.

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.

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.

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.

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.

Use nearest_decr k s to obtain the key-value pair ordinally less than or equal to the key k in the set s.

Use nearest_decr k m to obtain the key-value pair ordinally less than or equal to the key k in the map m.

Use nearest_incr k s to obtain the element ordinally greater than or equal to the key k in the set s.

Use nearest_incr k m to obtain the key-value pair ordinally greater than or equal to the key k in the map m.

Epsilon, i.e.

The expression that matches the empty symbol sequence.

A parser that never recognizes any input, i.e.

The empty set.

The empty tree.

The empty priority queue.

The empty heap.

A stream processor that reads no input and writes no output.

The empty deque.

An empty sequence.

A monad that returns unit and performs no operation.

A monad that returns unit and performs no operation.

A monad that returns unit and performs no operation.

A stream processor that outputs every input value without change.

Use normalize m to discard empty substrings from the list.

Returns the current time in TAI64N, obtained by reading the current time from the POSIX gettimeofday() function, and adjusting for leap seconds.

Returns the current time in TAI64, obtained by reading the current time from the POSIX time() function, and adjusting for leap seconds.

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.

Use null to construct a wire that discards every message transmitted without ever delivering it.

of_array v is like of_string s, except that it operates on an 'a array value instead of a string value.

of_channel c returns the sequence of characters produced by reading them on demand from the channel c.

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.

Use of_expression x to produce a regular expression from the DFA expression x.

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 f returns a sequence produced by applying f () repeatedly until Not_found is raised.

Interprets the argument as a TAI64N label and returns the corresponding TAI64N value.

Interprets the argument as a TAI64 label and returns the corresponding TAI64 value.

Use of_list s to iterate a list of elements and compose a new set by inserting them in order.

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.

Use of_list s to construct a priority queue from a list of elements.

Use of_list s to construct a heap from a list of elements.

Use of_list s to construct a deque from a list of elements.

of_list s converts a 'a list value into a sequence.

Use of_list_decr s to compose the set with elements in the ordered list s.

Use of_list_decr s to compose a tree with the key-value pairs in the ordered list s.

Use of_list_incr s to compose the set with elements in the ordered list s.

Use of_list_incr s to compose a tree with the key-value pairs in the ordered list s.

Use of_seq z to ingest the whole character sequence z, parse it and produce a regular expression.

Use of_seq z to evaluate a sequence of elements and compose a new set by inserting them in order.

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.

Use of_seq z to construct a priority queue from a sequence of elements.

Use of_seq z to construct a heap from a sequence of elements.

Use of_seq z to convert a sequence into the equivalent stream processor (which never ingests any input).

Use of_seq z to construct a deque from a sequence of elements.

Use of_seq_decr z to compose the set with elements in the ordered sequence z.

Use of_seq_decr z to compose a tree with the key-value pairs in the ordered sequence z.

Use of_seq_incr z to compose the set with elements in the ordered sequence z.

Use of_seq_incr z to compose a tree with the key-value pairs in the ordered sequence z.

Use of_string s to produce a regular expression from the string s.

of_string s returns the sequence of characters produced by extracting them on demand from the string s with String.unsafe_get.

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 s pos returns the sequence of characters produced by extracting them on demand from the string s with String.unsafe_get.

A flow that reads a stream of 31-bit UCS4 integer codes and writes them as a stream of encoded characters.

Converts a value consistent with the result of calling the Unix.gettimeofday function into a TAI64N value.

Converts a value consistent with the result of calling the Unix.time function into a TAI64 value.

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.

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.

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.

Use optmap f to construct a stream processor that applies f to every input value and outputs the result if there is one.

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 f s returns the sequence produced by applying f to every element of s and taking all the Some a results in order.

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.

Use parse r to produce a parser that matches the input stream to the regular expression r and returns the corresponding string value.

Use parse r to produce a parser that matches the input stream to the regular expression r and returns the corresponding string value.

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

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

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

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 f s returns two deques.

partition f s returns two sequences.

Use pop ~len q to pop a message of length no larger than len from the B end of the substring deque q.

Use pop q to obtain the head and the tail of a priority queue q in one operation.

Use pop h to obtain the head and the tail of a heap h in one operation.

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.

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.

Use predicate f m to test whether all the key-value pairs in the tree m satisfy the predicate function f.

Use predicate f q to test whether all the elements in priority queue q satisfy the predicate function f.

Use predicate f h to test whether all the elements in heap h satisfy the predicate function f.

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 f s evaluates as much of the sequence s as necessary to determine that every element satisfy the predicate function f.

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.

Use push m q to push the message m into the A end of the substring queue q.

push x d adds the element x to the end of the deque d.

Use put e s to obtain a new set produced by inserting the element e into the set s.

Use put e q to obtain a new priority queue that is the result of inserting the element e into the queue q.

Use put e h to obtain a new heap that is the result of inserting the element e into the heap h.

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.

Bind read to get the next input value from the external stream.

Bind read to get the next input value from the external stream.

The continuation monad that returns a value obtained from the flow produced by its evaluation.

The state-continuation monad that returns a value obtained from the flow produced by its evaluation.

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.

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.

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.

Use return a to produce a monad that returns a as an intermediate result from the current continuation.

Use return a to produce a monad that returns a as an intermediate result from the current continuation.

Use return a to produce a monad that returns a when evaluated.

reverse s evaluates the entire sequence and composes a list of the elements in reverse order.

Use sat f to create a parser that recognizes, shifts and reduces input tokens for which the satisfier function f returns true.

Use sat f to create a parser that recognizes, shifts and reduces input tokens for which the satisfier function f returns true.

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.

Use scanfx in place of scanf to construct a parser with a cursor weaved into the input stream.

Use search r z to search the character sequence z for a pattern that matches the regular expression r.

Use search k m to obtain the value associated with the key k in the tree m.

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 s returns the sequence of elements composed by taking only the second object in an element pair.

sentinel x s returns a sequence identical to s except that x is raised by evaluating to the end.

Use separate r z to map the character sequence z into the sequence of sequences found between matches for the regular expression r.

Use listmap f to construct a stream processor that applies f to every input value and outputs every element of the resulting sequence.

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

Use sequence z to compose a monad that binds all of the monads in the sequence z in the order specified.

Use sequence z to compose a monad that binds all of the monads in the sequence z in the order specified.

Use sequence z to compose a monad that binds all of the monads in the sequence z in the order specified.

Use shift ~pos m to return a new message with all the text in message m before the position pos removed.

shift n s returns the sequence of all the elements in s after the first n elements are discarded.

Use shiftq ~len q to discard the first len octets from the B end of the substring deque q.

Use simplex to construct a new maching pair of rx and tx objects.

Use simplex to construct a new matching pair of rx and tx objects.

Use singleton e to compose a new set containing only the element e.

Use size s to compute the size of the set s.

Use size m to count the number of elements in the tree m.

Use size q to count the number of elements in the priority queue q.

Use size h to count the number of elements in the heap h.

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.

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 s is equivalent to (first s, second s).

Bind the result of start y s to start a new process evaluating the gadget y with a state initializer s.

Use start y to start a new gadget evaluating the gadget y.

A basic agent, initially set with a limit of `Notice, and with with one basic archiver for the Pervasives.stderr channel.

A basic agent, initially set with a limit of `Notice, and with with one basic archiver for the Pervasives.stdout channel.

Bind the result of store obj to store the state obj as the encapsulated state for the current monad.

Use store s to produce a monad with s as the value of its encapsulated state.

Use store s to produce a monad with s as the value of its encapsulated state.

Subtract one TAI64N value from another.

Subtract one TAI64 value from another.

Use subset s1 s2 to test whether the set s1 is a subset of s2.

Use tail q to obtain the heap produced by discarding the element on the top of the priority queue q.

Use tail h to obtain the heap produced by discarding the element on the top of heap h.

tail d is discards the element at the end of the deque d.

Discards the first element in the sequence and returns the sequence of remaining elements.

Use test r s to test whether the string s matches the regular expression r.

to_array v is like to_string s, except that it constructs an 'a array value instead of a string value.

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 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 ~year ~month ~day returns the Chronological Julian Day number of the specified Gregorian date.

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.

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 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 s returns a function that evaluates the next value in the sequence each time it's called.

Returns a string of 8 characters containing the TAI64N label corresponding to the TAI64N value of its argument.

Returns a string of 8 characters containing the TAI64 label corresponding to the TAI64 value of its argument.

to_list d returns the elements in the deque in the order they would appear by successive calls of pop d.

to_list s is the same as List.rev (reverse s).

Use to_list_decr s to produce the list of elements in the set s in order of decreasing ordinality.

Use to_list_decr m to obtain a sequence of the key-value pairs in the tree m in order of descreasing ordinality.

Use to_list_incr s to produce the list of elements in the set s in order of increasing ordinality.

Use to_list_incr m to obtain a sequence of the key-value pairs in the tree m in order of increasing ordinality.

Use to_seq m to obtain the sequence of characters in message m.

Use to_seq q to produce a sequence of elements in top to bottom order from the priority queue q.

Use to_seq h to produce a sequence of elements in top to bottom order from the heap h.

Use to_seq w to convert a stream processor w into the equivalent sequence.

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.

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.

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 d returns a lazily evaluated sequence of the pairs (hd, tl) obtained by successively calling of pop d.

Use to_seq_decr s to produce the sequence of elements in the set s in order of decreasing ordinality.

Use to_seq_decr m to obtain a sequence of the key-value pairs in the tree m in order of descreasing ordinality.

Use to_seq_incr s to produce the sequence of elements in the set s in order of increasing ordinality.

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 s evaluates the entire character sequence s and composes a string value containing the characters in order.

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

A flow that transcodes an encoded character stream into a stream of 31-bit UCS4 integer codes.

Converts a TAI64 value to a value consistent with the result of calling the Unix.gettimeofday function.

Converts a TAI64 value to a value consistent with the result of calling the Unix.gettimeofday function.

Use tok f to recognize and shift input tokens for which the tokenizer function f reduces an output value.

Use tok f to recognize and shift input tokens for which the tokenizer function f reduces an output value.

Use transcode i to convert a sequence of characters in the input encoding into a sequence of characters in the output encoding.

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.

A transcoder flow.

Use truncate ~pos m to return a new message containing all the text in message m before the position pos.

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.

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.

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

Use union s1 s2 to obtain a new set from the union of the sets s1 and s2.

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.

A stream processor that converts uppercase US-ASCII characters into lowercase characters.

Convert from TAI64 to UTC time.

Convert from UTC time to TAI64.

This is the same as utc_to_tai64, except it assumes the input is a valid UTC time value.

Use weave ~c i with an initial cursor c and an input sequence i to create an input sequence with accompanying cursor.

Use wire to return a new wire for carrying messages of type 'x.

Use wire to return a new wire for carrying messages of type 'x.

Use wirepair to return a pair of new wires for carrying messages of type 'x and 'y.

Use wirepair to return a pair of new wires for carrying messages of type 'x and 'y.

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

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

Bind the result of write obj to put the next output value into the external stream.

Bind the result of write obj to put the next output value into the external stream.

Use writeC x to compose a continuation monad that puts x into the flow produced by evaluation and returns the unit value.

Use write x to compose a continuation monad that puts x into the sequence produced by evaluation and returns the unit value.

Use writeSC x to compose a state-continuation monad that puts x into the flow produced by evaluation and returns the unit value.

Use writeSC x to compose a state-continuation monad that puts x into the sequence produced by evaluation and returns the unit value.