Index: doc/user/user.tex
===================================================================
--- doc/user/user.tex	(revision 558999fe8e14e308055cf923b0444fc66de7870f)
+++ doc/user/user.tex	(revision 134e6d9b32539c6e7854c1d9211fbefa0c94f9d1)
@@ -11,6 +11,6 @@
 %% Created On       : Wed Apr  6 14:53:29 2016
 %% Last Modified By : Peter A. Buhr
-%% Last Modified On : Mon Aug 22 23:43:30 2022
-%% Update Count     : 5503
+%% Last Modified On : Mon Jun  5 21:18:29 2023
+%% Update Count     : 5521
 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 
@@ -108,6 +108,6 @@
 \huge \CFA Team (past and present) \medskip \\
 \Large Andrew Beach, Richard Bilson, Michael Brooks, Peter A. Buhr, Thierry Delisle, \smallskip \\
-\Large Glen Ditchfield, Rodolfo G. Esteves, Aaron Moss, Colby Parsons, Rob Schluntz, \smallskip \\
-\Large Fangren Yu, Mubeen Zulfiqar
+\Large Glen Ditchfield, Rodolfo G. Esteves, Jiada Liang, Aaron Moss, Colby Parsons \smallskip \\
+\Large Rob Schluntz, Fangren Yu, Mubeen Zulfiqar
 }% author
 
@@ -169,7 +169,7 @@
 Like \Index*[C++]{\CC{}}, there may be both old and new ways to achieve the same effect.
 For example, the following programs compare the C, \CFA, and \CC I/O mechanisms, where the programs output the same result.
-\begin{flushleft}
-\begin{tabular}{@{}l@{\hspace{1em}}l@{\hspace{1em}}l@{}}
-\multicolumn{1}{@{}c@{\hspace{1em}}}{\textbf{C}}	& \multicolumn{1}{c}{\textbf{\CFA}}	& \multicolumn{1}{c@{}}{\textbf{\CC}}	\\
+\begin{center}
+\begin{tabular}{@{}lll@{}}
+\multicolumn{1}{@{}c}{\textbf{C}}	& \multicolumn{1}{c}{\textbf{\CFA}}	& \multicolumn{1}{c@{}}{\textbf{\CC}}	\\
 \begin{cfa}[tabsize=3]
 #include <stdio.h>$\indexc{stdio.h}$
@@ -199,5 +199,5 @@
 \end{cfa}
 \end{tabular}
-\end{flushleft}
+\end{center}
 While \CFA I/O \see{\VRef{s:StreamIOLibrary}} looks similar to \Index*[C++]{\CC{}}, there are important differences, such as automatic spacing between variables and an implicit newline at the end of the expression list, similar to \Index*{Python}~\cite{Python}.
 
@@ -856,5 +856,5 @@
 still works.
 Nevertheless, reversing the default action would have a non-trivial effect on case actions that compound, such as the above example of processing shell arguments.
