Index: doc/papers/general/evaluation/c-stack.c
===================================================================
--- doc/papers/general/evaluation/c-stack.c	(revision 29db7239b8192d870e72ad96c020f2db4b40c2bc)
+++ doc/papers/general/evaluation/c-stack.c	(revision 81e8ab00cb49d1a0ae230e86de7686f659ec61fb)
@@ -3,15 +3,25 @@
 
 struct stack_node {
-	void* value;
-	struct stack_node* next;
+	void * value;
+	struct stack_node * next;
 };
 
 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 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;
+}
+
+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;
 	}
@@ -19,27 +29,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 29db7239b8192d870e72ad96c020f2db4b40c2bc)
+++ doc/papers/general/evaluation/cfa-stack.c	(revision 81e8ab00cb49d1a0ae230e86de7686f659ec61fb)
@@ -17,4 +17,14 @@
 	}
 	*crnt = 0;
+}
+
+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;
 }
 
@@ -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 29db7239b8192d870e72ad96c020f2db4b40c2bc)
+++ doc/papers/general/evaluation/cpp-stack.hpp	(revision 81e8ab00cb49d1a0ae230e86de7686f659ec61fb)
@@ -2,16 +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 ) {
+	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;
@@ -19,8 +22,8 @@
 		*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,17 +32,14 @@
 	}
 
-	stack() : head(nullptr) {}
-	stack(const stack<T>& o) { copy(o); }
-	stack(stack<T>&& o) : head(o.head) { o.head = 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;
 	}
 
-	stack& operator= (stack<T>&& o) {
+	stack & operator= ( stack<T> && o ) {
 		if ( this == &o ) return *this;
 		head = o.head;
@@ -50,12 +50,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 29db7239b8192d870e72ad96c020f2db4b40c2bc)
+++ doc/papers/general/evaluation/cpp-vstack.cpp	(revision 81e8ab00cb49d1a0ae230e86de7686f659ec61fb)
@@ -2,9 +2,9 @@
 #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::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,17 +13,26 @@
 }
 
-stack::stack() : head(nullptr) {}
-stack::stack(const stack& o) { copy(o); }
-stack::stack(stack&& o) : head(o.head) { o.head = nullptr; }
+void stack::clear() {
+	for ( node * next = head; next; ) {
+		node * crnt = next;
+		next = crnt->next;
+		delete crnt;
+	}
+	head = nullptr;
+}
+
+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;
 }
 
-stack& stack::operator= (stack&& o) {
+stack & stack::operator=( stack && o ) {
 	if ( this == &o ) return *this;
 	head = o.head;
@@ -32,23 +41,14 @@
 }
 
-void stack::clear() {
-    for ( node* next = head; next; ) {
-		node* crnt = next;
-		next = crnt->next;
-		delete crnt;
-	}
-	head = nullptr;
-}
-
 
 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 29db7239b8192d870e72ad96c020f2db4b40c2bc)
+++ doc/papers/general/evaluation/cpp-vstack.hpp	(revision 81e8ab00cb49d1a0ae230e86de7686f659ec61fb)
@@ -2,25 +2,24 @@
 #include "object.hpp"
 
-class stack {
+struct stack {
 	struct node {
 		ptr<object> value;
-		node* next;
+		node * next;
+		node( const object & v, node * n = nullptr );
+	};
+	node * head;
 
-		node( const object& v, node* n = nullptr );
-	};
-	node* head;
+	void copy( const stack & o );
 
-	void copy(const stack& o);
-public:
 	stack();
-	stack(const stack& o);
-	stack(stack&& o);
+	stack( const stack & o );
+	stack( stack && o );
 	~stack();
-	stack& operator= (const stack& o);
-	stack& operator= (stack&& o);
+	stack& operator=( const stack& o );
+	stack& operator=( stack && o );
 
 	void clear();
 	bool empty() const;
-	void push(const object& value);
+	void push( const object & value );
 	ptr<object> pop();
 };