Index: doc/papers/general/evaluation/c-bench.c
===================================================================
--- doc/papers/general/evaluation/c-bench.c	(revision 860f19f8e4e35fd97620e0da5e6c37a54a001484)
+++ doc/papers/general/evaluation/c-bench.c	(revision ac4dad218855fd49df19e14a62c1a2fc4f908307)
@@ -5,12 +5,12 @@
 #include "c-stack.h"
 
-char* new_char( char c ) {
-	char* q = malloc(sizeof(char)); /***/
+char * new_char( char c ) {
+	char* q = malloc( sizeof(char) ); /***/
 	*q = c;
 	return q;
 }
 
-short* new_short( short s ) {
-	short* q = malloc(sizeof(short)); /***/
+short * new_short( short s ) {
+	short* q = malloc( sizeof(short) ); /***/
 	*q = s;
 	return q;
@@ -18,14 +18,14 @@
 
 int* new_int( int i ) {
-	int* q = malloc(sizeof(int)); /***/
+	int* q = malloc( sizeof(int) ); /***/
 	*q = i;
 	return q;
 }
 
-void* copy_char( const void* p ) { return new_char( *(const char*)p ); } /***/
-void* copy_short( const void* p ) { return new_short( *(const short*)p ); } /***/
-void* copy_int( const void* p ) { return new_int( *(const int*)p ); } /***/
-void* copy_pair_short_char( const void* p ) { return copy_pair( p, copy_short, copy_char ); } /***/
-void free_pair_short_char( void* p ) { free_pair( p, free, free ); } /***/
+void * copy_char( const void * p ) { return new_char( *(const char*)p ); } /***/
+void * copy_short( const void * p ) { return new_short( *(const short*)p ); } /***/
+void * copy_int( const void * p ) { return new_int( *(const int*)p ); } /***/
+void * copy_pair_short_char( const void * p ) { return copy_pair( p, copy_short, copy_char ); } /***/
+void free_pair_short_char( void * p ) { free_pair( p, free, free ); } /***/
 
 int cmp_char( const void* a, const void* b ) { /***/
@@ -37,5 +37,5 @@
 }
 
-int main(int argc, char** argv) {
+int main(int argc, char * argv[] ) {
 	int maxi = 0, vali = 42;
 	struct stack si = new_stack(), ti;
Index: doc/papers/general/evaluation/c-pair.c
===================================================================
--- doc/papers/general/evaluation/c-pair.c	(revision 860f19f8e4e35fd97620e0da5e6c37a54a001484)
+++ doc/papers/general/evaluation/c-pair.c	(revision ac4dad218855fd49df19e14a62c1a2fc4f908307)
@@ -2,25 +2,25 @@
 #include "c-pair.h"
 
-struct pair* new_pair(void* first, void* second) {
-	struct pair* p = malloc(sizeof(struct pair)); /***/
-	*p = (struct pair){ first, second }; /***/
+pair * new_pair( void * first, void * second ) {
+	pair * p = malloc( sizeof(pair) ); /***/
+	*p = (pair){ first, second }; /***/
 	return p;
 }
 
-struct pair* copy_pair(const struct pair* src, 
-		void* (*copy_first)(const void*), void* (*copy_second)(const void*)) {
+pair * copy_pair( const pair * src, 
+		void * (* copy_first)(const void* ), void * (* copy_second)(const void *)) {
 	return new_pair( copy_first(src->first), copy_second(src->second) );
 }
 
-void free_pair(struct pair* p, void (*free_first)(void*), void (*free_second)(void*)) {
-	free_first(p->first);
-	free_second(p->second);
-	free(p);
+void free_pair( pair * p, void (* free_first)(void *), void (* free_second)(void *)) {
+	free_first( p->first );
+	free_second( p->second );
+	free( p );
 }
 
-int cmp_pair(const struct pair* a, const struct pair* b, 
-		int (*cmp_first)(const void*, const void*), int (*cmp_second)(const void*, const void*)) {
-	int c = cmp_first(a->first, b->first);
-	if ( c == 0 ) c = cmp_second(a->second, b->second);
+int cmp_pair( const pair * a, const pair * b, 
+		int (* cmp_first)(const void *, const void *), int (* cmp_second)(const void *, const void *)) {
+	int c = cmp_first( a->first, b->first );
+	if ( c == 0 ) c = cmp_second( a->second, b->second );
 	return c;
 }
Index: doc/papers/general/evaluation/c-pair.h
===================================================================
--- doc/papers/general/evaluation/c-pair.h	(revision 860f19f8e4e35fd97620e0da5e6c37a54a001484)
+++ doc/papers/general/evaluation/c-pair.h	(revision ac4dad218855fd49df19e14a62c1a2fc4f908307)
@@ -1,16 +1,16 @@
 #pragma once
 
-struct pair {
-	void* first;
-	void* second;
-};
+typedef struct pair {
+	void * first;
+	void * second;
+} pair;
 
-struct pair* new_pair(void* first, void* second);
+pair * new_pair( void * first, void * second );
 
-struct pair* copy_pair(const struct pair* src, 
-	void* (*copy_first)(const void*), void* (*copy_second)(const void*));
+pair * copy_pair( const pair * src, 
+	void * (* copy_first)(const void *), void * (* copy_second)(const void *));
 
-void free_pair(struct pair* p, void (*free_first)(void*), void (*free_second)(void*));
+void free_pair( pair * p, void (* free_first)(void *), void (* free_second)(void *));
 
-int cmp_pair(const struct pair* a, const struct pair* b, 
-	int (*cmp_first)(const void*, const void*), int (*cmp_second)(const void*, const void*));
+int cmp_pair( const pair * a, const pair * b, 
+	int (* cmp_first)(const void *, const void *), int (* cmp_second)(const void *, const void *));
Index: doc/papers/general/evaluation/c-print.c
===================================================================
--- doc/papers/general/evaluation/c-print.c	(revision 860f19f8e4e35fd97620e0da5e6c37a54a001484)
+++ doc/papers/general/evaluation/c-print.c	(revision ac4dad218855fd49df19e14a62c1a2fc4f908307)
@@ -4,44 +4,44 @@
 #include "c-print.h"
 
-void print_string(FILE* out, const char* x) { fprintf(out, "%s", x); }
+void print_string( FILE * out, const char * x ) { fprintf( out, "%s", x ); }
 
-void print_bool(FILE* out, _Bool x) { fprintf(out, "%s", x ? "true" : "false"); }
+void print_bool( FILE * out, _Bool x ) { fprintf( out, "%s", x ? "true" : "false" ); }
 
-void print_char(FILE* out, char x) {
-	if ( 0x20 <= x && x <= 0x7E ) { fprintf(out, "'%c'", x); }
-	else { fprintf(out, "'\\%x'", x); }
+void print_char( FILE * out, char x ) {
+	if ( 0x20 <= x && x <= 0x7E ) { fprintf( out, "'%c'", x ); }
+	else { fprintf( out, "'\\%x'", x ); }
 }
 
-void print_int(FILE* out, int x) { fprintf(out, "%d", x); }
+void print_int( FILE * out, int x ) { fprintf( out, "%d", x ); }
 
-void print_fmt(FILE* out, char fmt, void* p) {
+void print_fmt( FILE * out, char fmt, void * p ) {
 	switch( fmt ) {
-	case 's': print_string(out, (const char*)p); break; /***/
-	case 'b': print_bool(out, *(_Bool*)p); break; /***/
-	case 'c': print_char(out, *(char*)p); break; /***/
-	case 'd': print_int(out, *(int*)p); break; /***/
+	case 's': print_string( out, (const char*)p ); break; /***/
+	case 'b': print_bool( out, *(_Bool*)p ); break; /***/
+	case 'c': print_char( out, *(char*)p ); break; /***/
+	case 'd': print_int( out, *(int*)p ); break; /***/
 	}
 }
 
-void print(FILE* out, const char* fmt, ...) {
+void print( FILE * out, const char * fmt, ... ) {
 	va_list args;
 	va_start(args, fmt);
-	for (const char* it = fmt; *it; ++it) {
+	for ( const char * it = fmt; *it; ++it ) {
 		switch( *it ) {
-		case 's': print_string(out, va_arg(args, const char*)); break; /***/
-		case 'b': print_bool(out, va_arg(args, int)); break; /***/
-		case 'c': print_char(out, va_arg(args, int)); break; /***/
-		case 'd': print_int(out, va_arg(args, int)); break; /***/
+		case 's': print_string( out, va_arg( args, const char * ) ); break; /***/
+		case 'b': print_bool( out, va_arg( args, int ) ); break; /***/
+		case 'c': print_char( out, va_arg( args, int ) ); break; /***/
+		case 'd': print_int( out, va_arg( args, int ) ); break; /***/
 		case 'p': {
-			const struct pair x = va_arg(args, const struct pair); /***/
-			fprintf(out, "[");
-			print_fmt(out, *++it, x.first); /***/
-			fprintf(out, ", ");
-			print_fmt(out, *++it, x.second); /***/
-			fprintf(out, "]");
+			const struct pair x = va_arg( args, const struct pair ); /***/
+			fprintf( out, "[" );
+			print_fmt( out, *++it, x.first ); /***/
+			fprintf( out, ", " );
+			print_fmt( out, *++it, x.second ); /***/
+			fprintf( out, "]" );
 			break;
 		}
 		}
 	}
-	va_end(args);
+	va_end( args );
 }
Index: doc/papers/general/evaluation/c-print.h
===================================================================
--- doc/papers/general/evaluation/c-print.h	(revision 860f19f8e4e35fd97620e0da5e6c37a54a001484)
+++ doc/papers/general/evaluation/c-print.h	(revision ac4dad218855fd49df19e14a62c1a2fc4f908307)
@@ -2,8 +2,8 @@
 #include <stdio.h>
 
-void print_string(FILE* out, const char* x);
-void print_bool(FILE* out, _Bool x);
-void print_char(FILE* out, char x);
-void print_int(FILE* out, int x);
+void print_string( FILE * out, const char * x );
+void print_bool( FILE * out, _Bool x );
+void print_char( FILE * out, char x );
+void print_int( FILE * out, int x );
 
-void print(FILE* out, const char* fmt, ...);
+void print( FILE * out, const char * fmt, ... );
Index: doc/papers/general/evaluation/c-stack.c
===================================================================
--- doc/papers/general/evaluation/c-stack.c	(revision 860f19f8e4e35fd97620e0da5e6c37a54a001484)
+++ doc/papers/general/evaluation/c-stack.c	(revision ac4dad218855fd49df19e14a62c1a2fc4f908307)
@@ -2,31 +2,32 @@
 #include "c-stack.h"
 
-struct stack_node {
+typedef struct node {
 	void * value;
-	struct stack_node * next;
-};
+	struct node * next;
+} node;
 
-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 );
+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 }; /***/ }
+stack new_stack() { return (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, 
+stack * assign_stack( stack * s, const stack * t, 
 		void * (*copy_el)( const void * ), void (*free_el)( void * ) ) {
 	if ( s->head == t->head ) return s;
@@ -36,14 +37,14 @@
 }
 
-_Bool stack_empty( const struct stack * s ) { return s->head == NULL; }
+_Bool stack_empty( const 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 }; /***/
+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;
Index: doc/papers/general/evaluation/c-stack.h
===================================================================
--- doc/papers/general/evaluation/c-stack.h	(revision 860f19f8e4e35fd97620e0da5e6c37a54a001484)
+++ doc/papers/general/evaluation/c-stack.h	(revision ac4dad218855fd49df19e14a62c1a2fc4f908307)
@@ -1,16 +1,16 @@
 #pragma once
 
-struct stack_node;
-struct stack {
-	struct stack_node* head;
-};
+struct node;
+typedef struct stack {
+	struct node * head;
+} stack;
 
-struct stack new_stack();
-void copy_stack(struct stack* dst, const struct stack* src, void* (*copy)(const void*));
-struct stack* assign_stack(struct stack* dst, const struct stack* src, 
-	void* (*copy_el)(const void*), void (*free_el)(void*));
-void clear_stack(struct stack* s, void (*free_el)(void*));
+stack new_stack();
+void copy_stack(stack * dst, const stack * src, void * (* copy)(const void *));
+stack * assign_stack( stack * dst, const stack * src, 
+	void * (* copy_el)(const void *), void (* free_el)(void *));
+void clear_stack(stack * s, void (*free_el)(void *));
 
-_Bool stack_empty(const struct stack* s);
-void push_stack(struct stack* s, void* value);
-void* pop_stack(struct stack* s);
+_Bool stack_empty( const stack * s );
+void push_stack( stack * s, void * value );
+void * pop_stack( stack * s );
Index: doc/papers/general/evaluation/cfa-stack.c
===================================================================
--- doc/papers/general/evaluation/cfa-stack.c	(revision 860f19f8e4e35fd97620e0da5e6c37a54a001484)
+++ doc/papers/general/evaluation/cfa-stack.c	(revision ac4dad218855fd49df19e14a62c1a2fc4f908307)
@@ -2,54 +2,56 @@
 #include "cfa-stack.h"
 
-forall( otype T ) struct stack_node {
-	T value;
-	stack_node(T) * next;
-};
+forall( otype T ) {
+	struct node {
+		T value;
+		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);
+	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;
+
+	void ^?{}( stack(T) & s) { clear( s ); }
+
+    void clear( stack(T) & s ) with( s ) {
+		for ( node(T) * nx = head; nx; ) {
+			node(T) * cr = nx;
+			nx = cr->next;
+			^(*cr){};
+			free(cr);
+		}
+		head = 0;
+	}
+
+	stack(T) ?=?( stack(T) & s, stack(T) t ) {
+		if ( s.head == t.head ) return s;
+		clear( s );
+		s{ t };
+		return s;
+	}
+
+	_Bool empty( const stack(T) & s ) { return s.head == 0; }
+
+	void push( stack(T) & s, T value ) with( s ) {
+		node(T) * n = alloc();
+		(*n){ value, head };
+		head = n;
+	}
+
+	T pop( stack(T) & s ) with( s ) {
+		node(T) * n = head;
+		head = n->next;
+		T v = n->value;
+		^(*n){};
+		free( n );
+		return v;
+	}
 }
-
-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;
-}
Index: doc/papers/general/evaluation/cfa-stack.h
===================================================================
--- doc/papers/general/evaluation/cfa-stack.h	(revision 860f19f8e4e35fd97620e0da5e6c37a54a001484)
+++ doc/papers/general/evaluation/cfa-stack.h	(revision ac4dad218855fd49df19e14a62c1a2fc4f908307)
@@ -1,16 +1,18 @@
 #pragma once
 
-forall( otype T ) struct stack_node;
-forall( otype T ) struct stack {
-	stack_node(T) * head;
-};
+forall( otype T ) {
+	struct node;
+	struct stack {
+		node(T) * head;
+	};
 
-forall( otype T ) void ?{}( stack(T) & s );
-forall( otype T ) void ?{}( stack(T) & s, stack(T) t );
-forall( otype T ) stack(T) ?=?( stack(T) & s, stack(T) t );
-forall( otype T ) void ^?{}( stack(T) & s);
+	void ?{}( stack(T) & s );
+	void ?{}( stack(T) & s, stack(T) t );
+	void ^?{}( stack(T) & s);
+	void clear( stack(T) & s );
 
-forall( otype T ) _Bool empty( const stack(T) & s );
-forall( otype T ) void push( stack(T) & s, T value );
-forall( otype T ) T pop( stack(T) & s );
-forall( otype T ) void clear( stack(T) & s );
+	stack(T) ?=?( stack(T) & s, stack(T) t );
+	_Bool empty( const stack(T) & s );
+	void push( stack(T) & s, T value );
+	T pop( stack(T) & s );
+}
Index: doc/papers/general/evaluation/cpp-stack.hpp
===================================================================
--- doc/papers/general/evaluation/cpp-stack.hpp	(revision 860f19f8e4e35fd97620e0da5e6c37a54a001484)
+++ doc/papers/general/evaluation/cpp-stack.hpp	(revision ac4dad218855fd49df19e14a62c1a2fc4f908307)
@@ -14,8 +14,8 @@
 
 	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;
@@ -23,10 +23,10 @@
 
 	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;
+		node ** cr = &head;
+		for ( node * nx = o.head; nx; nx = nx->next ) {
+			*cr = new node{ nx->value }; /***/
+			cr = &(*cr)->next;
 		}
-		*crnt = nullptr;
+		*cr = nullptr;
 	}
 
Index: doc/papers/general/evaluation/cpp-vstack.cpp
===================================================================
--- doc/papers/general/evaluation/cpp-vstack.cpp	(revision 860f19f8e4e35fd97620e0da5e6c37a54a001484)
+++ doc/papers/general/evaluation/cpp-vstack.cpp	(revision ac4dad218855fd49df19e14a62c1a2fc4f908307)
@@ -5,8 +5,8 @@
 
 void stack::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;
@@ -14,10 +14,10 @@
 
 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;
+	node ** cr = &head;
+	for ( node * nx = o.head; nx; nx = nx->next ) {
+		*cr = new node{ *nx->value }; /***/
+		cr = &(*cr)->next;
 	}
-	*crnt = nullptr;
+	*cr = nullptr;
 }