Index: libcfa/src/bits/algorithm.hfa
===================================================================
--- libcfa/src/bits/algorithm.hfa	(revision a7aea7d762e94109be8ad28e8cd35350fc5c528c)
+++ libcfa/src/bits/algorithm.hfa	(revision fd54fef231baeeb0016103bf19cc8e6d87287faf)
@@ -17,12 +17,12 @@
 
 #ifdef SAFE_SORT
-forall( otype T | {  int ?<?( T, T ); int ?>?( T, T ); } ) static inline void __libcfa_small_sort2( T * arr );
-forall( otype T | {  int ?<?( T, T ); int ?>?( T, T ); } ) static inline void __libcfa_small_sort3( T * arr );
-forall( otype T | {  int ?<?( T, T ); int ?>?( T, T ); } ) static inline void __libcfa_small_sort4( T * arr );
-forall( otype T | {  int ?<?( T, T ); int ?>?( T, T ); } ) static inline void __libcfa_small_sort5( T * arr );
-forall( otype T | {  int ?<?( T, T ); int ?>?( T, T ); } ) static inline void __libcfa_small_sort6( T * arr );
-forall( otype T | {  int ?<?( T, T ); int ?>?( T, T ); } ) static inline void __libcfa_small_sortN( T * arr, size_t dim );
+forall( T | {  int ?<?( T, T ); int ?>?( T, T ); } ) static inline void __libcfa_small_sort2( T * arr );
+forall( T | {  int ?<?( T, T ); int ?>?( T, T ); } ) static inline void __libcfa_small_sort3( T * arr );
+forall( T | {  int ?<?( T, T ); int ?>?( T, T ); } ) static inline void __libcfa_small_sort4( T * arr );
+forall( T | {  int ?<?( T, T ); int ?>?( T, T ); } ) static inline void __libcfa_small_sort5( T * arr );
+forall( T | {  int ?<?( T, T ); int ?>?( T, T ); } ) static inline void __libcfa_small_sort6( T * arr );
+forall( T | {  int ?<?( T, T ); int ?>?( T, T ); } ) static inline void __libcfa_small_sortN( T * arr, size_t dim );
 