-Therefore, to preserve backwards compatibility, it is necessary to introduce a new kind of ©switch© statement, called \Indexc{choose}, with no implicit fall-through semantics and an explicit fall-through if the last statement of a case-clause ends with the new keyword \Indexc{fallthrough}/\Indexc{fallthru}, \eg:
+Therefore, to preserve backwards compatibility, it is necessary to introduce a new kind of ©switch© statement, called \Indexc{choose}, with no implicit fall-through semantics and an explicit fall-through if the last statement of a case-clause ends with the new keyword \Indexc{fallthrough}/\-\Indexc{fallthru}, \eg:
 \begin{cfa}
 ®choose® ( i ) {
@@ -1167,5 +1167,5 @@
 \end{cfa}
 \end{itemize}
-\R{Warning}: specifying the down-to range maybe unexcepted because the loop control \emph{implicitly} switches the L and H values (and toggles the increment/decrement for I):
+\R{Warning}: specifying the down-to range maybe unexpected because the loop control \emph{implicitly} switches the L and H values (and toggles the increment/decrement for I):
 \begin{cfa}
 for ( i; 1 ~ 10 )	${\C[1.5in]{// up range}$
@@ -1173,5 +1173,5 @@
 for ( i; ®10 -~ 1® )	${\C{// \R{WRONG down range!}}\CRT}$
 \end{cfa}
-The reason for this sematics is that the range direction can be toggled by adding/removing the minus, ©'-'©, versus interchanging the L and H expressions, which has a greater chance of introducing errors.
+The reason for this semantics is that the range direction can be toggled by adding/removing the minus, ©'-'©, versus interchanging the L and H expressions, which has a greater chance of introducing errors.
 
 
@@ -2256,10 +2256,10 @@
 Days days = Mon; // enumeration type declaration and initialization
 \end{cfa}
-The set of enums are injected into the variable namespace at the definition scope.
-Hence, enums may be overloaded with enum/variable/function names.
-\begin{cfa}
+The set of enums is injected into the variable namespace at the definition scope.
+Hence, enums may be overloaded with variable, enum, and function names.
+\begin{cfa}
+int Foo;			$\C{// type/variable separate namespaces}$
 enum Foo { Bar };
 enum Goo { Bar };	$\C[1.75in]{// overload Foo.Bar}$
-int Foo;			$\C{// type/variable separate namespace}$
 double Bar;			$\C{// overload Foo.Bar, Goo.Bar}\CRT$
 \end{cfa}
@@ -2301,5 +2301,5 @@
 Hence, the value of enum ©Mon© is 0, ©Tue© is 1, ...\,, ©Sun© is 6.
 If an enum value is specified, numbering continues by one from that value for subsequent unnumbered enums.
-If an enum value is an expression, the compiler performs constant-folding to obtain a constant value.
+If an enum value is a \emph{constant} expression, the compiler performs constant-folding to obtain a constant value.
 
 \CFA allows other integral types with associated values.
@@ -2313,10 +2313,10 @@
 \begin{cfa}
 // non-integral numeric
-enum( ®double® ) Math { PI_2 = 1.570796, PI = 3.141597,  E = 2.718282 }
+enum( ®double® ) Math { PI_2 = 1.570796, PI = 3.141597, E = 2.718282 }
 // pointer
-enum( ®char *® ) Name { Fred = "Fred",  Mary = "Mary",  Jane = "Jane" };
+enum( ®char *® ) Name { Fred = "Fred",  Mary = "Mary", Jane = "Jane" };
 int i, j, k;
 enum( ®int *® ) ptr { I = &i,  J = &j,  K = &k };
-enum( ®int &® ) ref { I = i,  J = j,  K = k };
+enum( ®int &® ) ref { I = i,   J = j,   K = k };
 // tuple
 enum( ®[int, int]® ) { T = [ 1, 2 ] };
@@ -2361,5 +2361,5 @@
 \begin{cfa}
 enum( char * ) Name2 { ®inline Name®, Jack = "Jack", Jill = "Jill" };
-enum ®/* inferred */®  Name3 { ®inline Name2®, Sue = "Sue", Tom = "Tom" };
+enum ®/* inferred */® Name3 { ®inline Name2®, Sue = "Sue", Tom = "Tom" };
 \end{cfa}
 Enumeration ©Name2© inherits all the enums and their values from enumeration ©Name© by containment, and a ©Name© enumeration is a subtype of enumeration ©Name2©.
@@ -3818,7 +3818,7 @@
 				   "[ output-file (default stdout) ] ]";
 		} // choose
-	} catch( ®Open_Failure® * ex; ex->istream == &in ) {
+	} catch( ®open_failure® * ex; ex->istream == &in ) { $\C{// input file errors}$
 		®exit® | "Unable to open input file" | argv[1];
-	} catch( ®Open_Failure® * ex; ex->ostream == &out ) {
+	} catch( ®open_failure® * ex; ex->ostream == &out ) { $\C{// output file errors}$
 		®close®( in );						$\C{// optional}$
 		®exit® | "Unable to open output file" | argv[2];
@@ -4038,5 +4038,5 @@
 
 \item
-\Indexc{sepDisable}\index{manipulator!sepDisable@©sepDisable©} and \Indexc{sepEnable}\index{manipulator!sepEnable@©sepEnable©} toggle printing the separator.
+\Indexc{sepDisable}\index{manipulator!sepDisable@©sepDisable©} and \Indexc{sepEnable}\index{manipulator!sepEnable@©sepEnable©} globally toggle printing the separator.
 \begin{cfa}[belowskip=0pt]
 sout | sepDisable | 1 | 2 | 3; $\C{// turn off implicit separator}$
@@ -4053,5 +4053,5 @@
 
 \item
-\Indexc{sepOn}\index{manipulator!sepOn@©sepOn©} and \Indexc{sepOff}\index{manipulator!sepOff@©sepOff©} toggle printing the separator with respect to the next printed item, and then return to the global separator setting.
+\Indexc{sepOn}\index{manipulator!sepOn@©sepOn©} and \Indexc{sepOff}\index{manipulator!sepOff@©sepOff©} locally toggle printing the separator with respect to the next printed item, and then return to the global separator setting.
 \begin{cfa}[belowskip=0pt]
 sout | 1 | sepOff | 2 | 3; $\C{// turn off implicit separator for the next item}$
@@ -4129,5 +4129,5 @@
 6
 \end{cfa}
-Note, a terminating ©nl© is merged (overrides) with the implicit newline at the end of the ©sout© expression, otherwise it is impossible to to print a single newline
+Note, a terminating ©nl© is merged (overrides) with the implicit newline at the end of the ©sout© expression, otherwise it is impossible to print a single newline
 \item
 \Indexc{nlOn}\index{manipulator!nlOn@©nlOn©} implicitly prints a newline at the end of each output expression.
