Index: doc/bibliography/pl.bib
===================================================================
--- doc/bibliography/pl.bib	(revision b51e5fdb602c1dba2eccbae649d9e6465ad8f6b3)
+++ doc/bibliography/pl.bib	(revision e84382bd450d0ddb9a03b545b1a3cce0f32ed4d7)
@@ -5205,6 +5205,5 @@
     year	= 1984,
     series	= {Computers and their Applications},
-    address	= {Market Cross House, Cooper Street, Chichester, West Sussex,
-	PO19 1EB, England},
+    address	= {Market Cross House, Cooper Street, Chichester, West Sussex, PO19 1EB, England},
     summary	= {
         The principles of Procedural Abstraction, Data Type Completeness,
@@ -5258,12 +5257,16 @@
 }
 
-@book{PowerPC,
-    key		= {PowerPC processor},
-    title	= {Programming Environments Manual for 32-Bit Implementations of the PowerPC ArchitectureARM Architecture},
-    publisher	= {Freescale Semiconductor},
-    volume	= {MPCFPE32B},
-    edition	= {Rev. 3},
-    month	= 9,
-    year	= 2005,
+@inproceedings{Rafkind09,
+    keywords	= {accurate, C programming language, conservative, garbage collection, precise},
+    contributer	= {pabuhr@plg},
+    author	= {Rafkind, Jon and Wick, Adam and Regehr, John and Flatt, Matthew},
+    title	= {Precise Garbage Collection for C},
+    booktitle	= {Proceedings of the 2009 International Symposium on Memory Management},
+    series	= {ISMM '09},
+    year	= {2009},
+    location	= {Dublin, Ireland},
+    pages	= {39-48},
+    publisher	= {ACM},
+    address	= {New York, NY, USA},
 }
 
@@ -5338,6 +5341,5 @@
 
 @article{psa:persistence,
-    keywords	= {persistence, first-class procedures, closure, PS-Algol,
-	Abstract Data Types},
+    keywords	= {persistence, first-class procedures, closure, PS-Algol, Abstract Data Types},
     contributer	= {gjditchfield@plg},
     author	= {Malcolm P. Atkinson and Ronald Morrison},
@@ -5370,6 +5372,5 @@
 
 @article{Procol89,
-    keywords	= {active objects, object-oriented languages,
-	object-based languages, explicit per-object protocol},
+    keywords	= {active objects, object-oriented languages, object-based languages, explicit per-object protocol},
     contributer	= {akgoel@plg},
     author	= {Jan van den Bos and Chris Laffra},
@@ -5383,4 +5384,14 @@
     note	= {Proceedings of the OOPSLA'89 Conference, Oct. 1--6, 1989, New Orleans, Lousiana},
     abstract	= {},
+}
+
+@book{PowerPC,
+    key		= {PowerPC processor},
+    title	= {Programming Environments Manual for 32-Bit Implementations of the PowerPC ArchitectureARM Architecture},
+    publisher	= {Freescale Semiconductor},
+    volume	= {MPCFPE32B},
+    edition	= {Rev. 3},
+    month	= 9,
+    year	= 2005,
 }
 
@@ -6075,5 +6086,5 @@
 
 @inproceedings{Leissa14,
-    title	= {Sierra: a SIMD extension for C++},
+    title	= {{S}ierra: a {SIMD} extension for {C}++},
     author	= {Lei{\ss}a, Roland and Haffner, Immanuel and Hack, Sebastian},
     booktitle	= {Proceedings of the 2014 Workshop on Workshop on programming models for SIMD/Vector processing},
Index: doc/papers/general/Paper.tex
===================================================================
--- doc/papers/general/Paper.tex	(revision b51e5fdb602c1dba2eccbae649d9e6465ad8f6b3)
+++ doc/papers/general/Paper.tex	(revision e84382bd450d0ddb9a03b545b1a3cce0f32ed4d7)
@@ -368,4 +368,14 @@
 Hence, programmers can easily form local environments, adding and modifying appropriate functions, to maximize reuse of other existing functions and types.
 
+Unconstruction is a mechanism to distribute @forall@ over related routines/types (see @stack@ examples in Section~\ref{sec:eval}):
+\begin{cfa}
+forall( otype T ) {							$\C{// forall block}$
+	struct stack { stack_node(T) * head; };	$\C{// generic type}$
+	void push( stack(T) & s, T value ) ...	$\C{// generic operations}$
+	T pop( stack(T) & s ) ...
+}
+\end{cfa}
+Each block declaration is prefixed with the initial @forall@ clause significantly reducing duplication.
+
 
 \subsection{Traits}
@@ -836,5 +846,5 @@
 % \end{cfa}
 % so the thunk provides flattening and structuring conversions to inferred functions, improving the compatibility of tuples and polymorphism.
-% These thunks are generated locally using gcc nested-functions, rather hositing them to the external scope, so they can easily access local state.
+% These thunks are generated locally using gcc nested-functions, rather hoisting them to the external scope, so they can easily access local state.
 
 
@@ -1167,5 +1177,5 @@
 \lstMakeShortInline@%
 \end{cquote}
-The target label must be below the @fallthrough@, \ie @fallthrough@ cannot form a loop, and the label may not be nested in a control structor, \ie it must be at the same level as the @case@ clauses;
+The target label must be below the @fallthrough@, \ie @fallthrough@ cannot form a loop, and the label may not be nested in a control structure, \ie it must be at the same level as the @case@ clauses;
 the target label may be case @default@.
 
@@ -2155,7 +2165,7 @@
 \begin{cfa}
 struct W {
-    double stones;
-    W() { stones = 0.0; }
-    W( double w ) { stones = w; }
+	double stones;
+	W() { stones = 0.0; }
+	W( double w ) { stones = w; }
 };
 W operator+( W l, W r ) {
@@ -2719,8 +2729,8 @@
 
 \CC is the best known C-based language, and is similar to \CFA in that both are extensions to C with source and runtime backwards compatibility.
-Specific difference between \CFA and \CC have been identified in prior sections, with a final observation that \CFA has equal or few tokens to express the same notion in several cases.
-The key difference between design philosophies is that \CFA is easier for C programmers to understand, by maintaining a procedural paradigm and avoiding complex interactions among extensions.
+Specific difference between \CFA and \CC have been identified in prior sections, with a final observation that \CFA has equal or fewer tokens to express the same notion in many cases.
+The key difference in design philosophies is that \CFA is easier for C programmers to understand by maintaining a procedural paradigm and avoiding complex interactions among extensions.
 \CC, on the other hand, has multiple overlapping features (such as the three forms of polymorphism), many of which have complex interactions with its object-oriented design. 
-As a result, \CC has a steep learning curve for even experienced C programmers, especially when attempting to maintain performance equivalent to C legacy code.
+As a result, \CC has a steep learning curve for even experienced C programmers, especially when attempting to maintain performance equivalent to C legacy-code.
 
 There are several other C extension-languages with less usage and even more dramatic changes than \CC. 
@@ -2728,7 +2738,7 @@
 Other languages extend C with more focused features. 
 CUDA~\cite{Nickolls08}, ispc~\cite{Pharr12}, and Sierra~\cite{Leissa14} add data-parallel primitives to C or \CC;
-such features have not yet been added to \CFA, but are not precluded by the design.
-Finaly, some C extensions (or suggested extensions) attempt to provide a more memory-safe C~\cite{Boehm88};
-type-checked polymorphism in \CFA covers several of C's memory-safety holes, but more aggressive approaches such as annotating all pointer types with their nullability are contradictory to \CFA's backwards compatibility goals.
+such features have not yet been added to \CFA, but are easily incorporated within its design.
+Finally, some C extensions (or suggested extensions) attempt to provide a more memory-safe C~\cite{Boehm88,Rafkind09};
+type-checked polymorphism in \CFA covers several of C's memory-safety issues, but more aggressive approaches such as annotating all pointer types with their nullability are contradictory to \CFA's backwards compatibility goals.
 
 
@@ -2841,7 +2851,7 @@
 	struct stack_node * n = s->head;
 	s->head = n->next;
-	void * x = n->value;
+	void * v = n->value;
 	free( n );
-	return x;
+	return v;
 }
 \end{cfa}
@@ -2897,4 +2907,54 @@
 \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);
+		}
+		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;
+	}
+	stack(T) ?=?( stack(T) & s, stack(T) t ) {
+		if ( s.head == t.head ) return s;
+		clear( s );
+		s{ t };
+		return s;
+	}
+	void ^?{}( stack(T) & s) { clear( s ); }
+	_Bool empty( const stack(T) & s ) { return s.head == 0; }
+	void push( stack(T) & s, T value ) with( s ) {
+		stack_node(T) * n = alloc();
+		(*n){ value, head };
+		head = n;
+	}
+	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{comment}
+
 \medskip\noindent
 \CC
@@ -2907,4 +2967,7 @@
 	};
 	node * head;
+	stack() : head( nullptr ) {}
+	stack( const stack<T> & o) { copy( o ); }
+	stack( stack<T> && o ) : head( o.head ) { o.head = nullptr; }
 	void clear() {
 		for ( node * next = head; next; ) {
@@ -2923,8 +2986,6 @@
 		*crnt = nullptr;
 	}
-	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();
@@ -2937,7 +2998,7 @@
 		node * n = head;
 		head = n->next;
-		T x = std::move( n->value );
+		T v = std::move( n->value );
 		delete n;
-		return x;
+		return v;
 	}
 };
@@ -2950,8 +3011,8 @@
 	struct node {
 		ptr<object> value;
-		node* next;
-		node( const object & v, node * n ) : value( v.new_copy() ), next( n ) {}
+		node * next;
+		node( const object & v, node * n = nullptr ) : value( v.new_copy() ), next( n ) {}
 	};
-	node* head;
+	node * head;
 	void clear() {
 		for ( node * next = head; next; ) {
@@ -2972,5 +3033,5 @@
 	stack() : head( nullptr ) {}
 	stack( const stack & o ) { copy( o ); }
-		~stack() { clear(); }
+	~stack() { clear(); }
 	stack & operator= ( const stack & o ) {
 		if ( this == &o ) return *this;
@@ -2984,7 +3045,7 @@
 		node * n = head;
 		head = n->next;
-		ptr<object> x = std::move( n->value );
+		ptr<object> v = std::move( n->value );
 		delete n;
-		return x;
+		return v;
 	}
 };
Index: doc/papers/general/evaluation/c-stack.c
===================================================================
--- doc/papers/general/evaluation/c-stack.c	(revision b51e5fdb602c1dba2eccbae649d9e6465ad8f6b3)
+++ doc/papers/general/evaluation/c-stack.c	(revision e84382bd450d0ddb9a03b545b1a3cce0f32ed4d7)
@@ -3,22 +3,31 @@
 
 struct stack_node {
-	void* value;
-	struct stack_node* next;
+	void * value;
+	struct stack_node * next;
 };
+
+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 );
+	}
+	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);
+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*)) {
+struct stack * assign_stack( struct stack * s, const struct stack * t, 
+		void * (*copy_el)( const void * ), void (*free_el)( void * ) ) {
 	if ( s->head == t->head ) return s;
 	clear_stack( s, free_el ); /***/
@@ -27,27 +36,17 @@
 }
 
-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);
-	}
-	s->head = NULL;
-}
+_Bool stack_empty( const struct stack * s ) { return s->head == NULL; }
 