-forall( otype T | {  int ?<?( T, T ); int ?>?( T, T ); } )
+forall( T | {  int ?<?( T, T ); int ?>?( T, T ); } )
 static inline void __libcfa_small_sort( T * arr, size_t dim ) {
 	switch( dim ) {
@@ -41,10 +41,10 @@
 #define SWAP(x,y) { T a = min(arr[x], arr[y]); T b = max(arr[x], arr[y]); arr[x] = a; arr[y] = b;}
 
-forall( otype T | {  int ?<?( T, T ); int ?>?( T, T ); } )
+forall( T | {  int ?<?( T, T ); int ?>?( T, T ); } )
 static inline void __libcfa_small_sort2( T * arr ) {
 	SWAP(0, 1);
 }
 
-forall( otype T | {  int ?<?( T, T ); int ?>?( T, T ); } )
+forall( T | {  int ?<?( T, T ); int ?>?( T, T ); } )
 static inline void __libcfa_small_sort3( T * arr ) {
 	SWAP(1, 2);
@@ -53,5 +53,5 @@
 }
 
-forall( otype T | {  int ?<?( T, T ); int ?>?( T, T ); } )
+forall( T | {  int ?<?( T, T ); int ?>?( T, T ); } )
 static inline void __libcfa_small_sort4( T * arr ) {
 	SWAP(0, 1);
@@ -62,5 +62,5 @@
 }
 
-forall( otype T | {  int ?<?( T, T ); int ?>?( T, T ); } )
+forall( T | {  int ?<?( T, T ); int ?>?( T, T ); } )
 static inline void __libcfa_small_sort5( T * arr ) {
 	SWAP(0, 1);
@@ -75,5 +75,5 @@
 }
 
-forall( otype T | {  int ?<?( T, T ); int ?>?( T, T ); } )
+forall( T | {  int ?<?( T, T ); int ?>?( T, T ); } )
 static inline void __libcfa_small_sort6( T * arr ) {
 	SWAP(1, 2);
@@ -91,5 +91,5 @@
 }
 
-forall( otype T | {  int ?<?( T, T ); int ?>?( T, T ); } )
+forall( T | {  int ?<?( T, T ); int ?>?( T, T ); } )
 static inline void __libcfa_small_sortN( T * arr, size_t dim ) {
 	int i, j;
@@ -112,5 +112,5 @@
 static inline void __libcfa_small_sortN( void* * arr, size_t dim );
 
-forall( dtype T )
+forall( T & )
 static inline void __libcfa_small_sort( T* * arr, size_t dim ) {
 	switch( dim ) {
Index: libcfa/src/bits/collection.hfa
===================================================================
--- libcfa/src/bits/collection.hfa	(revision a7aea7d762e94109be8ad28e8cd35350fc5c528c)
+++ libcfa/src/bits/collection.hfa	(revision fd54fef231baeeb0016103bf19cc8e6d87287faf)
@@ -31,5 +31,5 @@
 
 	// // wrappers to make Collection have T
-	// forall( dtype T ) {
+	// forall( T & ) {
 	// 	T *& Next( T * n ) {
 	// 		return (T *)Next( (Colable *)n );
@@ -38,5 +38,5 @@
 } // distribution
 
-forall( dtype T | { T *& Next ( T * ); } ) {
+forall( T & | { T *& Next ( T * ); } ) {
 	bool listed( T * n ) {
 		return Next( n ) != 0p;
@@ -76,5 +76,5 @@
 	} // post: elts = null
 
-	forall( dtype T ) {
+	forall( T & ) {
 		T * Curr( ColIter & ci ) with( ci ) {
 			return (T *)curr;
Index: libcfa/src/bits/containers.hfa
===================================================================
--- libcfa/src/bits/containers.hfa	(revision a7aea7d762e94109be8ad28e8cd35350fc5c528c)
+++ libcfa/src/bits/containers.hfa	(revision fd54fef231baeeb0016103bf19cc8e6d87287faf)
@@ -23,5 +23,5 @@
 
 #ifdef __cforall
-	forall(dtype T)
+	forall(T &)
 #else
 	#define T void
@@ -40,23 +40,23 @@
 
 #ifdef __cforall
-	// forall(otype T | sized(T))
+	// forall(T | sized(T))
 	// static inline void ?{}(__small_array(T) & this) {}
 
-	forall(dtype T | sized(T))
+	forall(T & | sized(T))
 	static inline T & ?[?]( __small_array(T) & this, __lock_size_t idx ) {
 		return ((typeof(this.data))this.data)[idx];
 	}
 
-	forall(dtype T | sized(T))
+	forall(T & | sized(T))
 	static inline T & ?[?]( const __small_array(T) & this, __lock_size_t idx ) {
 		return ((typeof(this.data))this.data)[idx];
 	}
 
-	forall(dtype T)
+	forall(T &)
 	static inline T * begin( const __small_array(T) & this ) {
 		return ((typeof(this.data))this.data);
 	}
 
-	forall(dtype T | sized(T))
+	forall(T & | sized(T))
 	static inline T * end( const __small_array(T) & this ) {
 		return ((typeof(this.data))this.data) + this.size;
@@ -69,5 +69,5 @@
 
 #ifdef __cforall
-	trait is_node(dtype T) {
+	trait is_node(T &) {
 		T *& get_next( T & );
 	};
@@ -78,5 +78,5 @@
 //-----------------------------------------------------------------------------
 #ifdef __cforall
-	forall(dtype TYPE)
+	forall(TYPE &)
 	#define T TYPE
 #else
@@ -95,10 +95,10 @@
 
 #ifdef __cforall
-	forall(dtype T)
+	forall(T &)
 	static inline void ?{}( __stack(T) & this ) {
 		(this.top){ 0p };
 	}
 
-	static inline forall( dtype T | is_node(T) ) {
+	static inline forall( T & | is_node(T) ) {
 		void push( __stack(T) & this, T * val ) {
 			verify( !get_next( *val ) );
@@ -126,5 +126,5 @@
 //-----------------------------------------------------------------------------
 #ifdef __cforall
-	forall(dtype TYPE)
+	forall(TYPE &)
 	#define T TYPE
 #else
@@ -144,5 +144,5 @@
 
 #ifdef __cforall
-	static inline forall( dtype T | is_node(T) ) {
+	static inline forall( T & | is_node(T) ) {
 		void ?{}( __queue(T) & this ) with( this ) {
 			(this.head){ 1p };
@@ -215,5 +215,5 @@
 //-----------------------------------------------------------------------------
 #ifdef __cforall
-	forall(dtype TYPE)
+	forall(TYPE &)
 	#define T TYPE
 	#define __getter_t * [T * & next, T * & prev] ( T & )
@@ -237,5 +237,5 @@
 
 #ifdef __cforall
-	forall(dtype T )
+	forall(T & )
 	static inline [void] ?{}( __dllist(T) & this, * [T * & next, T * & prev] ( T & ) __get ) {
 		(this.head){ 0p };
@@ -245,5 +245,5 @@
 	#define next 0
 	#define prev 1
-	static inline forall(dtype T) {
+	static inline forall(T &) {
 		void push_front( __dllist(T) & this, T & node ) with( this ) {
 			verify(__get);
Index: libcfa/src/bits/queue.hfa
===================================================================
--- libcfa/src/bits/queue.hfa	(revision a7aea7d762e94109be8ad28e8cd35350fc5c528c)
+++ libcfa/src/bits/queue.hfa	(revision fd54fef231baeeb0016103bf19cc8e6d87287faf)
@@ -9,5 +9,5 @@
 // instead of being null.
 
-forall( dtype T | { T *& Next ( T * ); } ) {
+forall( T & | { T *& Next ( T * ); } ) {
 	struct Queue {
 		inline Collection;								// Plan 9 inheritance
@@ -151,5 +151,5 @@
 } // distribution
 
-forall( dtype T | { T *& Next ( T * ); } ) {
+forall( T & | { T *& Next ( T * ); } ) {
 	struct QueueIter {
 		inline ColIter;									// Plan 9 inheritance
Index: libcfa/src/bits/sequence.hfa
===================================================================
--- libcfa/src/bits/sequence.hfa	(revision a7aea7d762e94109be8ad28e8cd35350fc5c528c)
+++ libcfa/src/bits/sequence.hfa	(revision fd54fef231baeeb0016103bf19cc8e6d87287faf)
@@ -29,5 +29,5 @@
 
 	// // wrappers to make Collection have T
-	// forall( dtype T ) {
+	// forall( T & ) {
 	// 	T *& Back( T * n ) {
 	// 		return (T *)Back( (Seqable *)n );
@@ -43,5 +43,5 @@
 // and the back field of the last node points at the first node (circular).
 
-forall( dtype T | { T *& Back ( T * ); T *& Next ( T * ); } ) {
+forall( T & | { T *& Back ( T * ); T *& Next ( T * ); } ) {
 	struct Sequence {
 		inline Collection;								// Plan 9 inheritance
@@ -231,5 +231,5 @@
 } // distribution
 
-forall( dtype T | { T *& Back ( T * ); T *& Next ( T * ); } ) {
+forall( T & | { T *& Back ( T * ); T *& Next ( T * ); } ) {
 	// SeqIter(T) is used to iterate over a Sequence(T) in head-to-tail order.
 	struct SeqIter {
Index: libcfa/src/bits/stack.hfa
===================================================================
--- libcfa/src/bits/stack.hfa	(revision a7aea7d762e94109be8ad28e8cd35350fc5c528c)
+++ libcfa/src/bits/stack.hfa	(revision fd54fef231baeeb0016103bf19cc8e6d87287faf)
@@ -9,5 +9,5 @@
 // instead of being null.
 
-forall( dtype T | { T *& Next ( T * ); } ) {
+forall( T & | { T *& Next ( T * ); } ) {
 	struct Stack {
 		inline Collection;								// Plan 9 inheritance
@@ -67,5 +67,5 @@
 // order returned by drop().
 
-forall( dtype T | { T *& Next ( T * ); } ) {
+forall( T & | { T *& Next ( T * ); } ) {
 	struct StackIter {
 		inline ColIter;									// Plan 9 inheritance