Index: doc/papers/general/Paper.tex
===================================================================
--- doc/papers/general/Paper.tex	(revision 10f814274819855875989c6dbf86fcb1e3ddf61d)
+++ doc/papers/general/Paper.tex	(revision 0723a5716bac65785647f12737c8842ed6b525ca)
@@ -1052,8 +1052,8 @@
 \label{s:WithClauseStatement}
 
-Grouping heterogenous data into \newterm{aggregate}s is a common programming practice, and an aggregate can be further organized into more complex structures, such as arrays and containers:
+Grouping heterogenous 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}$
+struct S {									$\C{// aggregate}$
+	char c;									$\C{// fields}$
 	int i;
 	double d;
@@ -1061,8 +1061,8 @@
 S s, as[10];
 \end{cfa}
-However, routines manipulating aggregates have repeition of the aggregate name to access its containing fields:
+However, routines 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}$
+	`s.`c; `s.`i; `s.`d;					$\C{// access containing fields}$
 }
 \end{cfa}
@@ -1070,13 +1070,13 @@
 \begin{C++}
 class C {
-	char c;								$\C{// fields}$
+	char c;									$\C{// fields}$
 	int i;
 	double d;
-	int mem() {							$\C{// implicit "this" parameter}$
-		`this->`c; `this->`i; `this->`d;$\C{// access containing fields}$
+	int mem() {								$\C{// implicit "this" parameter}$
+		`this->`c; `this->`i; `this->`d;	$\C{// access containing fields}$
 	}
 }
 \end{C++}
-Nesting of member routines in a \lstinline[language=C++]@class@ allows eliding \lstinline[language=C++]@this->@ because of nested lexical-scoping.
+Nesting of member routines in a \lstinline[language=C++]@class@ allows eliding \lstinline[language=C++]@this->@ because of lexical scoping.
 
 % In object-oriented programming, there is an implicit first parameter, often names @self@ or @this@, which is elided.
@@ -1088,9 +1088,9 @@
 % \TODO{Fill out section. Be sure to mention arbitrary expressions in with-blocks, recent change driven by Thierry to prioritize field name over parameters.}
 
-\CFA provides a @with@ clause/statement (see Pascal~\cite[\S~4.F]{Pascal}) to elide aggregate qualification to fields by opening a scope containing field identifiers.
-Hence, the qualified fields become variables, and making it easier to optimize field references in a block.
+\CFA provides a @with@ clause/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 s ) `with( s )` {				$\C{// with clause}$
-	c; i; d;							$\C{\color{red}// s.c, s.i, s.d}$
+void f( S s ) `with( s )` {					$\C{// with clause}$
+	c; i; d;								$\C{\color{red}// s.c, s.i, s.d}$
 }
 \end{cfa}
@@ -1098,20 +1098,35 @@
 \begin{cfa}
 int mem( S & this ) `with( this )` {		$\C{// with clause}$
-	c; i; d;							$\C{\color{red}// this.c, this.i, this.d}$
+	c; i; d;								$\C{\color{red}// this.c, this.i, this.d}$
 }
 \end{cfa}
-The key generality over the object-oriented approach is that one aggregate parameter \lstinline[language=C++]@this@ is not treated specially over other aggregate parameters:
+The generality over the object-oriented approach is that multiple aggregate parameters can be opened, not just \lstinline[language=C++]@this@:
 \begin{cfa}
 struct T { double m, n; };
 int mem( 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}$
+	c; i; d;								$\C{\color{red}// s.c, s.i, s.d}$
+	m; n;									$\C{\color{red}// t.m, t.n}$
 }
 \end{cfa}
-The equivalent object-oriented style is:
+The equivalent object-oriented approach is:
 \begin{cfa}
-int S::mem( 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;
+int S::mem( 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}
+
+\begin{cfa}
+struct S { int i, j; } sv;
+with( sv ) {
+	S & sr = sv;
+	with( sr ) {
+		S * sp = &sv;
+		with( *sp ) {
+			i = 3; j = 4;					$\C{\color{red}// sp-{\textgreater}i, sp-{\textgreater}j}$
+		}
+		i = 3; j = 4;						$\C{\color{red}// sr.i, sr.j}$
+	}
+	i = 3; j = 4;							$\C{\color{red}// sv.i, sv.j}$
 }
 \end{cfa}
@@ -1122,7 +1137,7 @@
 	struct S1 { ... } s1;
 	struct S2 { ... } s2;
-	`with( s1 )` {						$\C{// with statement}$
+	`with( s1 )` {							$\C{// with statement}$
 		// access fields of s1 without qualification
-		`with( s2 )` {					$\C{// nesting}$
+		`with( s2 )` {						$\C{// nesting}$
 			// access fields of s1 and s2 without qualification
 		}
@@ -1140,18 +1155,18 @@
 struct T { int i; int k; int m } b, c;
 `with( a, b )` {
-	j + k;							$\C{// unambiguous, unique names define unique types}$
-	i;								$\C{// ambiguous, same name and type}$
-	a.i + b.i;						$\C{// unambiguous, qualification defines unique names}$
-	m;								$\C{// ambiguous, same name and no context to define unique type}$
-	m = 5.0;						$\C{// unambiguous, same name and context defines unique type}$
-	m = 1;							$\C{// unambiguous, same name and context defines unique type}$
-}
-`with( c )` { ... }					$\C{// ambiguous, same name and no context}$
-`with( (S)c )` { ... }					$\C{// unambiguous, same name and cast defines unique type}$
+	j + k;									$\C{// unambiguous, unique names define unique types}$
+	i;										$\C{// ambiguous, same name and type}$
+	a.i + b.i;								$\C{// unambiguous, qualification defines unique names}$
+	m;										$\C{// ambiguous, same name and no context to define unique type}$
+	m = 5.0;								$\C{// unambiguous, same name and context defines unique type}$
+	m = 1;									$\C{// unambiguous, same name and context defines unique type}$
+}
+`with( c )` { ... }							$\C{// ambiguous, same name and no context}$
+`with( (S)c )` { ... }						$\C{// unambiguous, same name and cast defines unique type}$
 \end{cfa}
 
 The components in the "with" clause
 
-  with ( a, b, c ) { ... }
+  with( a, b, c ) { ... }
 
 serve 2 purposes: each component provides a type and object. The type must be a