Index: doc/user/user.tex
===================================================================
--- doc/user/user.tex	(revision 0ed8759db78011e036f332fe29485e98558ed316)
+++ doc/user/user.tex	(revision 1eeab949a46e8a10e2226acdd060a7c25dcf8f9c)
@@ -11,6 +11,6 @@
 %% Created On       : Wed Apr  6 14:53:29 2016
 %% Last Modified By : Peter A. Buhr
-%% Last Modified On : Sun May 21 23:36:42 2017
-%% Update Count     : 1822
+%% Last Modified On : Wed May 24 22:21:42 2017
+%% Update Count     : 1994
 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 
@@ -151,5 +151,5 @@
 
 Like \Index*[C++]{\CC}, there may be both an old and new ways to achieve the same effect.
-For example, the following programs compare the \CFA and C I/O mechanisms.
+For example, the following programs compare the \CFA, C, nad \CC I/O mechanisms, where the programs output the same result.
 \begin{quote2}
 \begin{tabular}{@{}l@{\hspace{1.5em}}l@{\hspace{1.5em}}l@{}}
@@ -183,5 +183,4 @@
 \end{tabular}
 \end{quote2}
-The programs output the same result.
 While the \CFA I/O looks similar to the \Index*[C++]{\CC} output style, there are important differences, such as automatic spacing between variables as in \Index*{Python} (see~\VRef{s:IOLibrary}).
 
