Changes in / [77acd07d:3f8ab8f]

File:

• doc/papers/general/Paper.tex (modified) (7 diffs)

doc/papers/general/Paper.tex

@@ -1052 +1052 @@
 \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 +1061 @@
 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 +1070 @@
 \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 +1088 @@
 % \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 +1098 @@
 \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 +1137 @@
         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 +1155 @@
 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