Index: doc/user/user.tex
===================================================================
--- doc/user/user.tex	(revision 58e2ce3410706f3978686f5d9bf0ebb96fdb0b56)
+++ doc/user/user.tex	(revision 3be81a4f4d89f40c05e9d5218b3b49580d239127)
@@ -11,6 +11,6 @@
 %% Created On       : Wed Apr  6 14:53:29 2016
 %% Last Modified By : Peter A. Buhr
-%% Last Modified On : Tue Apr 23 14:13:10 2024
-%% Update Count     : 6623
+%% Last Modified On : Tue Jul  9 10:43:40 2024
+%% Update Count     : 6887
 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 
@@ -182,5 +182,5 @@
 &
 \begin{cfa}[tabsize=3]
-#include <fstream>§\indexc{fstream}§
+#include <fstream.hfa>§\indexc{fstream.hfa}§
 
 int main( void ) {
@@ -445,5 +445,5 @@
 #include <stdio.h>§\indexc{stdio.h}§ §\C{// C header file}§
 #else
-#include <fstream>§\indexc{fstream}§ §\C{// \CFA header file}§
+#include <fstream.hfa>§\indexc{fstream.hfa}§ §\C{// \CFA header file}§
 #endif
 \end{cfa}
@@ -1006,8 +1006,8 @@
 \subsection{Loop Control}
 
-Looping a fixed number of times, possibly with a loop index, occurs frequently.
-\CFA condenses simply looping to facilitate coding speed and safety~\see{examples in \VRef[Figure]{f:LoopControlExamples}}.
-
-The \Indexc{for}, \Indexc{while}, and \Indexc{do} loop-control are extended to allow an empty conditional, which implies a comparison value of ©1© (true).
+Looping a predefined number of times, possibly with a loop index, occurs frequently.
+\CFA condenses writing loops to facilitate coding speed and safety.
+
+\Indexc{for}, \Indexc{while}, and \Indexc{do} loop-control\index{loop control} are extended with an empty conditional, meaning a comparison value of ©1© (true).
 \begin{cfa}
 while ( ®/* empty */®  )				§\C{// while ( true )}§
@@ -1015,4 +1015,116 @@
 do ... while ( ®/* empty */®  )			§\C{// do ... while ( true )}§
 \end{cfa}
+
+The ©for© control\index{for control}, \ie ©for ( /* control */ )©, is extended with a range and step.
+A range is a set of values defined by an optional low value (default to 0), tilde, and high value, ©L ~ H©, with an optional step ©~ S© (default to 1), which means an ascending set of values from ©L© to ©H© in positive steps of ©S©.
+\begin{cfa}
+0 ~ 5									§\C{// \{ 0, 1, 2, 3, 4, 5 \}}§
+-8 ~ -2 ~ 2								§\C{// \{ -8. -6, -4, -2 \}}§
+-3 ~ 3 ~ 1								§\C{// \{ -3, -2, -1, 0, 1, 2, 3 \}}§
+\end{cfa}
+\R{Warning}: A range in descending order, \eg ©5 ~ -3© is the null (empty) set, \ie no values in the set.
+\R{Warning}: A ©0© or negative step is undefined.
+Note, the order of values in a set may not be the order the values are presented during looping.
+
+The range character, ©'~'©, is decorated on the left and right to control how the set values are presented in the loop body.
+The range character can be prefixed with ©'+'© or ©'-'© indicating the \emph{direction} the range is scanned, \ie from left to right (ascending) or right to left (descending).
+Ascending stepping uses operator \Indexc{+=};
+descending stepping uses operator \Indexc{-=}.
+If there is no prefix character, it defaults to ©'+'©.
+\begin{cfa}
+-8 ®§\Sp§®~ -2							§\C{// ascending, no prefix}§
+0 ®+®~ 5								§\C{// ascending, prefix}§
+-3 ®-®~ 3								§\C{// descending}§
+\end{cfa}
+For descending iteration, the ©L© and ©H© values are \emph{implicitly} switched, and the increment/decrement for ©S© is toggled.
+When changing the iteration direction, this form is faster and safer, \ie the direction prefix can be added/removed without changing existing (correct) program text.
+\R{Warning}: reversing the range endpoints for descending order results in an empty set.
+\begin{cfa}
+for ( i; ®10 -~ 1® )					§{\C{// WRONG descending range!}§
+\end{cfa}
+
+Because C uses zero origin, most loops iterate from 0 to $N - 1$.
+Hence, when scanning a range during iteration, the last value is dropped, \eg ©0 ~ 5© is ©0, 1, 2, 3, 4©, an exclusive range, [©L©,©H©\R{)}.
+To obtain \emph{all} the values in the range, the range character is postfixed with ©'='©, \eg ©0 ~= 5© is ©0, 1, 2, 3, 4, 5©, an inclusive range, [©L©,©H©\R{]}.
+\index{\~}\index{ascending exclusive range}
+\index{\~=}\index{ascending inclusive range}
+\index{-\~}\index{descending exclusive range}
+\index{-\~=}\index{descending inclusive range}
+
+©for© control is formalized by the following regular expression:
+\begin{cquote}
+[ ©L© ]\ \ [ ©+©\ \ |\ \ ©-© ]\ \ \R{©~©}\ \ [ ©=© ]\ \ ©H©\ \ [ ©~© ©S© ]
+\end{cquote}
+where ©[©\,©]© denotes optional and ©|© denotes alternative.
+That is, the optional low set value, the optional scan direction (ascending/descending), the (possibly) required range character, the optional include last-scan value, the required high set value, and the optional range character and step value.
+\R{Warning}: the regular expression allows the form ©~H©, but this syntax has a preexisting meaning in C: complement the bits of ©H©, \eg ©for ( ~5 )© meaning ©for ( -6 )©, as ©-6© is the complement of ©5©.
+This anomaly is unlikely to cause problems because programers will write the shorter ©for ( 5 )©.
+
+The previous ©for© loops have an anonymous loop index in which the range iteration is computed.
+To access the value of the range iteration in the loop body, a \Index{loop index} is specified before the range.
+\begin{cfa}
+for ( ®int i;® 0 ~ 10 ~ 2 ) { ... ®i® ... }	§\C{// loop index available in loop body}§
+\end{cfa}
+Hence, unlike the 3 components in the C ©for©-control, there are only two components in the \CFA ©for©-control: the optional index variable and the range.
+The index type is optional (like \CC ©auto©), where the type is normally inferred from the low value ©L© because it initializes the index (the type of ©H© can be different from ©L©).
+When ©L© is omitted, the type of the required high value ©H© is used, as both ©L© and ©H© are the same type in this case.
+\begin{cfa}
+for ( i; ®1.5® ~ 5 )					§\C{// typeof(1.5) i; 1.5 is low value}§
+for ( i; ®5.5® )						§\C{// typeof(5.5) i; 5.5 is high value}§
+\end{cfa}
+
+The following examples illustrate common \CFA ©for©-control combinations, with the C counter-part in the comment.
+\begin{itemize}[itemsep=0pt]
+\item
+©H© is implicit ascending exclusive range [0,©H©\R{)}.
+\begin{cfa}
+for ( ®5® )								§\C{// for ( typeof(5) i; i < 5; i += 1 )}§
+\end{cfa}
+\item
+©~=© ©H© is implicit ascending inclusive range [0,©H©\R{]}.
+\begin{cfa}
+for ( ®~=® 5 )							§\C{// for ( typeof(5) i; i <= 5; i += 1 )}§
+\end{cfa}
+\item
+©L© ©~©\index{~@©~©} ©H© is explicit ascending exclusive range [©L©,©H©\R{)}.
+\begin{cfa}
+for ( 1 ®~® 5 )							§\C{// for ( typeof(1) i = 1; i < 5; i += 1 )}§
+\end{cfa}
+\item
+©L© ©~=©\index{~=@©~=©} ©H© is explicit ascending inclusive range [©L©,©H©\R{]}.
+\begin{cfa}
+for ( 1 ®~=® 5 )						§\C{// for ( typeof(1) i = 1; i <= 5; i += 1 )}§
+\end{cfa}
+\item
+©L© ©-~©\index{-~@©-~©} ©H© is explicit descending exclusive range \R{(}©H©,©L©], where ©L© and ©H© are implicitly interchanged to make the range descending.
+\begin{cfa}
+for ( 1 ®-~® 5 )						§\C{// for ( typeof(1) i = 5; i > 0; i -= 1 )}§
+\end{cfa}
+\item
+©L© ©-~=©\index{-~=@©-~=©} ©H© is explicit descending inclusive range \R{[}©H©,©L©], where ©L© and ©H© are implicitly interchanged to make the range descending.
+\begin{cfa}
+for ( 1 ®-~=® 5 )						§\C{// for ( typeof(1) i = 5; i >= 0; i -= 1 )}§
+\end{cfa}
+\end{itemize}
+
+There are situations when the ©for©-control actions need to be moved into the loop body, \eg a mid-loop exit does not need an iteration-completion test in the ©for© control.
+The character ©'@'© indicates that a specific ©for©-control action is ignored, \ie generates no code.
+\begin{cfa}
+for ( i; ®@® -~ 10 )					§\C{// for ( typeof(10) i = 10; \R{/*empty*/}; i -= 1 )}§
+for ( i; 1 ~ ®@® ~ 2 )					§\C{// for ( typeof(1) i = 1; \R{/* empty */}; i += 2 )}§
+for ( i; 1 ~ 10 ~ ®@® )					§\C{// for ( typeof(1) i = 1; i < 10; \R{/* empty */} )}§
+for ( i; 1 ~ ®@® ~ ®@® )				§\C{// for ( typeof(1) i = 1; \R{/* empty */}; \R{/* empty */} )}§
+\end{cfa}
+\R{Warning}: ©L© \emph{cannot} be elided for the ascending range, \lstinline{@ ~ 5}, nor ©H© for the descending range, \lstinline{1 -~ @}, as the loop index is uninitialized.
+\R{Warning}: ©H© \emph{cannot} be elided in an anonymous loop index, ©1 ~ @©, as there is no index to stop the loop.
+
+There are situations when multiple loop indexes are required.
+The character ©':'© means add another index, where any number of indices may be chained in a single ©for© control.
+\begin{cfa}
+for ( i; 5  ®:®  j; 2 ~ 12 ~ 3 )		§\C{// for ( typeof(i) i = 1, j = 2; \R{i < 5 \&\& j < 12}; i += 1, j += 3 )}§
+for ( i; 5  ®:®  j; 2 ~ @ ~ 3 )			§\C{// for ( typeof(i) i = 1, j = 2; \R{i < 5}; i += 1, j += 3 )}§
+for ( i; 5  ®:®  j; 2.5 ~ @ ~ 3.5 )		§\C{// no C equivalent, without hoisting declaration of floating-point j}§
+\end{cfa}
+\VRef[Figure]{f:LoopControlExamples} shows more complex loop-control examples across all the different options.
 
 \begin{figure}
@@ -1025,5 +1137,5 @@
 for () { sout | "empty"; break; }				§\C[3in]{sout | nl | nlOff;}§
 
-for ( 0 ) { sout | "A"; } sout | "zero";		§\C{sout | nl;}§
+for ( 0 ) { sout | "A"; }						§\C{sout | nl;}§
 for ( 1 ) { sout | "A"; }						§\C{sout | nl;}§
 for ( 10 ) { sout | "A"; }						§\C{sout | nl;}§
@@ -1073,5 +1185,5 @@
 empty
 
-zero
+
 A
 A A A A A A A A A A
@@ -1120,110 +1232,73 @@
 \end{figure}
 
-% for ()  => for ( ;; )
-% for ( 10 - t ) => for ( typeof(10 - t) ? = 0 ; ? < 10 - t; ? += 1 ) // using 0 and 1
-% for ( i ; 10 - t ) => for ( typeof(10 - t) i = 0 ; i < 10 - t; i += 1 ) // using 0 and 1
-% for ( T i ; 10 - t ) => for ( T i = 0 ; i < 10 - t; i += 1 ) // using 0 and 1
-% for ( 3~9 ) => for ( int ? = 3 ; ? < 9; ? += 1 ) // using 1
-% for ( i ; 3~9 ) => for ( int i = 3 ; i < 9; i += 1 ) // using 1
-% for ( T i ; 3~9 ) => for ( T i = 3 ; i < 9; i += 1 ) // using 1
-
-The ©for© control is extended with 4 new loop-control operators, which are not overloadable:
-\begin{description}[itemsep=0pt,parsep=0pt]
-\item
-\Indexc{\~} (tilde) \Index{up-to exclusive range},
-\item
-\Indexc{\~=} (tilde equal) \Index{up-to inclusive range},
-\item
-\Indexc{-\~} (minus tilde) \Index{down-to exclusive range},
-\item
-\Indexc{-\~=} (minus tilde equal) \Index{down-to inclusive range}.
-\end{description}
-
-The ©for© index components, low (L), high (H), and increment (I), are optional.
-If missing:
-\begin{itemize}[itemsep=0pt,parsep=0pt]
-\item
-\Indexc{0} is the implicit low value.
-\item
-\Indexc{1} is the implicit increment value.
-\item
-The up-to range uses operator \Indexc{+=} for increment.
-\item
-The down-to range uses operator \Indexc{-=} for decrement.
-\end{itemize}
-
-If no type is specified for the loop index, it is the type of the high value H (when the low value is implicit) or the low value L.
-\begin{cfa}
-for ( ®5® )								§\C{// typeof(5) anonymous-index; 5 is high value}§
-for ( i; ®1.5® ~ 5.5 )					§\C{// typeof(1.5) i; 1.5 is low value}§
-for ( ®int i®; 0 ~ 10 ~ 2 )				§\C{// int i; type is explicit}§
-\end{cfa}
-
-The following are examples for constructing different for-control:
-\begin{itemize}[itemsep=0pt]
-\item
-H is implicit up-to exclusive range [0,H\R{)}.
-\begin{cfa}
-for ( ®5® )								§\C{// for ( typeof(5) i; i < 5; i += 1 )}§
-\end{cfa}
-\item
-©~=© H is implicit up-to inclusive range [0,H\R{]}.
-\begin{cfa}
-for ( ®~=® 5 )							§\C{// for ( typeof(5) i; i <= 5; i += 1 )}§
-\end{cfa}
-\item
-L ©~©\index{~@©~©} H is explicit up-to exclusive range [L,H\R{)}.
-\begin{cfa}
-for ( 1 ®~® 5 )							§\C{// for ( typeof(1) i = 1; i < 5; i += 1 )}§
-\end{cfa}
-\item
-L ©~=©\index{~=@©~=©} H is explicit up-to inclusive range [L,H\R{]}.
-\begin{cfa}
-for ( 1 ®~=® 5 )						§\C{// for ( typeof(1) i = 1; i <= 5; i += 1 )}§
-\end{cfa}
-\item
-L ©-~©\index{-~@©-~©} H is explicit down-to exclusive range [H,L\R{)}, where L and H are implicitly interchanged to make the range down-to.
-\begin{cfa}
-for ( 1 ®-~® 5 )						§\C{// for ( typeof(1) i = 5; i > 0; i -= 1 )}§
-\end{cfa}
-\item
-L ©-~=©\index{-~=@©-~=©} H is explicit down-to inclusive range [H,L\R{]}, where L and H are implicitly interchanged to make the range down-to.
-\begin{cfa}
-for ( 1 ®-~=® 5 )						§\C{// for ( typeof(1) i = 5; i >= 0; i -= 1 )}§
-\end{cfa}
-\item
-©@© means put nothing in this field.
-\begin{cfa}
-for ( i; 1 ~ ®@® ~ 2 )					§\C{// for ( typeof(1) i = 1; \R{/* empty */}; i += 2 )}§
-for ( i; 1 ~ 10 ~ ®@® )					§\C{// for ( typeof(1) i = 1; i < 10; \R{/* empty */} )}§
-for ( i; 1 ~ ®@® ~ ®@® )				§\C{// for ( typeof(1) i = 1; /*empty*/; \R{/* empty */} )}§
-\end{cfa}
-L cannot be elided for the up-to range, \lstinline{@ ~ 5}, and H for the down-to range, \lstinline{1 -~ @}, because then the loop index is uninitialized.
-Similarly, the high value cannot be elided is an anonymous loop index (©1 ~ @©), as there is no index to stop the loop.
-\item
-©:© means add another index.
-\begin{cfa}
-for ( i; 5 ®:® j; 2 ~ 12 ~ 3 )			§\C{// for ( typeof(i) i = 1, j = 2; i < 5 \&\& j < 12; i += 1, j += 3 )}§
-\end{cfa}
-\end{itemize}
-\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{// up range}§
-for ( i; 1 -~ 10 )						§{\C{// down range}§
-for ( i; ®10 -~ 1® )					§{\C{// \R{WRONG down range!}}}§
-\end{cfa}
-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.
-
-
-%\subsection{\texorpdfstring{Labelled \protect\lstinline{continue} / \protect\lstinline{break}}{Labelled continue / break}}
-\subsection{\texorpdfstring{Labelled \LstKeywordStyle{continue} / \LstKeywordStyle{break} Statement}{Labelled continue / break Statement}}
-
-C \Indexc{continue} and \Indexc{break} statements are restricted to one level of nesting for a particular control structure.
-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}, as in Java.
-For both ©continue© and ©break©, the target label must be directly associated with a \Indexc{for}, \Indexc{while} or \Indexc{do} statement;
-for ©break©, the target label can also be associated with a \Indexc{switch}, \Indexc{if} or compound (©{}©) statement.
-\VRef[Figure]{f:MultiLevelExit} shows a comparison between labelled ©continue© and ©break© and the corresponding C equivalent using ©goto© and labels.
-The innermost loop has 8 exit points, which cause continuation or termination of one or more of the 7 \Index{nested control-structure}s.
+Finally, any type that satisfies the ©Iterate© trait can be used with ©for© control.
+\begin{cfa}
+forall( T ) trait Iterate {
+	void ?{}( T & t, zero_t );
+	int ?<?( T t1, T t2 );
+	int ?<=?( T t1, T t2 );
+	int ?>?( T t1, T t2 );
+	int ?>=?( T t1, T t2 );
+	T ?+=?( T & t1, T t2 );
+	T ?+=?( T & t, one_t );
+	T ?-=?( T & t1, T t2 );
+	T ?-=?( T & t, one_t );
+}
+\end{cfa}
+\VRef[Figure]{f:ForControlStructureType} shows an example of a structure using ©for© control.
+Note, the use of ©(S){0}© when implicitly setting the loop-index type, because using 0 incorrect declares the index to ©int© rather than ©S©.
+
+\begin{figure}
+\begin{tabular}{@{}l@{\hspace{5pt}}l@{}}
+\begin{cfa}
+struct S { int i, j; };
+void ?{}( S & s, int i = 0, int j = 0 ) { s.[i, j] = [i, j]; }
+void ?{}( S & s, zero_t ) { s.[i, j] = 0; }
+int ?<?( S t1, S t2 ) { return t1.i < t2.i && t1.j < t2.j; }
+int ?<=?( S t1, S t2 ) { return t1.i <= t2.i && t1.j <= t2.j; }
+int ?>?( S t1, S t2 ) { return t1.i > t2.i && t1.j > t2.j; }
+int ?>=?( S t1, S t2 ) { return t1.i >= t2.i && t1.j >= t2.j; }
+S ?+=?( S & t1, S t2 ) { t1.i += t2.i; t1.j += t2.j; return t1; }
+S ?+=?( S & t, one_t ) { t.i += 1; t.j += 1; return t; }
+S ?-=?( S & t1, S t2 ) { t1.i -= t2.i; t1.j -= t2.j; return t1; }
+S ?-=?( S & t, one_t ) { t.i -= 1; t.j -= 1; return t; }
+ofstream & ?|?( ofstream & os, S s ) {
+	return os | "(" | s.i | s.j | ")";
+}
+void & ?|?( ofstream & os, S s ) {
+	(ofstream &)(os | s); ends( os );
+}
+
+
+
+\end{cfa}
+&
+\begin{cfa}
+int main() {
+	for ( S i = 0; i < (S){10,10}; i += 1 ) { sout | i; } sout | "A" | nl; // C
+	for ( S i; 0 ~ (S){10,10} ) { sout | i; } sout | "B" | nl; // CFA
+	for ( i; (S){10,10} ) { sout | i; } sout | "C" | nl;
+	for ( i; (S){0} ~ (S){10,10} ) { sout | i; } sout | "D" | nl;
+	for ( i; (S){0} ~= (S){10,10} ) { sout | i; } sout | "E" | nl;
+	for ( i; (S){0} ~= (S){10,10} ~ (S){2} ) { sout | i; } sout | "F" | nl;
+	for ( i; (S){0} -~  (S){10,10} ) { sout | i; } sout | "G" | nl;
+	for ( i; (S){0} -~= (S){10,10} ) { sout | i; } sout | "H" | nl;
+	for ( i; (S){0} -~= (S){10,10} ~ (S){2,1} ) { sout | i; } sout | "I" | nl;
+}
+(0 0) (1 1) (2 2) (3 3) (4 4) (5 5) (6 6) (7 7) (8 8) (9 9) A
+(0 0) (1 1) (2 2) (3 3) (4 4) (5 5) (6 6) (7 7) (8 8) (9 9) B
+(0 0) (1 1) (2 2) (3 3) (4 4) (5 5) (6 6) (7 7) (8 8) (9 9) C
+(0 0) (1 1) (2 2) (3 3) (4 4) (5 5) (6 6) (7 7) (8 8) (9 9) D
+(0 0) (1 1) (2 2) (3 3) (4 4) (5 5) (6 6) (7 7) (8 8) (9 9) (10 10) E
+(0 0) (2 0) (4 0) (6 0) (8 0) (10 0) F
+(10 10) (9 9) (8 8) (7 7) (6 6) (5 5) (4 4) (3 3) (2 2) (1 1) G
+(10 10) (9 9) (8 8) (7 7) (6 6) (5 5) (4 4) (3 3) (2 2) (1 1) (0 0) H
+(10 10) (8 9) (6 8) (4 7) (2 6) (0 5) I
+\end{cfa}
+\end{tabular}
+\caption{For Control with Structure Type}
+\label{f:ForControlStructureType}
+\end{figure}
+
 
 \begin{figure}
@@ -1297,4 +1372,16 @@
 \end{figure}
 
+
+%\subsection{\texorpdfstring{Labelled \protect\lstinline{continue} / \protect\lstinline{break}}{Labelled continue / break}}
+\subsection{\texorpdfstring{Labelled \LstKeywordStyle{continue} / \LstKeywordStyle{break} Statement}{Labelled continue / break Statement}}
+
+C \Indexc{continue} and \Indexc{break} statements are restricted to one level of nesting for a particular control structure.
+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}, as in Java.
+For both ©continue© and ©break©, the target label must be directly associated with a \Indexc{for}, \Indexc{while} or \Indexc{do} statement;
+for ©break©, the target label can also be associated with a \Indexc{switch}, \Indexc{if} or compound (©{}©) statement.
+\VRef[Figure]{f:MultiLevelExit} shows a comparison between labelled ©continue© and ©break© and the corresponding C equivalent using ©goto© and labels.
+The innermost loop has 8 exit points, which cause continuation or termination of one or more of the 7 \Index{nested control-structure}s.
+
 Both labelled \Indexc{continue} and \Indexc{break} are a \Indexc{goto}\index{goto@©goto©!restricted} restricted in the following ways:
 \begin{itemize}
@@ -3103,10 +3190,10 @@
 Similarly, if the argument is an expression, it must be parenthesized, \eg ©(i + 3)`h©, or only the last operand of the expression is the argument, \eg ©i + (3`h)©.
 
-\VRef[Figure]{f:UnitsComparison} shows a common usage for postfix functions: converting basic literals into user literals.
+\VRef[Figure]{f:UnitsComparison} shows a common example for postfix functions: converting basic literals into user literals.
 \see*{\VRef{s:DynamicStorageManagement} for other uses for postfix functions.}
-The \CFA example (left) stores a mass in units of stones (1 stone = 14 lb or 6.35 kg) and provides an addition operator (imagine a full set of arithmetic operators).
+The \CFA example (left) stores a mass in units of stones (1 stone = 14 lb or 6.35 kg) and provides an addition operator ©?+?© (imagine a full set of arithmetic operators).
+The arithmetic operators manipulate stones and the postfix operations convert to/from different units.
 The three postfixing function names ©st©, ©lb©, and ©kg©, represent units stones, pounds, and kilograms, respectively.
 Each name has two forms that bidirectional convert: a value of a specified unit to stones, \eg ©w = 14`lb© $\Rightarrow$ ©w == 1© stone or a ©Weight© from stones back to specific units, \eg ©w`lb© (1 stone) to ©14©.
-All arithmetic operations manipulate stones and the postfix operations convert to the different units.
 A similar group of postfix functions provide user constants for converting time units into nanoseconds, which is the basic time unit, \eg ©ns©, ©us©, ©ms©, ©s©, ©m©, ©h©, ©d©, and ©w©, for nanosecond, microsecond, millisecond, second, minute, hour, day, and week, respectively.
 (Note, month is not a fixed period of time nor is year because of leap years.)
@@ -3209,7 +3296,7 @@
 
 The \CC example (right) provides a \emph{restricted} capability via user literals.
-The \lstinline[language=C++]{operator ""} only takes a constant argument (\ie no variable argument), and the constant type must be the highest-level constant-type, \eg ©long double© for all floating-point constants.
+The \lstinline[language=C++]{operator""} only takes a constant argument (\ie no variable as an argument), and the constant type must be the highest-level constant-type, \eg ©long double© for all floating-point constants.
 As well, there is no constant conversion, \ie ©int© to ©double© constants, so integral constants are handled by a separate set of routines, with maximal integral type ©unsigned long long int©.
-Finally, there is no mechanism to use this syntax for a bidirectional conversion because \lstinline[language=C++]{operator ""} does not accept variable arguments.
+Finally, there is no mechanism to use this syntax for a bidirectional conversion because \lstinline[language=C++]{operator""} only accepts a constant argument.
 
 
@@ -5069,5 +5156,5 @@
 
 \begin{comment}
-#include <fstream>
+#include <fstream.hfa>
 #include <string.h>										// strcpy
 
@@ -6330,5 +6417,5 @@
 \begin{figure}
 \begin{cfa}
-#include <fstream>
+#include <fstream.hfa>
 #include <kernel>
 #include <stdlib>
@@ -9826,4 +9913,23 @@
 A contrary analysis:  https://hackaday.com/2024/02/29/the-white-house-memory-safety-appeal-is-a-security-red-herring/
 
+
+From: Ian Fox <ianfox97@gmail.com>
+Date: Fri, 10 May 2024 22:11:41 +0200
+Subject: Article on C and memory safety
+To: pabuhr@uwaterloo.ca
+
+Hi Dr. Buhr!
+
+I came across this
+<https://crashoverride.com/blog/c-isnt-a-hangover-rust-isnt-a-hangover-cure>
+article the other day which I thought made some excellent points, and it
+reminded me of your C forall project (especially with regards to the part
+about being able to opt in incrementally to the safety features while
+rewriting a codebase) so I figured you might enjoy it if you hadn't seen it
+already.
+
+All the best!
+Ian
+
 % Local Variables: %
 % tab-width: 4 %