-_Bool stack_empty(const struct stack* s) { return s->head == NULL; }
-
-void push_stack(struct stack* s, void* value) {
-	struct stack_node* n = malloc(sizeof(struct stack_node)); /***/
+void push_stack( struct stack * s, void * value ) {
+	struct stack_node * n = malloc( sizeof(struct stack_node) ); /***/
 	*n = (struct stack_node){ value, s->head }; /***/
 	s->head = n;
 }
 
-void* pop_stack(struct stack* s) {
-	struct stack_node* n = s->head;
+void * pop_stack( struct stack * s ) {
+	struct stack_node * n = s->head;
 	s->head = n->next;
-	void* x = n->value;
-	free(n);
-	return x;
+	void * v = n->value;
+	free( n );
+	return v;
 }
Index: doc/papers/general/evaluation/cfa-stack.c
===================================================================
--- doc/papers/general/evaluation/cfa-stack.c	(revision b51e5fdb602c1dba2eccbae649d9e6465ad8f6b3)
+++ doc/papers/general/evaluation/cfa-stack.c	(revision e84382bd450d0ddb9a03b545b1a3cce0f32ed4d7)
@@ -6,4 +6,14 @@
 	stack_node(T) * next;
 };
+
+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);
+	}
+	head = 0;
+}
 
 forall( otype T ) void ?{}( stack(T) & s ) { (s.head){ 0 }; }
