Index: doc/papers/general/Paper.tex
===================================================================
--- doc/papers/general/Paper.tex	(revision c8ad5d9ee9d1ad9027a536667adcb82740622d91)
+++ doc/papers/general/Paper.tex	(revision ac4dad218855fd49df19e14a62c1a2fc4f908307)
@@ -74,4 +74,5 @@
 \setlength{\gcolumnposn}{3.5in}
 \setlength{\columnposn}{\gcolumnposn}
+
 \newcommand{\C}[2][\@empty]{\ifx#1\@empty\else\global\setlength{\columnposn}{#1}\global\columnposn=\columnposn\fi\hfill\makebox[\textwidth-\columnposn][l]{\lst@basicstyle{\LstCommentStyle{#2}}}}
 \newcommand{\CRT}{\global\columnposn=\gcolumnposn}
@@ -191,5 +192,4 @@
 This installation base and the programmers producing it represent a massive software-engineering investment spanning decades and likely to continue for decades more.
 Nevertheless, C, first standardized over thirty years ago, lacks many features that make programming in more modern languages safer and more productive.
-
 The goal of the \CFA project is to create an extension of C that provides modern safety and productivity features while still ensuring strong backwards compatibility with C and its programmers.
 Prior projects have attempted similar goals but failed to honour C programming-style; for instance, adding object-oriented or functional programming with garbage collection is a non-starter for many C developers.
@@ -209,5 +209,4 @@
 
 \section{Introduction}
-
 The C programming language is a foundational technology for modern computing with millions of lines of code implementing everything from commercial operating-systems to hobby projects.
 This installation base and the programmers producing it represent a massive software-engineering investment spanning decades and likely to continue for decades more.
@@ -238,5 +237,5 @@
 \CC is used similarly, but has the disadvantages of multiple legacy design-choices that cannot be updated and active divergence of the language model from C, requiring significant effort and training to incrementally add \CC to a C-based project.
 
-\CFA is currently implemented as a source-to-source translator from \CFA to the gcc-dialect of C~\cite{GCCExtensions}, allowing it to leverage the portability and code optimizations provided by gcc, meeting goals (1)--(3).
+\CFA is an \emph{open-source} project implemented as an source-to-source translator from \CFA to the gcc-dialect of C~\cite{GCCExtensions}, allowing it to leverage the portability and code optimizations provided by gcc, meeting goals (1)--(3).
 Ultimately, a compiler is necessary for advanced features and optimal performance.
 All features discussed in this paper are working, unless otherwise stated as under construction.
@@ -266,8 +265,7 @@
 Code generation for these overloaded functions and variables is implemented by the usual approach of mangling the identifier names to include a representation of their type, while \CFA decides which overload to apply based on the same ``usual arithmetic conversions'' used in C to disambiguate operator overloads.
 As an example:
-
-\begin{cfa}
-int max = 2147483647;					$\C[4in]{// (1)}$
-double max = 1.7976931348623157E+308;	$\C{// (2)}$
+\begin{cfa}
+int max = 2147483647;						$\C[4in]{// (1)}$
+double max = 1.7976931348623157E+308;		$\C{// (2)}$
 int max( int a, int b ) { return a < b ? b : a; }  $\C{// (3)}$
 double max( double a, double b ) { return a < b ? b : a; }  $\C{// (4)}\CRT$
@@ -329,5 +327,6 @@
 A simple example is leveraging the existing type-unsafe (@void *@) C @bsearch@ to binary search a sorted float array:
 \begin{cfa}
-void * bsearch( const void * key, const void * base, size_t nmemb, size_t size, int (* compar)( const void *, const void * ));
+void * bsearch( const void * key, const void * base, size_t nmemb, size_t size,
+				int (* compar)( const void *, const void * ));
 int comp( const void * t1, const void * t2 ) {
 	 return *(double *)t1 < *(double *)t2 ? -1 : *(double *)t2 < *(double *)t1 ? 1 : 0;
@@ -377,10 +376,12 @@
 Hence, programmers can easily form local environments, adding and modifying appropriate functions, to maximize reuse of other existing functions and types.
 
-Under construction is a mechanism to distribute @forall@ over routines/types, where each block declaration is prefixed with the initial @forall@ clause significantly reducing duplication (see @stack@ examples in Section~\ref{sec:eval}):
-\begin{cfa}
-forall( otype `T` ) {							$\C{// forall block}$
+To reducing duplication, it is possible to distribute a group of @forall@ (and storage-class qualifiers) over functions/types, so each block declaration is prefixed by the group (see example in Appendix~\ref{s:CforallStack}).
+\begin{cfa}
+forall( otype `T` ) {							$\C{// distribution block, add forall qualifier to declarations}$
 	struct stack { stack_node(`T`) * head; };	$\C{// generic type}$
-	void push( stack(`T`) & s, `T` value ) ...	$\C{// generic operations}$
-	T pop( stack(`T`) & s ) ...
+	inline {									$\C{// nested distribution block, add forall/inline to declarations}$
+		void push( stack(`T`) & s, `T` value ) ...	$\C{// generic operations}$
+		T pop( stack(`T`) & s ) ...
+	}
 }
 \end{cfa}
@@ -390,18 +391,29 @@
 
 \CFA provides \newterm{traits} to name a group of type assertions, where the trait name allows specifying the same set of assertions in multiple locations, preventing repetition mistakes at each function declaration:
-\begin{cfa}
-trait `summable`( otype T ) {
-	void ?{}( T *, zero_t );				$\C{// constructor from 0 literal}$
-	T ?+?( T, T );							$\C{// assortment of additions}$
-	T ?+=?( T *, T );
-	T ++?( T * );
-	T ?++( T * );
+\begin{cquote}
+\lstDeleteShortInline@%
+\begin{tabular}{@{}l@{\hspace{\parindentlnth}}|@{\hspace{\parindentlnth}}l@{}}
+\begin{cfa}
+trait `sumable`( otype T ) {
+	void `?{}`( T &, zero_t ); // 0 literal constructor
+	T ?+?( T, T );			 // assortment of additions
+	T `?+=?`( T &, T );
+	T ++?( T & );
+	T ?++( T & );
 };
-forall( otype T `| summable( T )` ) T sum( T a[$\,$], size_t size ) {$\C{// use trait}$
-	`T` total = { `0` };					$\C{// instantiate T from 0 by calling its constructor}$
-	for ( unsigned int i = 0; i < size; i += 1 ) total `+=` a[i]; $\C{// select appropriate +}$
+\end{cfa}
+&
+\begin{cfa}
+forall( otype T `| sumable( T )` ) // use trait
+T sum( T a[$\,$], size_t size ) {
+	`T` total = { `0` };  // initialize by 0 constructor
+	for ( size_t i = 0; i < size; i += 1 )
+		total `+=` a[i]; // select appropriate +
 	return total;
 }
 \end{cfa}
+\end{tabular}
+\lstMakeShortInline@%
+\end{cquote}
 
 In fact, the set of @summable@ trait operators is incomplete, as it is missing assignment for type @T@, but @otype@ is syntactic sugar for the following implicit trait:
@@ -466,20 +478,29 @@
 
 A generic type can be declared by placing a @forall@ specifier on a @struct@ or @union@ declaration, and instantiated using a parenthesized list of types after the type name:
+\begin{cquote}
+\lstDeleteShortInline@%
+\begin{tabular}{@{}l@{\hspace{2\parindentlnth}}l@{}}
 \begin{cfa}
 forall( otype R, otype S ) struct pair {
-	R first;
-	S second;
+	R first;	S second;
 };
-forall( otype T ) T value( pair( const char *, T ) p ) { return p.second; } $\C{// dynamic}$
-forall( dtype F, otype T ) T value( pair( F *, T * ) p ) { return *p.second; } $\C{// dtype-static (concrete)}$
-
-pair( const char *, int ) p = { "magic", 42 }; $\C{// concrete}$
+`forall( otype T )` // dynamic
+T value( pair(const char *, T) p ) { return p.second; }
+`forall( dtype F, otype T )` // dtype-static (concrete)
+T value( pair(F *, T * ) p) { return *p.second; }
+\end{cfa}
+&
+\begin{cfa}
+pair(const char *, int) p = {"magic", 42}; // concrete
 int i = value( p );
-pair( void *, int * ) q = { 0, &p.second }; $\C{// concrete}$
+pair(void *, int *) q = { 0, &p.second }; // concrete
 i = value( q );
 double d = 1.0;
-pair( double *, double * ) r = { &d, &d }; $\C{// concrete}$
+pair(double *, double *) r = { &d, &d }; // concrete
 d = value( r );
 \end{cfa}
+\end{tabular}
+\lstMakeShortInline@%
+\end{cquote}
 
 \CFA classifies generic types as either \newterm{concrete} or \newterm{dynamic}.
@@ -568,18 +589,27 @@
 Another useful pattern enabled by reused dtype-static type instantiations is zero-cost \newterm{tag-structures}.
 Sometimes information is only used for type-checking and can be omitted at runtime, \eg:
+\begin{cquote}
+\lstDeleteShortInline@%
+\begin{tabular}{@{}l@{\hspace{2\parindentlnth}}l@{}}
 \begin{cfa}
 forall( dtype Unit ) struct scalar { unsigned long value; };
 struct metres {};
 struct litres {};
-
 forall( dtype U ) scalar(U) ?+?( scalar(U) a, scalar(U) b ) {
 	return (scalar(U)){ a.value + b.value };
 }
-scalar(metres) half_marathon = { 21_093 };
-scalar(litres) swimming_pool = { 2_500_000 };
-scalar(metres) marathon = half_marathon + half_marathon;
-scalar(litres) two_pools = swimming_pool + swimming_pool;
-marathon + swimming_pool;					$\C{// compilation ERROR}$
-\end{cfa}
+\end{cfa}
+&
+\begin{cfa}
+scalar(metres) half_marathon = { 21_098 };
+scalar(litres) pool = { 2_500_000 };
+scalar(metres) marathon = half_marathon +
+							half_marathon;
+scalar(litres) two_pools = pool + pool;
+`marathon + pool;`	// compilation ERROR
+\end{cfa}
+\end{tabular}
+\lstMakeShortInline@%
+\end{cquote}
 @scalar@ is a dtype-static type, so all uses have a single structure definition, containing @unsigned long@, and can share the same implementations of common functions like @?+?@.
 These implementations may even be separately compiled, unlike \CC template functions.
@@ -1189,13 +1219,9 @@
 		`LIF:` if ( ... ) {
 			`LF:` for ( ... ) {
-				`LW:` while ( ... ) {
-					... break `LC`; ...
-					... break `LS`; ...
-					... break `LIF`; ...
-					... continue `LF;` ...
-					... break `LF`; ...
-					... continue `LW`; ...
-					... break `LW`; ...
-				} // while
+				... break `LC`; ...
+				... break `LS`; ...
+				... break `LIF`; ...
+				... continue `LF;` ...
+				... break `LF`; ...
 			} // for
 		} else {
@@ -1213,13 +1239,9 @@
 		if ( ... ) {
 			for ( ... ) {
-				while ( ... ) {
-					... goto `LC`; ...
-					... goto `LS`; ...
-					... goto `LIF`; ...
-					... goto `LFC`; ...
-					... goto `LFB`; ...
-					... goto `LWC`; ...
-					... goto `LWB`; ...
-				  `LWC`: ; } `LWB:` ;
+				... goto `LC`; ...
+				... goto `LS`; ...
+				... goto `LIF`; ...
+				... goto `LFC`; ...
+				... goto `LFB`; ...
 			  `LFC:` ; } `LFB:` ;
 		} else {
@@ -1243,12 +1265,8 @@
 // continue loop
 // terminate loop
-// continue loop
-// terminate loop
 
 
 
 // terminate if
-
-
 
 \end{cfa}
@@ -1411,55 +1429,32 @@
 \label{s:WithStatement}
 
-Grouping heterogeneous data into \newterm{aggregate}s (structure/union) is a common programming practice, and an aggregate can be further organized into more complex structures, such as arrays and containers:
-\begin{cfa}
-struct S {									$\C{// aggregate}$
-	char c;									$\C{// fields}$
-	int i;
-	double d;
-};
-S s, as[10];
-\end{cfa}
-However, functions manipulating aggregates must repeat the aggregate name to access its containing fields:
-\begin{cfa}
-void f( S s ) {
-	`s.`c; `s.`i; `s.`d;					$\C{// access containing fields}$
-}
-\end{cfa}
-which extends to multiple levels of qualification for nested aggregates.
-A similar situation occurs in object-oriented programming, \eg \CC:
-\begin{C++}
-struct S {
-	char c;									$\C{// fields}$
-	int i;
-	double d;
-	void f() {								$\C{// implicit ``this'' aggregate}$
-		`this->`c; `this->`i; `this->`d;	$\C{// access containing fields}$
-	}
-}
-\end{C++}
-Object-oriented nesting of member functions in a \lstinline[language=C++]@class/struct@ allows eliding \lstinline[language=C++]@this->@ because of lexical scoping.
-However, for other aggregate parameters, qualification is necessary:
-\begin{cfa}
+Heterogeneous data is often aggregated into a structure/union.
+To reduce syntactic noise, \CFA provides a @with@ statement (see Pascal~\cite[\S~4.F]{Pascal}) to elide aggregate field-qualification by opening a scope containing the field identifiers.
+\begin{cquote}
+\vspace*{-\baselineskip}%???
+\lstDeleteShortInline@%
+\begin{cfa}
+struct S { char c; int i; double d; };
 struct T { double m, n; };
-int S::f( T & t ) {							$\C{// multiple aggregate parameters}$
-	c; i; d;								$\C{\color{red}// this--{\textgreater}.c, this--{\textgreater}.i, this--{\textgreater}.d}$
-	`t.`m; `t.`n;							$\C{// must qualify}$
-}
-\end{cfa}
-
-To simplify the programmer experience, \CFA provides a @with@ statement (see Pascal~\cite[\S~4.F]{Pascal}) to elide aggregate qualification to fields by opening a scope containing the field identifiers.
-Hence, the qualified fields become variables with the side-effect that it is easier to optimizing field references in a block.
-\begin{cfa}
-void f( S & this ) `with ( this )` {		$\C{// with statement}$
-	c; i; d;								$\C{\color{red}// this.c, this.i, this.d}$
-}
-\end{cfa}
-with the generality of opening multiple aggregate-parameters:
-\begin{cfa}
-void f( S & s, T & t ) `with ( s, t )` {		$\C{// multiple aggregate parameters}$
-	c; i; d;								$\C{\color{red}// s.c, s.i, s.d}$
-	m; n;									$\C{\color{red}// t.m, t.n}$
-}
-\end{cfa}
+// multiple aggregate parameters
+\end{cfa}
+\begin{tabular}{@{}l@{\hspace{\parindentlnth}}|@{\hspace{\parindentlnth}}l@{}}
+\begin{cfa}
+void f( S & s, T & t ) {
+	`s.`c; `s.`i; `s.`d;
+	`t.`m; `t.`n;
+}
+\end{cfa}
+&
+\begin{cfa}
+void f( S & s, T & t ) `with ( s, t )` {
+	c; i; d;		// no qualification
+	m; n;
+}
+\end{cfa}
+\end{tabular}
+\lstMakeShortInline@%
+\end{cquote}
+Object-oriented programming languages only provide implicit qualification for the receiver.
 
 In detail, the @with@ statement has the form:
@@ -1474,6 +1469,5 @@
 The object is the implicit qualifier for the open structure-fields.
 
-All expressions in the expression list are open in parallel within the compound statement.
-This semantic is different from Pascal, which nests the openings from left to right.
+All expressions in the expression list are open in parallel within the compound statement, which is different from Pascal, which nests the openings from left to right.
 The difference between parallel and nesting occurs for fields with the same name and type:
 \begin{cfa}
@@ -2261,5 +2255,7 @@
 \begin{cfa}
 MIN
+
 MAX
+
 PI
 E
@@ -2267,6 +2263,8 @@
 &
 \begin{cfa}
-SCHAR_MIN, CHAR_MIN, SHRT_MIN, INT_MIN, LONG_MIN, LLONG_MIN, FLT_MIN, DBL_MIN, LDBL_MIN
-SCHAR_MAX, UCHAR_MAX, SHRT_MAX, INT_MAX, LONG_MAX, LLONG_MAX, FLT_MAX, DBL_MAX, LDBL_MAX
+SCHAR_MIN, CHAR_MIN, SHRT_MIN, INT_MIN, LONG_MIN,
+	LLONG_MIN, FLT_MIN, DBL_MIN, LDBL_MIN
+SCHAR_MAX, UCHAR_MAX, SHRT_MAX, INT_MAX, LONG_MAX,
+	LLONG_MAX, FLT_MAX, DBL_MAX, LDBL_MAX
 M_PI, M_PIl
 M_E, M_El
@@ -2441,6 +2439,6 @@
 ip = (int *)malloc( sizeof( int ) ); memset( ip, fill, dim * sizeof( int ) );
 ip = (int *)realloc( ip, 2 * dim * sizeof( int ) );
-ip = (int *)realloc( ip, 4 * dim * sizeof( int ) ); memset( ip, fill, 4 * dim * sizeof( int ) );
-
+ip = (int *)realloc( ip, 4 * dim * sizeof( int ) );
+			memset( ip, fill, 4 * dim * sizeof( int ) );
 ip = memalign( 16, sizeof( int ) );
 ip = memalign( 16, sizeof( int ) ); memset( ip, fill, sizeof( int ) );
@@ -2607,5 +2605,5 @@
 Though \CFA provides significant added functionality over C, these features have a low runtime penalty.
 In fact, \CFA's features for generic programming can enable faster runtime execution than idiomatic @void *@-based C code.
-This claim is demonstrated through a set of generic-code-based micro-benchmarks in C, \CFA, and \CC (see stack implementations in Appendix~\ref{sec:BenchmarkStackImplementation}).
+This claim is demonstrated through a set of generic-code-based micro-benchmarks in C, \CFA, and \CC (see stack implementations in Appendix~\ref{sec:BenchmarkStackImplementations}).
 Since all these languages share a subset essentially comprising standard C, maximal-performance benchmarks should show little runtime variance, differing only in length and clarity of source code.
 A more illustrative comparison measures the costs of idiomatic usage of each language's features.
@@ -2824,38 +2822,51 @@
 \appendix
 
-\section{Benchmark Stack Implementation}
-\label{sec:BenchmarkStackImplementation}
-
-Throughout, @/***/@ designates a counted redundant type annotation; code reformatted for brevity.
-
-\smallskip\noindent
-C
-\begin{cfa}[xleftmargin=2\parindentlnth,aboveskip=0pt,belowskip=0pt]
-struct stack_node {
+\section{Benchmark Stack Implementations}
+\label{sec:BenchmarkStackImplementations}
+
+Throughout, @/***/@ designates a counted redundant type annotation; code reformatted slightly for brevity.
+
+
+\subsection{C}
+
+\begin{flushleft}
+\lstDeleteShortInline@%
+\begin{tabular}{@{}l@{\hspace{1.8\parindentlnth}}|@{\hspace{\parindentlnth}}l@{}}
+\begin{cfa}[xleftmargin=0pt,aboveskip=0pt,belowskip=0pt]
+typedef struct node {
 	void * value;
-	struct stack_node * next;
-};
-struct stack { struct stack_node* head; };
-void clear_stack( struct stack * s, void (*free_el)( void * ) ) {
-	for ( struct stack_node * next = s->head; next; ) {
-		struct stack_node * crnt = next;
-		next = crnt->next;
-		free_el( crnt->value );
-		free( crnt );
+	struct node * next;
+} node;
+typedef struct stack {
+	struct node * head;
+} stack;
+void copy_stack( stack * s, const stack * t,
+				void * (*copy)( const void * ) ) {
+	node ** cr = &s->head;
+	for (node * nx = t->head; nx; nx = nx->next) {
+		*cr = malloc( sizeof(node) ); /***/
+		(*cr)->value = copy( nx->value );
+		cr = &(*cr)->next;
+	}
+	*cr = NULL;
+}
+void clear_stack( stack * s, void (* free_el)( void * ) ) {
+	for ( node * nx = s->head; nx; ) {
+		node * cr = nx;
+		nx = cr->next;
+		free_el( cr->value );
+		free( cr );
 	}
 	s->head = NULL;
 }
-struct stack new_stack() { return (struct stack){ NULL }; /***/ }
-void copy_stack( struct stack * s, const struct stack * t, void * (*copy)( const void * ) ) {
-	struct stack_node ** crnt = &s->head;
-	for ( struct stack_node * next = t->head; next; next = next->next ) {
-		*crnt = malloc( sizeof(struct stack_node) ); /***/
-		(*crnt)->value = copy( next->value );
-		crnt = &(*crnt)->next;
-	}
-	*crnt = NULL;
-}
-struct stack * assign_stack( struct stack * s, const struct stack * t, 
-		void * (*copy_el)( const void * ), void (*free_el)( void * ) ) {
+\end{cfa}
+&
+\begin{cfa}[xleftmargin=0pt,aboveskip=0pt,belowskip=0pt]
+stack new_stack() {
+	return (stack){ NULL }; /***/
+}
+stack * assign_stack( stack * s, const stack * t, 
+				void * (*copy_el)( const void * ),
+				void (*free_el)( void * ) ) {
 	if ( s->head == t->head ) return s;
 	clear_stack( s, free_el ); /***/
@@ -2863,12 +2874,14 @@
 	return s;
 }
-_Bool stack_empty( const struct stack * s ) { return s->head == NULL; }
-void push_stack( struct stack * s, void * v ) {
-	struct stack_node * n = malloc( sizeof(struct stack_node) ); /***/
-	*n = (struct stack_node){ v, s->head }; /***/
+_Bool stack_empty( const stack * s ) {
+	 return s->head == NULL;
+}
+void push_stack( stack * s, void * v ) {
+	node * n = malloc(sizeof(node)); /***/
+	*n = (node){ v, s->head }; /***/
 	s->head = n;
 }
-void * pop_stack( struct stack * s ) {
-	struct stack_node * n = s->head;
+void * pop_stack( stack * s ) {
+	node * n = s->head;
 	s->head = n->next;
 	void * v = n->value;
@@ -2877,81 +2890,45 @@
 }
 \end{cfa}
-
-\medskip\noindent
-\CFA
-\begin{cfa}[xleftmargin=2\parindentlnth,aboveskip=0pt,belowskip=0pt]
-forall( otype T ) struct stack_node {
-	T value;
-	stack_node(T) * next;
-};
-forall( otype T ) struct stack { stack_node(T) * head; };
-forall( otype T ) void clear( stack(T) & s ) with( s ) {
-	for ( stack_node(T) * next = head; next; ) {
-		stack_node(T) * crnt = next;
-		next = crnt->next;
-		^(*crnt){};
-		free(crnt);
+\end{tabular}
+\lstMakeShortInline@%
+\end{flushleft}
+
+
+\subsection{\CFA}
+\label{s:CforallStack}
+
+\begin{flushleft}
+\lstDeleteShortInline@%
+\begin{tabular}{@{}l|@{\hspace{\parindentlnth}}l@{}}
+\begin{cfa}[xleftmargin=0pt,aboveskip=0pt,belowskip=0pt]
+forall( otype T ) {
+	struct node {
+		T value;
+		node(T) * next;
+	};
+	struct stack { node(T) * head; };
+	void ?{}( stack(T) & s ) { (s.head){ 0 }; }
+	void ?{}( stack(T) & s, stack(T) t ) {
+		node(T) ** cr = &s.head;
+		for ( node(T) * nx = t.head; nx; nx = nx->next ) {
+			*cr = alloc();
+			((*cr)->value){ nx->value };
+			cr = &(*cr)->next;
+		}
+		*cr = 0;
 	}
-	head = 0;
-}
-forall( otype T ) void ?{}( stack(T) & s ) { (s.head){ 0 }; }
-forall( otype T ) void ?{}( stack(T) & s, stack(T) t ) {
-	stack_node(T) ** crnt = &s.head;
-	for ( stack_node(T) * next = t.head; next; next = next->next ) {
-		*crnt = alloc();
-		((*crnt)->value){ next->value };
-		crnt = &(*crnt)->next;
-	}
-	*crnt = 0;
-}
-forall( otype T ) stack(T) ?=?( stack(T) & s, stack(T) t ) {
-	if ( s.head == t.head ) return s;
-	clear( s );
-	s{ t };
-	return s;
-}
-forall( otype T ) void ^?{}( stack(T) & s) { clear( s ); }
-forall( otype T ) _Bool empty( const stack(T) & s ) { return s.head == 0; }
-forall( otype T ) void push( stack(T) & s, T value ) with( s ) {
-	stack_node(T) * n = alloc();
-	(*n){ value, head };
-	head = n;
-}
-forall( otype T ) T pop( stack(T) & s ) with( s ) {
-	stack_node(T) * n = head;
-	head = n->next;
-	T v = n->value;
-	^(*n){};
-	free( n );
-	return v;
-}
-\end{cfa}
-
-\begin{comment}
-forall( otype T ) {
-	struct stack_node {
-		T value;
-		stack_node(T) * next;
-	};
-	struct stack { stack_node(T) * head; };
 	void clear( stack(T) & s ) with( s ) {
-		for ( stack_node(T) * next = head; next; ) {
-			stack_node(T) * crnt = next;
-			next = crnt->next;
-			^(*crnt){};
-			free(crnt);
+		for ( node(T) * nx = head; nx; ) {
+			node(T) * cr = nx;
+			nx = cr->next;
+			^(*cr){};
+			free(cr);
 		}
 		head = 0;
 	}
-	void ?{}( stack(T) & s ) { (s.head){ 0 }; }
-	void ?{}( stack(T) & s, stack(T) t ) {
-		stack_node(T) ** crnt = &s.head;
-		for ( stack_node(T) * next = t.head; next; next = next->next ) {
-			*crnt = alloc();
-			((*crnt)->value){ next->value };
-			crnt = &(*crnt)->next;
-		}
-		*crnt = 0;
-	}
+\end{cfa}
+&
+\begin{cfa}[xleftmargin=0pt,aboveskip=0pt,belowskip=0pt]
+	void ^?{}( stack(T) & s) { clear( s ); }
 	stack(T) ?=?( stack(T) & s, stack(T) t ) {
 		if ( s.head == t.head ) return s;
@@ -2960,13 +2937,14 @@
 		return s;
 	}
-	void ^?{}( stack(T) & s) { clear( s ); }
-	_Bool empty( const stack(T) & s ) { return s.head == 0; }
+	_Bool empty( const stack(T) & s ) {
+		return s.head == 0;
+	}
 	void push( stack(T) & s, T value ) with( s ) {
-		stack_node(T) * n = alloc();
+		node(T) * n = alloc();
 		(*n){ value, head };
 		head = n;
 	}
 	T pop( stack(T) & s ) with( s ) {
-		stack_node(T) * n = head;
+		node(T) * n = head;
 		head = n->next;
 		T v = n->value;
@@ -2976,36 +2954,48 @@
 	}
 }
-\end{comment}
-
-\medskip\noindent
-\CC
-\begin{cfa}[xleftmargin=2\parindentlnth,aboveskip=0pt,belowskip=0pt]
+
+\end{cfa}
+\end{tabular}
+\lstMakeShortInline@%
+\end{flushleft}
+
+
+\subsection{\CC}
+
+\begin{flushleft}
+\lstDeleteShortInline@%
+\begin{tabular}{@{}l|@{\hspace{\parindentlnth}}l@{}}
+\begin{cfa}[xleftmargin=0pt,aboveskip=0pt,belowskip=0pt]
 template<typename T> struct stack {
 	struct node {
 		T value;
 		node * next;
-		node( const T & v, node * n = nullptr ) : value( v ), next( n ) {}
+		node( const T & v, node * n = nullptr ) :
+			value( v ), next( n ) {}
 	};
 	node * head;
-	stack() : head( nullptr ) {}
-	stack( const stack<T> & o ) { copy( o ); }
+	void copy( const stack<T> & o ) {
+		node ** cr = &head;
+		for ( node * nx = o.head; nx; nx = nx->next ) {
+			*cr = new node{ nx->value }; /***/
+			cr = &(*cr)->next;
+		}
+		*cr = nullptr;
+	}
 	void clear() {
-		for ( node * next = head; next; ) {
-			node * crnt = next;
-			next = crnt->next;
-			delete crnt;
+		for ( node * nx = head; nx; ) {
+			node * cr = nx;
+			nx = cr->next;
+			delete cr;
 		}
 		head = nullptr;
 	}
-	void copy( const stack<T> & o ) {
-		node ** crnt = &head;
-		for ( node * next = o.head; next; next = next->next ) {
-			*crnt = new node{ next->value }; /***/
-			crnt = &(*crnt)->next;
-		}
-		*crnt = nullptr;
-	}
+\end{cfa}
+&
+\begin{cfa}[xleftmargin=0pt,aboveskip=0pt,belowskip=0pt]
+	stack() : head( nullptr ) {}
+	stack( const stack<T> & o ) { copy( o ); }
 	~stack() { clear(); }
-	stack & operator= ( const stack<T> & o ) {
+	stack & operator=( const stack<T> & o ) {
 		if ( this == &o ) return *this;
 		clear();
@@ -3014,5 +3004,7 @@
 	}
 	bool empty() const { return head == nullptr; }
-	void push( const T & value ) { head = new node{ value, head };  /***/ }
+	void push( const T & value ) {
+		head = new node{ value, head };  /***/
+	}
 	T pop() {
 		node * n = head;
@@ -3023,36 +3015,50 @@
 	}
 };
-\end{cfa}
-
-\medskip\noindent
-\CCV
-\begin{cfa}[xleftmargin=2\parindentlnth,aboveskip=0pt,belowskip=0pt]
+
+
+
+\end{cfa}
+\end{tabular}
+\lstMakeShortInline@%
+\end{flushleft}
+
+
+\subsection{\CCV}
+
+\begin{flushleft}
+\lstDeleteShortInline@%
+\begin{tabular}{@{}l|@{\hspace{\parindentlnth}}l@{}}
+\begin{cfa}[xleftmargin=0pt,aboveskip=0pt,belowskip=0pt]
 struct stack {
 	struct node {
 		ptr<object> value;
 		node * next;
-		node( const object & v, node * n = nullptr ) : value( v.new_copy() ), next( n ) {}
+		node( const object & v, node * n = nullptr ) :
+				value( v.new_copy() ), next( n ) {}
 	};
 	node * head;
+	void copy( const stack & o ) {
+		node ** cr = &head;
+		for ( node * nx = o.head; nx; nx = nx->next ) {
+			*cr = new node{ *nx->value }; /***/
+			cr = &(*cr)->next;
+		}
+		*cr = nullptr;
+	}
 	void clear() {
-		for ( node * next = head; next; ) {
-			node * crnt = next;
-			next = crnt->next;
-			delete crnt;
+		for ( node * nx = head; nx; ) {
+			node * cr = nx;
+			nx = cr->next;
+			delete cr;
 		}
 		head = nullptr;
 	}
-	void copy( const stack & o ) {
-		node ** crnt = &head;
-		for ( node * next = o.head; next; next = next->next ) {
-			*crnt = new node{ *next->value }; /***/
-			crnt = &(*crnt)->next;
-		}
-		*crnt = nullptr;
-	}
+\end{cfa}
+&
+\begin{cfa}[xleftmargin=0pt,aboveskip=0pt,belowskip=0pt]
 	stack() : head( nullptr ) {}
 	stack( const stack & o ) { copy( o ); }
 	~stack() { clear(); }
-	stack & operator= ( const stack & o ) {
+	stack & operator=( const stack & o ) {
 		if ( this == &o ) return *this;
 		clear();
@@ -3061,5 +3067,7 @@
 	}
 	bool empty() const { return head == nullptr; }
-	void push( const object & value ) { head = new node{ value, head }; /***/ }
+	void push( const object & value ) {
+		head = new node{ value, head }; /***/
+	}
 	ptr<object> pop() {
 		node * n = head;
@@ -3070,5 +3078,11 @@
 	}
 };
-\end{cfa}
+
+
+
+\end{cfa}
+\end{tabular}
+\lstMakeShortInline@%
+\end{flushleft}
 
 