@@ -1426,5 +1425,28 @@
 
 
-\section{Type/Routine Nesting}
+\section{Unnamed Structure Fields}
+
+C requires each field of a structure to have a name, except for a bit field associated with a basic type, \eg:
+\begin{cfa}
+struct {
+	int f1;					§\C{// named field}§
+	int f2 : 4;				§\C{// named field with bit field size}§
+	int : 3;				§\C{// unnamed field for basic type with bit field size}§
+	int ;					§\C{// disallowed, unnamed field}§
+	int *;					§\C{// disallowed, unnamed field}§
+	int (*)(int);			§\C{// disallowed, unnamed field}§
+};
+\end{cfa}
+This requirement is relaxed by making the field name optional for all field declarations; therefore, all the field declarations in the example are allowed.
+As for unnamed bit fields, an unnamed field is used for padding a structure to a particular size.
+A list of unnamed fields is also supported, \eg:
+\begin{cfa}
+struct {
+	int , , ;				§\C{// 3 unnamed fields}§
+}
+\end{cfa}
+
+
+\section{Nesting}
 
 Nesting of types and routines is useful for controlling name visibility (\newterm{name hiding}).
@@ -1796,27 +1818,4 @@
 
 
-\section{Unnamed Structure Fields}
-
-C requires each field of a structure to have a name, except for a bit field associated with a basic type, \eg:
-\begin{cfa}
-struct {
-	int f1;					§\C{// named field}§
-	int f2 : 4;				§\C{// named field with bit field size}§
-	int : 3;				§\C{// unnamed field for basic type with bit field size}§
-	int ;					§\C{// disallowed, unnamed field}§
-	int *;					§\C{// disallowed, unnamed field}§
-	int (*)(int);			§\C{// disallowed, unnamed field}§
-};
-\end{cfa}
-This requirement is relaxed by making the field name optional for all field declarations; therefore, all the field declarations in the example are allowed.
-As for unnamed bit fields, an unnamed field is used for padding a structure to a particular size.
-A list of unnamed fields is also supported, \eg:
-\begin{cfa}
-struct {
-	int , , ;				§\C{// 3 unnamed fields}§
-}
-\end{cfa}
-
-
 \section{Field Tuples}
 
@@ -1861,58 +1860,33 @@
 
 While C provides ©continue© and ©break© statements for altering control flow, both are restricted to one level of nesting for a particular control structure.
-Unfortunately, this restriction forces programmers to use ©goto© to achieve the equivalent control-flow for more than one level of nesting.
-To prevent having to switch to the ©goto©, \CFA extends the ©continue©\index{continue@©continue©}\index{continue@©continue©!labelled}\index{labelled!continue@©continue©} and ©break©\index{break@©break©}\index{break@©break©!labelled}\index{labelled!break@©break©} with a target label to support static multi-level exit\index{multi-level exit}\index{static multi-level exit}~\cite{Buhr85,Java}.
+Unfortunately, this restriction forces programmers to use \Indexc{goto} to achieve the equivalent control-flow for more than one level of nesting.
+To prevent having to switch to the ©goto©, \CFA extends the \Indexc{continue}\index{continue@©continue©!labelled}\index{labelled!continue@©continue©} and \Indexc{break}\index{break@©break©!labelled}\index{labelled!break@©break©} with a target label to support static multi-level exit\index{multi-level exit}\index{static multi-level exit}~\cite{Buhr85,Java}.
 For both ©continue© and ©break©, the target label must be directly associated with a ©for©, ©while© or ©do© statement;
 for ©break©, the target label can also be associated with a ©switch©, ©if© or compound (©{}©) statement.
-
-The following example shows the labelled ©continue© specifying which control structure is the target for the next loop iteration:
-\begin{quote2}
-\begin{tabular}{@{}l@{\hspace{3em}}l@{}}
-\multicolumn{1}{c@{\hspace{3em}}}{\textbf{\CFA}}	& \multicolumn{1}{c}{\textbf{C}}	\\
-\begin{cfa}
-®L1:® do {
-	®L2:® while ( ... ) {
-		®L3:® for ( ... ) {
-			... continue ®L1®; ...	// continue do
-			... continue ®L2®; ...	// continue while
-			... continue ®L3®; ...	// continue for
-		} // for
-	} // while
-} while ( ... );
-\end{cfa}
-&
-\begin{cfa}
-do {
-	while ( ... ) {
-		for ( ... ) {
-			... goto L1; ...
-			... goto L2; ...
-			... goto L3; ...
-		L3: ; }
-	L2: ; }
-L1: ; } while ( ... );
-\end{cfa}
-\end{tabular}
-\end{quote2}
-The innermost loop has three restart points, which cause the next loop iteration to begin.
-
-The following example shows the labelled ©break© specifying which control structure is the target for exit:
-\begin{quote2}
-\begin{tabular}{@{}l@{\hspace{3em}}l@{}}
-\multicolumn{1}{c@{\hspace{3em}}}{\textbf{\CFA}}	& \multicolumn{1}{c}{\textbf{C}}	\\
-\begin{cfa}
-®L1:® {
+\VRef[Figure]{f:MultiLevelResumeTermination} shows the labelled ©continue© and ©break©, specifying which control structure is the target for exit, and the corresponding C program using only ©goto©.
+The innermost loop has 7 exit points, which cause resumption or termination of one or more of the 7 \Index{nested control-structure}s.
+
+\begin{figure}
+\begin{tabular}{@{\hspace{\parindentlnth}}l@{\hspace{1.5em}}l@{}}
+\multicolumn{1}{c@{\hspace{1.5em}}}{\textbf{\CFA}}	& \multicolumn{1}{c}{\textbf{C}}	\\
+\begin{cfa}
+®LC:® {
 	... §declarations§ ...
-	®L2:® switch ( ... ) {
+	®LS:® switch ( ... ) {
 	  case 3:
-	    ®L3:® if ( ... ) {
-			®L4:® for ( ... ) {
-				... break ®L1®; ...	// exit compound statement
-				... break ®L2®; ...	// exit switch
-				... break ®L3®; ...	// exit if
-				... break ®L4®; ...	// exit loop
+		®LIF:® if ( ... ) {
+			®LF:® for ( ... ) {
+				®LW:® while ( ... ) {
+					... break ®LC®; ...			// terminate compound
+					... break ®LS®; ...			// terminate switch
+					... break ®LIF®; ...			// terminate if
+					... continue ®LF;® ...	 // resume loop
+					... break ®LF®; ...			// terminate loop
+					... continue ®LW®; ...	 // resume loop
+					... break ®LW®; ...		  // terminate loop
+				} // while
 			} // for
 		} else {
-			... break ®L3®; ...		// exit if
+			... break ®LIF®; ...					 // terminate if
 		} // if
 	} // switch
@@ -1925,31 +1899,37 @@
 	switch ( ... ) {
 	  case 3:
-	    if ( ... ) {
+		if ( ... ) {
 			for ( ... ) {
-				... goto L1; ...
-				... goto L2; ...
-				... goto L3; ...
-				... goto L4; ...
-			} L4: ;
+				for ( ... ) {
+					... goto ®LC®; ...
+					... goto ®LS®; ...
+					... goto ®LIF®; ...
+					... goto ®LFC®; ...
+					... goto ®LFB®; ...
+					... goto ®LWC®; ...
+					... goto ®LWB®; ...
+				  ®LWC®: ; } ®LWB:® ;
+			  ®LFC:® ; } ®LFB:® ;
 		} else {
-			... goto L3; ...
-		} L3: ;
-	} L2: ;
-} L1: ;
+			... goto ®LIF®; ...
+		} ®L3:® ;
+	} ®LS:® ;
+} ®LC:® ;
 \end{cfa}
 \end{tabular}
-\end{quote2}
-The innermost loop has four exit points, which cause termination of one or more of the four \Index{nested control structure}s.
-
-Both ©continue© and ©break© with target labels are simply a ©goto©\index{goto@©goto©!restricted} restricted in the following ways:
+\caption{Multi-level Resume/Termination}
+\label{f:MultiLevelResumeTermination}
+\end{figure}
+
+Both labelled ©continue© and ©break© are a ©goto©\index{goto@©goto©!restricted} restricted in the following ways:
 \begin{itemize}
 \item
-They cannot be used to create a loop.
-This means that only the looping construct can be used to create a loop.
-This restriction is important since all situations that can result in repeated execution of statements in a program are clearly delineated.
-\item
-Since they always transfer out of containing control structures, they cannot be used to branch into a control structure.
+They cannot create a loop, which means only the looping constructs cause looping.
+This restriction means all situations resulting in repeated execution are clearly delineated.
+\item
+They cannot branch into a control structure.
+This restriction prevents missing initialization at the start of a control structure resulting in undefined behaviour.
 \end{itemize}
-The advantage of the labelled ©continue©/©break© is allowing static multi-level exits without having to use the ©goto© statement and tying control flow to the target control structure rather than an arbitrary point in a program.
+The advantage of the labelled ©continue©/©break© is allowing static multi-level exits without having to use the ©goto© statement, and tying control flow to the target control structure rather than an arbitrary point in a program.
 Furthermore, the location of the label at the \emph{beginning} of the target control structure informs the reader that complex control-flow is occurring in the body of the control structure.
 With ©goto©, the label is at the end of the control structure, which fails to convey this important clue early enough to the reader.
@@ -2268,5 +2248,5 @@
 \index{input/output library}
 
-The goal for the \CFA I/O is to make I/O as simple as possible in the common cases, while fully supporting polymorphism and user defined types in a consistent way.
+The goal of \CFA I/O is to simplify the common cases\index{I/O!common case}, while fully supporting polymorphism and user defined types in a consistent way.
 The common case is printing out a sequence of variables separated by whitespace.
 \begin{quote2}
@@ -2274,5 +2254,5 @@
 \multicolumn{1}{c@{\hspace{3em}}}{\textbf{\CFA}}	& \multicolumn{1}{c}{\textbf{\CC}}	\\
 \begin{cfa}
-int x = 0, y = 1, z = 2;
+int x = 1, y = 2, z = 3;
 sout | x ®|® y ®|® z | endl;
 \end{cfa}
@@ -2281,10 +2261,25 @@
 
 cout << x ®<< " "® << y ®<< " "® << z << endl;
+\end{cfa}
+\\
+\begin{cfa}[mathescape=off,showspaces=true,aboveskip=0pt,belowskip=0pt]
+1 2 3
+\end{cfa}
+&
+\begin{cfa}[mathescape=off,showspaces=true,aboveskip=0pt,belowskip=0pt]
+1 2 3
 \end{cfa}
 \end{tabular}
 \end{quote2}
 The \CFA form has half as many characters as the \CC form, and is similar to \Index*{Python} I/O with respect to implicit separators.
-
-The logical-or operator is used because it is the lowest-priority overloadable operator, other than assignment.
+A tuple prints all the tuple's values, each separated by ©", "©.
+\begin{cfa}[mathescape=off,aboveskip=0pt,belowskip=0pt]
+[int, int] t1 = [1, 2], t2 = [3, 4];
+sout | t1 | t2 | endl;					§\C{// print tuples}§
+\end{cfa}
+\begin{cfa}[mathescape=off,showspaces=true,belowskip=0pt]
+1, 2, 3, 4
+\end{cfa}
+\CFA uses the logical-or operator for I/O because it is the lowest-priority overloadable operator, other than assignment.
 Therefore, fewer output expressions require parenthesis.
 \begin{quote2}
@@ -2299,5 +2294,10 @@
 &
 \begin{cfa}
-cout << x * 3 << y + 1 << (z << 2) << (x == y) << (x | y) << (x || y) << (x > z ? 1 : 2) << endl;
+cout << x * 3 << y + 1 << ®(®z << 2®)® << ®(®x == y®)® << (x | y) << (x || y) << (x > z ? 1 : 2) << endl;
+\end{cfa}
+\\
+&
+\begin{cfa}[mathescape=off,showspaces=true,aboveskip=0pt,belowskip=0pt]
+3 3 12 0 3 1 2
 \end{cfa}
 \end{tabular}
@@ -2305,4 +2305,5 @@
 Finally, the logical-or operator has a link with the Shell pipe-operator for moving data, where data flows in the correct direction for input but the opposite direction for output.
 
+
 The implicit separator\index{I/O separator} character (space/blank) is a separator not a terminator.
 The rules for implicitly adding the separator are:
@@ -2316,4 +2317,5 @@
 1 2 3
 \end{cfa}
+
 \item
 A separator does not appear before or after a character literal or variable.
@@ -2322,6 +2324,7 @@
 123
 \end{cfa}
-\item
-A separator does not appear before or after a null (empty) C string
+
+\item
+A separator does not appear before or after a null (empty) C string.
 \begin{cfa}
 sout | 1 | "" | 2 | "" | 3 | endl;
@@ -2329,6 +2332,7 @@
 \end{cfa}
 which is a local mechanism to disable insertion of the separator character.
-\item
-A separator does not appear before a C string starting with the (extended) \Index{ASCII}\index{ASCII!extended} characters: \lstinline[mathescape=off]@([{=$£¥¡¿«@
+
+\item
+A separator does not appear before a C string starting with the (extended) \Index{ASCII}\index{ASCII!extended} characters: \lstinline[mathescape=off,basicstyle=\tt]@([{=$£¥¡¿«@
 %$
 \begin{cfa}[mathescape=off]
@@ -2337,29 +2341,64 @@
 \end{cfa}
 %$
-\begin{cfa}[mathescape=off,showspaces=true,aboveskip=0pt,belowskip=0pt]
-x (1 x [2 x {3 x =4 x $5 x £6 x ¥7 x ¡8 x ¿9 x «10
+\begin{cfa}[mathescape=off,basicstyle=\tt,showspaces=true,aboveskip=0pt,belowskip=0pt]
+x ®(®1 x ®[®2 x ®{®3 x ®=®4 x ®$®5 x ®£®6 x ®¥®7 x ®¡®8 x ®¿®9 x ®«®10
 \end{cfa}
 %$
+where \lstinline[basicstyle=\tt]@¡¿@ are inverted opening exclamation and question marks, and \lstinline[basicstyle=\tt]@«@ is an opening citation mark.
+
 \item
 {\lstset{language=CFA,deletedelim=**[is][]{¢}{¢}}
-A seperator does not appear after a C string ending with the (extended) \Index{ASCII}\index{ASCII!extended} characters: ©,.;!?)]}%¢»©
+A seperator does not appear after a C string ending with the (extended) \Index{ASCII}\index{ASCII!extended} characters: \lstinline[basicstyle=\tt]@,.;!?)]}%¢»@
 \begin{cfa}[belowskip=0pt]
 sout | 1 | ", x" | 2 | ". x" | 3 | "; x" | 4 | "! x" | 5 | "? x" | 6 | "% x"
 		| 7 | "¢ x" | 8 | "» x" | 9 | ") x" | 10 | "] x" | 11 | "} x" | endl;
 \end{cfa}
-\begin{cfa}[mathescape=off,showspaces=true,aboveskip=0pt,belowskip=0pt]
-1, x 2. x 3; x 4! x 5? x 6% x 7§\textcent§ x 8» x 9) x 10] x 11} x
+\begin{cfa}[basicstyle=\tt,showspaces=true,aboveskip=0pt,belowskip=0pt]
+1®,® x 2®.® x 3®;® x 4®!® x 5®?® x 6®%® x 7§\color{red}\textcent§ x 8®»® x 9®)® x 10®]® x 11®}® x
 \end{cfa}}%
-\item
-A seperator does not appear before or after a C string begining/ending with the \Index{ASCII} quote or whitespace characters: \lstinline[showspaces=true]@`'": \t\v\f\r\n@
+where \lstinline[basicstyle=\tt]@»@ is a closing citation mark.
+
+\item
+A seperator does not appear before or after a C string begining/ending with the \Index{ASCII} quote or whitespace characters: \lstinline[basicstyle=\tt,showspaces=true]@`'": \t\v\f\r\n@
 \begin{cfa}[belowskip=0pt]
 sout | "x`" | 1 | "`x'" | 2 | "'x\"" | 3 | "\"x:" | 4 | ":x " | 5 | " x\t" | 6 | "\tx" | endl;
 \end{cfa}
-\begin{cfa}[mathescape=off,showspaces=true,showtabs=true,aboveskip=0pt,belowskip=0pt]
-x`1`x'2'x"3"x:4:x 5 x	6	x
+\begin{cfa}[basicstyle=\tt,showspaces=true,showtabs=true,aboveskip=0pt,belowskip=0pt]
+x®`®1®`®x§\color{red}\texttt{'}§2§\color{red}\texttt{'}§x§\color{red}\texttt{"}§3§\color{red}\texttt{"}§x®:®4®:®x® ®5® ®x®	®6®	®x
+\end{cfa}
+
+\item
+If a space is desired before or after one of the special string start/end characters, simply insert a space.
+\begin{cfa}[belowskip=0pt]
+sout | "x (§\color{red}\texttt{\textvisiblespace}§" | 1 | "§\color{red}\texttt{\textvisiblespace}§) x" | 2 | "§\color{red}\texttt{\textvisiblespace}§, x" | 3 | "§\color{red}\texttt{\textvisiblespace}§:x:§\color{red}\texttt{\textvisiblespace}§" | 4 | endl;
+\end{cfa}
+\begin{cfa}[basicstyle=\tt,showspaces=true,showtabs=true,aboveskip=0pt,belowskip=0pt]
+x (® ®1® ®) x 2® ®, x 3® ®:x:® ®4
 \end{cfa}
 \end{enumerate}
 
-The following \CC-style \Index{manipulator}s allow control over implicit seperation.
+The following routines and \CC-style \Index{manipulator}s control implicit seperation.
+\begin{enumerate}
+\item
+Routines \Indexc{sepSet}\index{manipulator!sepSet@©sepSet©} and \Indexc{sepGet}\index{manipulator!sepGet@©sepGet©} set and get the separator string.
+The separator string can be at most 16 characters including the ©'\0'© string terminator (15 printable characters).
+\begin{cfa}[mathescape=off,aboveskip=0pt,belowskip=0pt]
+sepSet( sout, ", $" );						§\C{// set separator from " " to ", \$"}§
+sout | 1 | 2 | 3 | " \"" | ®sepGet( sout )® | "\"" | endl;
+\end{cfa}
+%$
+\begin{cfa}[mathescape=off,showspaces=true,aboveskip=0pt]
+1, $2, $3 ®", $"®
+\end{cfa}
+%$
+\begin{cfa}[mathescape=off,aboveskip=0pt,belowskip=0pt]
+sepSet( sout, " " );						§\C{// reset separator to " "}§
+sout | 1 | 2 | 3 | " \"" | ®sepGet( sout )® | "\"" | endl;
+\end{cfa}
+\begin{cfa}[mathescape=off,showspaces=true,aboveskip=0pt]
+1 2 3 ®" "®
+\end{cfa}
+
+\item
 Manipulators \Indexc{sepOn}\index{manipulator!sepOn@©sepOn©} and \Indexc{sepOff}\index{manipulator!sepOff@©sepOff©} \emph{locally} toggle printing the separator, \ie the seperator is adjusted only with respect to the next printed item.
 \begin{cfa}[mathescape=off,belowskip=0pt]
@@ -2375,4 +2414,6 @@
 12 3
 \end{cfa}
+
+\item
 Manipulators \Indexc{sepDisable}\index{manipulator!sepDisable@©sepDisable©} and \Indexc{sepEnable}\index{manipulator!sepEnable@©sepEnable©} \emph{globally} toggle printing the separator, \ie the seperator is adjusted with respect to all subsequent printed items, unless locally adjusted.
 \begin{cfa}[mathescape=off,aboveskip=0pt,belowskip=0pt]
@@ -2394,51 +2435,33 @@
 1 2 3
 \end{cfa}
-Printing a tuple outputs all the tuple's values separated by ©", "©:
+
+\item
+Routine \Indexc{sepSetTuple}\index{manipulator!sepSetTuple@©sepSetTuple©} and \Indexc{sepGetTuple}\index{manipulator!sepGetTuple@©sepGetTuple©} get and set the tuple separator-string.
+The tuple separator-string can be at most 16 characters including the ©'\0'© string terminator (15 printable characters).
 \begin{cfa}[mathescape=off,aboveskip=0pt,belowskip=0pt]
-sout | [2, 3] | [4, 5] | endl;				§\C{// print tuple}§
+sepSetTuple( sout, " " );					§\C{// set tuple separator from ", " to " "}§
+sout | t1 | t2 | " \"" | ®sepGetTuple( sout )® | "\"" | endl;
+\end{cfa}
+\begin{cfa}[mathescape=off,showspaces=true,aboveskip=0pt]
+1 2 3 4 ®" "®
+\end{cfa}
+\begin{cfa}[mathescape=off,aboveskip=0pt,belowskip=0pt]
+sepSetTuple( sout, ", " );					§\C{// reset tuple separator to ", "}§
+sout | t1 | t2 | " \"" | ®sepGetTuple( sout )® | "\"" | endl;
+\end{cfa}
+\begin{cfa}[mathescape=off,showspaces=true,aboveskip=0pt]
+1, 2, 3, 4 ®", "®
+\end{cfa}
+
+\item
+The tuple separator can also be turned on and off.
+\begin{cfa}[mathescape=off,aboveskip=0pt,belowskip=0pt]
+sout | sepOn | t1 | sepOff | t2 | endl;		§\C{// locally turn on/off implicit separation}§
 \end{cfa}
 \begin{cfa}[mathescape=off,showspaces=true,aboveskip=0pt,belowskip=0pt]
-2, 3, 4, 5
-\end{cfa}
-The tuple separator can also be turned on and off:
-\begin{cfa}[mathescape=off,aboveskip=0pt,belowskip=0pt]
-sout | sepOn | [2, 3] | sepOff | [4, 5] | endl;	§\C{// locally turn on/off implicit separation}§
-\end{cfa}
-\begin{cfa}[mathescape=off,showspaces=true,aboveskip=0pt,belowskip=0pt]
-, 2, 34, 5
+, 1, 23, 4
 \end{cfa}
 Notice a tuple seperator starts the line because the next item is a tuple.
-Finally, the stream routines \Indexc{sepGet}\index{manipulator!sepGet@©sepGet©} and \Indexc{sepSet}\index{manipulator!sepSet@©sepSet©} get and set the basic separator-string.
-\begin{cfa}[mathescape=off,aboveskip=0pt,aboveskip=0pt,belowskip=0pt]
-sepSet( sout, ", $" );						§\C{// set separator from " " to ", \$"}§
-sout | 1 | 2 | 3 | " \"" | sepGet( sout ) | "\"" | endl;
-\end{cfa}
-%$
-\begin{cfa}[mathescape=off,showspaces=true,aboveskip=0pt]
-1, $2, $3 ", $"
-\end{cfa}
-%$
-\begin{cfa}[mathescape=off,aboveskip=0pt,aboveskip=0pt,belowskip=0pt]
-sepSet( sout, " " );						§\C{// reset separator to " "}§
-sout | 1 | 2 | 3 | " \"" | sepGet( sout ) | "\"" | endl;
-\end{cfa}
-\begin{cfa}[mathescape=off,showspaces=true,aboveskip=0pt]
-1 2 3 " "
-\end{cfa}
-and the stream routines \Indexc{sepGetTuple}\index{manipulator!sepGetTuple@©sepGetTuple©} and \Indexc{sepSetTuple}\index{manipulator!sepSetTuple@©sepSetTuple©} get and set the tuple separator-string.
-\begin{cfa}[mathescape=off,aboveskip=0pt,aboveskip=0pt,belowskip=0pt]
-sepSetTuple( sout, " " );					§\C{// set tuple separator from ", " to " "}§
-sout | [2, 3] | [4, 5] | " \"" | sepGetTuple( sout ) | "\"" | endl;
-\end{cfa}
-\begin{cfa}[mathescape=off,showspaces=true,aboveskip=0pt]
-2 3 4 5 " "
-\end{cfa}
-\begin{cfa}[mathescape=off,aboveskip=0pt,aboveskip=0pt,belowskip=0pt]
-sepSetTuple( sout, ", " );					§\C{// reset tuple separator to ", "}§
-sout | [2, 3] | [4, 5] | " \"" | sepGetTuple( sout ) | "\"" | endl;
-\end{cfa}
-\begin{cfa}[mathescape=off,showspaces=true,aboveskip=0pt]
-2, 3, 4, 5 ", "
-\end{cfa}
+\end{enumerate}
 
 \begin{comment}
@@ -2446,6 +2469,9 @@
 
 int main( void ) {
-	int x = 0, y = 1, z = 2;
-	sout | x * 3 | y + 1 | z << 2 | x == y | (x | y) | (x || y) | (x > z ? 1 : 2) | endl | endl;
+	int x = 1, y = 2, z = 3;
+	sout | x | y | z | endl;
+	[int, int] t1 = [1, 2], t2 = [3, 4];
+	sout | t1 | t2 | endl;						// print tuple
+	sout | x * 3 | y + 1 | z << 2 | x == y | (x | y) | (x || y) | (x > z ? 1 : 2) | endl;
 	sout | 1 | 2 | 3 | endl;
 	sout | '1' | '2' | '3' | endl;
@@ -2456,13 +2482,5 @@
 		| 7 | "¢ x" | 8 | "» x" | 9 | ") x" | 10 | "] x" | 11 | "} x" | endl;
 	sout | "x`" | 1 | "`x'" | 2 | "'x\"" | 3 | "\"x:" | 4 | ":x " | 5 | " x\t" | 6 | "\tx" | endl;
-
-	sout | sepOn | 1 | 2 | 3 | sepOn | endl;	// separator at start of line
-	sout | 1 | sepOff | 2 | 3 | endl;			// locally turn off implicit separator
-	sout | sepDisable | 1 | 2 | 3 | endl;		// globally turn off implicit separation
-	sout | 1 | sepOn | 2 | 3 | endl;			// locally turn on implicit separator
-	sout | sepEnable | 1 | 2 | 3 | endl;		// globally turn on implicit separation
-
-	sout | [2, 3] | [4, 5] | endl;				// print tuple
-	sout | sepOn | [2, 3] | sepOff | [4, 5] | endl;	// locally turn on/off implicit separation
+	sout | "x ( " | 1 | " ) x" | 2 | " , x" | 3 | " :x: " | 4 | endl;
 
 	sepSet( sout, ", $" );						// set separator from " " to ", $"
@@ -2471,12 +2489,23 @@
 	sout | 1 | 2 | 3 | " \"" | sepGet( sout ) | "\"" | endl;
 
+	sout | sepOn | 1 | 2 | 3 | sepOn | endl;	// separator at start of line
+	sout | 1 | sepOff | 2 | 3 | endl;			// locally turn off implicit separator
+
+	sout | sepDisable | 1 | 2 | 3 | endl;		// globally turn off implicit separation
+	sout | 1 | sepOn | 2 | 3 | endl;			// locally turn on implicit separator
+	sout | sepEnable | 1 | 2 | 3 | endl;		// globally turn on implicit separation
+
 	sepSetTuple( sout, " " );					// set tuple separator from ", " to " "
-	sout | [2, 3] | [4, 5] | " \"" | sepGetTuple( sout ) | "\"" | endl;
+	sout | t1 | t2 | " \"" | sepGetTuple( sout ) | "\"" | endl;
 	sepSetTuple( sout, ", " );					// reset tuple separator to ", "
-	sout | [2, 3] | [4, 5] | " \"" | sepGetTuple( sout ) | "\"" | endl;
+	sout | t1 | t2 | " \"" | sepGetTuple( sout ) | "\"" | endl;
+
+	sout | t1 | t2 | endl;						// print tuple
+	sout | sepOn | t1 | sepOff | t2 | endl;		// locally turn on/off implicit separation
 }
 
 // Local Variables: //
 // tab-width: 4 //
+// fill-column: 100 //
 // End: //
 \end{comment}
@@ -2972,5 +3001,5 @@
 generic (type T | bool ?<?(T, T) )
 
-T min(T a, T b) {
+T min( T a, T b ) {
 	return a < b ? a : b;
 }
@@ -3011,5 +3040,5 @@
 
 generic (type T | Orderable(T))
-T min(T a, T b) {
+T min( T a, T b ) {
 	return a < b ? a : b;
 }
@@ -5081,17 +5110,61 @@
 C11 prescribes the following standard header-files~\cite[\S~7.1.2]{C11} and \CFA adds to this list:
 \begin{quote2}
-\begin{tabular}{lll|l}
-\multicolumn{3}{c|}{C11} & \multicolumn{1}{c}{\CFA}		\\
+\begin{tabular}{llll|l}
+\multicolumn{4}{c|}{C11} & \multicolumn{1}{c}{\CFA}		\\
 \hline
-assert.h	& math.h		& stdlib.h		& unistd.h	\\
-complex.h	& setjmp.h		& stdnoreturn.h	& gmp.h		\\
-ctype.h		& signal.h		& string.h		\\
-errno.h		& stdalign.h	& tgmath.h		\\
-fenv.h		& stdarg.h		& threads.h		\\
-float.h		& stdatomic.h	& time.h		\\
-inttypes.h	& stdbool.h		& uchar.h		\\
-iso646.h	& stddef.h		& wchar.h		\\
-limits.h	& stdint.h		& wctype.h		\\
-locale.h	& stdio.h		&				\\
+\begin{tabular}{@{}l@{}}
+assert.h	\\
+complex.h	\\
+ctype.h		\\
+errno.h		\\
+fenv.h		\\
+float.h		\\
+inttypes.h	\\
+iso646.h	\\
+\end{tabular}
+&
+\begin{tabular}{@{}l@{}}
+limits.h	\\
+locale.h	\\
+math.h		\\
+setjmp.h	\\
+signal.h	\\
+stdalign.h	\\
+stdarg.h	\\
+stdatomic.h	\\
+\end{tabular}
+&
+\begin{tabular}{@{}l@{}}
+stdbool.h	\\
+stddef.h	\\
+stdint.h	\\
+stdio.h		\\
+stdlib.h	\\
+stdnoreturn.h \\
+string.h	\\
+tgmath.h	\\
+\end{tabular}
+&
+\begin{tabular}{@{}l@{}}
+threads.h	\\
+time.h		\\
+uchar.h		\\
+wchar.h		\\
+wctype.h	\\
+			\\
+			\\
+			\\
+\end{tabular}
+&
+\begin{tabular}{@{}l@{}}
+unistd.h	\\
+gmp.h		\\
+			\\
+			\\
+			\\
+			\\
+			\\
+			\\
+\end{tabular}
 \end{tabular}
 \end{quote2}
@@ -5104,5 +5177,5 @@
 \label{s:StandardLibrary}
 
-The \CFA standard-library wraps many existing explicitly-polymorphic C general-routines into implicitly-polymorphic versions.
+The \CFA standard-library wraps explicitly-polymorphic C general-routines into implicitly-polymorphic versions.
 
 
@@ -5122,7 +5195,4 @@
 forall( dtype T | sized(T) ) T * memalign( size_t alignment );		// deprecated
 forall( dtype T | sized(T) ) int posix_memalign( T ** ptr, size_t alignment );
-
-forall( otype T ) T * memset( T * ptr, unsigned char fill ); // use default value '\0' for fill
-forall( otype T ) T * memset( T * ptr );				// remove when default value available
 
 forall( dtype T, ttype Params | sized(T) | { void ?{}(T *, Params); } ) T * new( Params p );
@@ -5168,6 +5238,9 @@
 \leavevmode
 \begin{cfa}[aboveskip=0pt,belowskip=0pt]
-forall( otype T | { int ?<?( T, T ); } )
-T * bsearch( const T key, const T * arr, size_t dimension );§\indexc{bsearch}§
+forall( otype T | { int ?<?( T, T ); } )	// location
+T * bsearch( T key, const T * arr, size_t dimension );§\indexc{bsearch}§
+
+forall( otype T | { int ?<?( T, T ); } )	// position
+unsigned int bsearch( T key, const T * arr, size_t dimension );
 
 forall( otype T | { int ?<?( T, T ); } )
@@ -5180,8 +5253,8 @@
 \leavevmode
 \begin{cfa}[aboveskip=0pt,belowskip=0pt]
-char abs( char );§\indexc{abs}§
+unsigned char abs( signed char );§\indexc{abs}§
 int abs( int );
-long int abs( long int );
-long long int abs( long long int );
+unsigned long int abs( long int );
+unsigned long long int abs( long long int );
 float abs( float );
 double abs( double );
@@ -5190,4 +5263,6 @@
 double abs( double _Complex );
 long double abs( long double _Complex );
+forall( otype T | { void ?{}( T *, zero_t ); int ?<?( T, T ); T -?( T ); } )
+T abs( T );
 \end{cfa}
 
@@ -5216,8 +5291,8 @@
 \begin{cfa}[aboveskip=0pt,belowskip=0pt]
 forall( otype T | { int ?<?( T, T ); } )
-T min( const T t1, const T t2 );§\indexc{min}§
+T min( T t1, T t2 );§\indexc{min}§
 
 forall( otype T | { int ?>?( T, T ); } )
-T max( const T t1, const T t2 );§\indexc{max}§
+T max( T t1, T t2 );§\indexc{max}§
 
 forall( otype T | { T min( T, T ); T max( T, T ); } )
@@ -5232,5 +5307,5 @@
 \label{s:Math Library}
 
-The \CFA math-library wraps many existing explicitly-polymorphic C math-routines into implicitly-polymorphic versions.
+The \CFA math-library wraps explicitly-polymorphic C math-routines into implicitly-polymorphic versions.
 
 
@@ -5239,11 +5314,4 @@
 \leavevmode
 \begin{cfa}[aboveskip=0pt,belowskip=0pt]
-float fabs( float );§\indexc{fabs}§
-double fabs( double );
-long double fabs( long double );
-float cabs( float _Complex );
-double cabs( double _Complex );
-long double cabs( long double _Complex );
-
 float ?%?( float, float );§\indexc{fmod}§
 float fmod( float, float );
@@ -5600,4 +5668,258 @@
 
 
+\section{Multi-precision Integers}
+\label{s:MultiPrecisionIntegers}
+
+\CFA has an interface to the \Index{GMP} \Index{multi-precision} signed-integers~\cite{GMP}, similar to the \CC interface provided by GMP.
+The \CFA interface wraps GMP routines into operator routines to make programming with multi-precision integers identical to using fixed-sized integers.
+The \CFA type name for multi-precision signed-integers is \Indexc{Int}.
+
+\begin{cfa}
+void ?{}( Int * this );					§\C{// constructor}§
+void ?{}( Int * this, Int init );
+void ?{}( Int * this, zero_t );
+void ?{}( Int * this, one_t );
+void ?{}( Int * this, signed long int init );
+void ?{}( Int * this, unsigned long int init );
+void ?{}( Int * this, const char * val );
+void ^?{}( Int * this );
+
+Int ?=?( Int * lhs, Int rhs );			§\C{// assignment}§
+Int ?=?( Int * lhs, long int rhs );
+Int ?=?( Int * lhs, unsigned long int rhs );
+Int ?=?( Int * lhs, const char * rhs );
+
+char ?=?( char * lhs, Int rhs );
+short int ?=?( short int * lhs, Int rhs );
+int ?=?( int * lhs, Int rhs );
+long int ?=?( long int * lhs, Int rhs );
+unsigned char ?=?( unsigned char * lhs, Int rhs );
+unsigned short int ?=?( unsigned short int * lhs, Int rhs );
+unsigned int ?=?( unsigned int * lhs, Int rhs );
+unsigned long int ?=?( unsigned long int * lhs, Int rhs );
+
+long int narrow( Int val );
+unsigned long int narrow( Int val );
+
+int ?==?( Int oper1, Int oper2 );		§\C{// comparison}§
+int ?==?( Int oper1, long int oper2 );
+int ?==?( long int oper2, Int oper1 );
+int ?==?( Int oper1, unsigned long int oper2 );
+int ?==?( unsigned long int oper2, Int oper1 );
+
+int ?!=?( Int oper1, Int oper2 );
+int ?!=?( Int oper1, long int oper2 );
+int ?!=?( long int oper1, Int oper2 );
+int ?!=?( Int oper1, unsigned long int oper2 );
+int ?!=?( unsigned long int oper1, Int oper2 );
+
+int ?<?( Int oper1, Int oper2 );
+int ?<?( Int oper1, long int oper2 );
+int ?<?( long int oper2, Int oper1 );
+int ?<?( Int oper1, unsigned long int oper2 );
+int ?<?( unsigned long int oper2, Int oper1 );
+
+int ?<=?( Int oper1, Int oper2 );
+int ?<=?( Int oper1, long int oper2 );
+int ?<=?( long int oper2, Int oper1 );
+int ?<=?( Int oper1, unsigned long int oper2 );
+int ?<=?( unsigned long int oper2, Int oper1 );
+
+int ?>?( Int oper1, Int oper2 );
+int ?>?( Int oper1, long int oper2 );
+int ?>?( long int oper1, Int oper2 );
+int ?>?( Int oper1, unsigned long int oper2 );
+int ?>?( unsigned long int oper1, Int oper2 );
+
+int ?>=?( Int oper1, Int oper2 );
+int ?>=?( Int oper1, long int oper2 );
+int ?>=?( long int oper1, Int oper2 );
+int ?>=?( Int oper1, unsigned long int oper2 );
+int ?>=?( unsigned long int oper1, Int oper2 );
+
+Int +?( Int oper );						§\C{// arithmetic}§
+Int -?( Int oper );
+Int ~?( Int oper );
+
+Int ?&?( Int oper1, Int oper2 );
+Int ?&?( Int oper1, long int oper2 );
+Int ?&?( long int oper1, Int oper2 );
+Int ?&?( Int oper1, unsigned long int oper2 );
+Int ?&?( unsigned long int oper1, Int oper2 );
+Int ?&=?( Int * lhs, Int rhs );
+
+Int ?|?( Int oper1, Int oper2 );
+Int ?|?( Int oper1, long int oper2 );
+Int ?|?( long int oper1, Int oper2 );
+Int ?|?( Int oper1, unsigned long int oper2 );
+Int ?|?( unsigned long int oper1, Int oper2 );
+Int ?|=?( Int * lhs, Int rhs );
+
+Int ?^?( Int oper1, Int oper2 );
+Int ?^?( Int oper1, long int oper2 );
+Int ?^?( long int oper1, Int oper2 );
+Int ?^?( Int oper1, unsigned long int oper2 );
+Int ?^?( unsigned long int oper1, Int oper2 );
+Int ?^=?( Int * lhs, Int rhs );
+
+Int ?+?( Int addend1, Int addend2 );
+Int ?+?( Int addend1, long int addend2 );
+Int ?+?( long int addend2, Int addend1 );
+Int ?+?( Int addend1, unsigned long int addend2 );
+Int ?+?( unsigned long int addend2, Int addend1 );
+Int ?+=?( Int * lhs, Int rhs );
+Int ?+=?( Int * lhs, long int rhs );
+Int ?+=?( Int * lhs, unsigned long int rhs );
+Int ++?( Int * lhs );
+Int ?++( Int * lhs );
+
+Int ?-?( Int minuend, Int subtrahend );
+Int ?-?( Int minuend, long int subtrahend );
+Int ?-?( long int minuend, Int subtrahend );
+Int ?-?( Int minuend, unsigned long int subtrahend );
+Int ?-?( unsigned long int minuend, Int subtrahend );
+Int ?-=?( Int * lhs, Int rhs );
+Int ?-=?( Int * lhs, long int rhs );
+Int ?-=?( Int * lhs, unsigned long int rhs );
+Int --?( Int * lhs );
+Int ?--( Int * lhs );
+
+Int ?*?( Int multiplicator, Int multiplicand );
+Int ?*?( Int multiplicator, long int multiplicand );
+Int ?*?( long int multiplicand, Int multiplicator );
+Int ?*?( Int multiplicator, unsigned long int multiplicand );
+Int ?*?( unsigned long int multiplicand, Int multiplicator );
+Int ?*=?( Int * lhs, Int rhs );
+Int ?*=?( Int * lhs, long int rhs );
+Int ?*=?( Int * lhs, unsigned long int rhs );
+
+Int ?/?( Int dividend, Int divisor );
+Int ?/?( Int dividend, unsigned long int divisor );
+Int ?/?( unsigned long int dividend, Int divisor );
+Int ?/?( Int dividend, long int divisor );
+Int ?/?( long int dividend, Int divisor );
+Int ?/=?( Int * lhs, Int rhs );
+Int ?/=?( Int * lhs, long int rhs );
+Int ?/=?( Int * lhs, unsigned long int rhs );
+
+[ Int, Int ] div( Int dividend, Int divisor );
+[ Int, Int ] div( Int dividend, unsigned long int divisor );
+
+Int ?%?( Int dividend, Int divisor );
+Int ?%?( Int dividend, unsigned long int divisor );
+Int ?%?( unsigned long int dividend, Int divisor );
+Int ?%?( Int dividend, long int divisor );
+Int ?%?( long int dividend, Int divisor );
+Int ?%=?( Int * lhs, Int rhs );
+Int ?%=?( Int * lhs, long int rhs );
+Int ?%=?( Int * lhs, unsigned long int rhs );
+
+Int ?<<?( Int shiften, mp_bitcnt_t shift );
+Int ?<<=?( Int * lhs, mp_bitcnt_t shift );
+Int ?>>?( Int shiften, mp_bitcnt_t shift );
+Int ?>>=?( Int * lhs, mp_bitcnt_t shift );
+
+Int abs( Int oper );					§\C{// number functions}§
+Int fact( unsigned long int N );
+Int gcd( Int oper1, Int oper2 );
+Int pow( Int base, unsigned long int exponent );
+Int pow( unsigned long int base, unsigned long int exponent );
+void srandom( gmp_randstate_t state );
+Int random( gmp_randstate_t state, mp_bitcnt_t n );
+Int random( gmp_randstate_t state, Int n );
+Int random( gmp_randstate_t state, mp_size_t max_size );
+int sgn( Int oper );
+Int sqrt( Int oper );
+
+forall( dtype istype | istream( istype ) ) istype * ?|?( istype * is, Int * mp );  §\C{// I/O}§
+forall( dtype ostype | ostream( ostype ) ) ostype * ?|?( ostype * os, Int mp );
+\end{cfa}
+
+The following factorial programs contrast using GMP with the \CFA and C interfaces, where the output from these programs appears in \VRef[Figure]{f:MultiPrecisionFactorials}.
+(Compile with flag \Indexc{-lgmp} to link with the GMP library.)
+\begin{quote2}
+\begin{tabular}{@{}l@{\hspace{\parindentlnth}}|@{\hspace{\parindentlnth}}l@{}}
+\multicolumn{1}{c|@{\hspace{\parindentlnth}}}{\textbf{\CFA}}	& \multicolumn{1}{@{\hspace{\parindentlnth}}c}{\textbf{C}}	\\
+\hline
+\begin{cfa}
+#include <gmp>
+int main( void ) {
+	sout | "Factorial Numbers" | endl;
+	Int fact;
+	fact = 1;
+	sout | 0 | fact | endl;
+	for ( unsigned int i = 1; i <= 40; i += 1 ) {
+		fact *= i;
+		sout | i | fact | endl;
+	}
+}
+\end{cfa}
+&
+\begin{cfa}
+#include <gmp.h>
+int main( void ) {
+	®gmp_printf®( "Factorial Numbers\n" );
+	®mpz_t® fact;
+	®mpz_init_set_ui®( fact, 1 );
+	®gmp_printf®( "%d %Zd\n", 0, fact );
+	for ( unsigned int i = 1; i <= 40; i += 1 ) {
+		®mpz_mul_ui®( fact, fact, i );
+		®gmp_printf®( "%d %Zd\n", i, fact );
+	}
+}
+\end{cfa}
+\end{tabular}
+\end{quote2}
+
+\begin{figure}
+\begin{cfa}
+Factorial Numbers
+0 1
+1 1
+2 2
+3 6
+4 24
+5 120
+6 720
+7 5040
+8 40320
+9 362880
+10 3628800
+11 39916800
+12 479001600
+13 6227020800
+14 87178291200
+15 1307674368000
+16 20922789888000
+17 355687428096000
+18 6402373705728000
+19 121645100408832000
+20 2432902008176640000
+21 51090942171709440000
+22 1124000727777607680000
+23 25852016738884976640000
+24 620448401733239439360000
+25 15511210043330985984000000
+26 403291461126605635584000000
+27 10888869450418352160768000000
+28 304888344611713860501504000000
+29 8841761993739701954543616000000
+30 265252859812191058636308480000000
+31 8222838654177922817725562880000000
+32 263130836933693530167218012160000000
+33 8683317618811886495518194401280000000
+34 295232799039604140847618609643520000000
+35 10333147966386144929666651337523200000000
+36 371993326789901217467999448150835200000000
+37 13763753091226345046315979581580902400000000
+38 523022617466601111760007224100074291200000000
+39 20397882081197443358640281739902897356800000000
+40 815915283247897734345611269596115894272000000000
+\end{cfa}
+\caption{Multi-precision Factorials}
+\label{f:MultiPrecisionFactorials}
+\end{figure}
+
+
 \section{Rational Numbers}
 \label{s:RationalNumbers}
@@ -5612,21 +5934,16 @@
 }; // Rational
 
-// constants
-extern struct Rational 0;
-extern struct Rational 1;
-
-// constructors
-Rational rational();
+Rational rational();					§\C{// constructors}§
 Rational rational( long int n );
 Rational rational( long int n, long int d );
-
-// getter/setter for numerator/denominator
-long int numerator( Rational r );
+void ?{}( Rational * r, zero_t );
+void ?{}( Rational * r, one_t );
+
+long int numerator( Rational r );		§\C{// numerator/denominator getter/setter}§
 long int numerator( Rational r, long int n );
 long int denominator( Rational r );
 long int denominator( Rational r, long int d );
 
-// comparison
-int ?==?( Rational l, Rational r );
+int ?==?( Rational l, Rational r );		§\C{// comparison}§
 int ?!=?( Rational l, Rational r );
 int ?<?( Rational l, Rational r );
@@ -5635,6 +5952,5 @@
 int ?>=?( Rational l, Rational r );
 
-// arithmetic
-Rational -?( Rational r );
+Rational -?( Rational r );				§\C{// arithmetic}§
 Rational ?+?( Rational l, Rational r );
 Rational ?-?( Rational l, Rational r );
@@ -5642,10 +5958,8 @@
 Rational ?/?( Rational l, Rational r );
 
-// conversion
-double widen( Rational r );
+double widen( Rational r );				§\C{// conversion}§
 Rational narrow( double f, long int md );
 
-// I/O
-forall( dtype istype | istream( istype ) ) istype * ?|?( istype *, Rational * );
+forall( dtype istype | istream( istype ) ) istype * ?|?( istype *, Rational * ); // I/O
 forall( dtype ostype | ostream( ostype ) ) ostype * ?|?( ostype *, Rational );
 \end{cfa}