@@ -44,12 +54,2 @@
 	return v;
 }
-
-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);
-	}
-	head = 0;
-}
Index: doc/papers/general/evaluation/cpp-stack.hpp
===================================================================
--- doc/papers/general/evaluation/cpp-stack.hpp	(revision b51e5fdb602c1dba2eccbae649d9e6465ad8f6b3)
+++ doc/papers/general/evaluation/cpp-stack.hpp	(revision e84382bd450d0ddb9a03b545b1a3cce0f32ed4d7)
@@ -2,25 +2,19 @@
 #include <utility>
 
-template<typename T> class stack {
+template<typename T> struct stack {
 	struct node {
 		T value;
-		node* next;
+		node * next;
+		node( const T & v, node * n = nullptr ) : value( v ), next( n ) {}
+	};
+	node * head;
 
-		node( const T& v, node* n = nullptr ) : value(v), next(n) {}
-	};
-	node* head;
+	stack() : head( nullptr ) {}
+	stack( const stack<T> & o ) { copy( o ); }
+	stack( stack<T> && o ) : head( o.head ) { o.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;
-	}
-public:
 	void clear() {
-	    for ( node* next = head; next; ) {
-			node* crnt = next;
+		for ( node * next = head; next; ) {
+			node * crnt = next;
 			next = crnt->next;
 			delete crnt;
@@ -29,12 +23,19 @@
 	}
 
-	stack() : head(nullptr) {}
-	stack(const stack<T>& o) { copy(o); }
+	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;
+	}
+
 	~stack() { clear(); }
 
-	stack& operator= (const stack<T>& o) {
+	stack & operator= ( const stack<T> & o ) {
 		if ( this == &o ) return *this;
 		clear();
-		copy(o);
+		copy( o );
 		return *this;
 	}
@@ -42,12 +43,12 @@
 	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;
+		node * n = head;
 		head = n->next;
-		T x = std::move(n->value);
+		T v = std::move( n->value );
 		delete n;
-		return x;
+		return v;
 	}
 };
Index: doc/papers/general/evaluation/cpp-vstack.cpp
===================================================================
--- doc/papers/general/evaluation/cpp-vstack.cpp	(revision b51e5fdb602c1dba2eccbae649d9e6465ad8f6b3)
+++ doc/papers/general/evaluation/cpp-vstack.cpp	(revision e84382bd450d0ddb9a03b545b1a3cce0f32ed4d7)
@@ -2,9 +2,18 @@
 #include <utility>
 
-stack::node::node( const object& v, node* n ) : value( v.new_copy() ), next( n ) {}
+stack::node::node( const object & v, node * n ) : value( v.new_copy() ), next( n ) {}
 
-void stack::copy(const stack& o) {
-	node** crnt = &head;
-	for ( node* next = o.head; next; next = next->next ) {
+void stack::clear() {
+	for ( node * next = head; next; ) {
+		node * crnt = next;
+		next = crnt->next;
+		delete crnt;
+	}
+	head = nullptr;
+}
+
+void stack::copy( const stack & o ) {
+	node ** crnt = &head;
+	for ( node * next = o.head; next; next = next->next ) {
 		*crnt = new node{ *next->value }; /***/
 		crnt = &(*crnt)->next;
@@ -13,34 +22,32 @@
 }
 
-stack::stack() : head(nullptr) {}
-stack::stack(const stack& o) { copy(o); }
+stack::stack() : head( nullptr ) {}
+stack::stack( const stack & o ) { copy( o ); }
+stack::stack( stack && o ) : head( o.head ) { o.head = nullptr; }
 stack::~stack() { clear(); }
 
-stack& stack::operator= (const stack& o) {
+stack & stack::operator=( const stack & o ) {
 	if ( this == &o ) return *this;
 	clear();
-	copy(o);
+	copy( o );
 	return *this;
 }
 
-void stack::clear() {
-    for ( node* next = head; next; ) {
-		node* crnt = next;
-		next = crnt->next;
-		delete crnt;
-	}
-	head = nullptr;
+stack & stack::operator=( stack && o ) {
+	if ( this == &o ) return *this;
+	head = o.head;
+	o.head = nullptr;
+	return *this;
 }
-
 
 bool stack::empty() const { return head == nullptr; }
 
-void stack::push(const object& value) { head = new node{ value, head }; /***/ }
+void stack::push( const object & value ) { head = new node{ value, head }; /***/ }
 
 ptr<object> stack::pop() {
-	node* n = head;
+	node * n = head;
 	head = n->next;
-	ptr<object> x = std::move(n->value);
+	ptr<object> v = std::move( n->value );
 	delete n;
-	return x;
+	return v;
 }
Index: doc/papers/general/evaluation/cpp-vstack.hpp
===================================================================
--- doc/papers/general/evaluation/cpp-vstack.hpp	(revision b51e5fdb602c1dba2eccbae649d9e6465ad8f6b3)
+++ doc/papers/general/evaluation/cpp-vstack.hpp	(revision e84382bd450d0ddb9a03b545b1a3cce0f32ed4d7)
@@ -2,23 +2,23 @@
 #include "object.hpp"
 
-class stack {
+struct stack {
 	struct node {
 		ptr<object> value;
-		node* next;
-
-		node( const object& v, node* n = nullptr );
+		node * next;
+		node( const object & v, node * n = nullptr );
 	};
-	node* head;
-
-	void copy(const stack& o);
-public:
-	stack();
-	stack(const stack& o);
-	~stack();
-	stack& operator= (const stack& o);
+	node * head;
 
 	void clear();
+	void copy( const stack & o );
+
+	stack();
+	stack( const stack & o );
+	stack( stack && o );
+	~stack();
+	stack & operator=( const stack& o );
+	stack & operator=( stack && o );
 	bool empty() const;
-	void push(const object& value);
+	void push( const object & value );
 	ptr<object> pop();
 };