Index: libcfa/src/bits/collection.hfa
===================================================================
--- libcfa/src/bits/collection.hfa	(revision b37515b1c02ee9d9ba7d60b5f6bee246234cde78)
+++ libcfa/src/bits/collection.hfa	(revision cc5cc27711f848c820ed0de9ac1b5f643d4d011f)
@@ -13,5 +13,5 @@
 	// return true iff *this is an element of a collection
 	bool listed( Colable & co ) with( co ) {			// pre: this != 0
-		return next != 0;
+		return next != 0p;
 	}
 
@@ -23,5 +23,16 @@
 		return cp->next;
 	}
+
+	forall( dtype T ) {
+		T *& Next( T * n ) {
+			return (T *)Next( (Colable *)n );
+		}
+
+		bool listed( T * n ) {
+			return Next( (Colable *)n ) != 0p;
+		}
+	} // distribution
 } // distribution
+
 
 struct Collection {
@@ -41,4 +52,5 @@
 		return root == 0p;
 	}
+
 	void * head( Collection & collection ) with( collection ) {
 		return root;
@@ -55,3 +67,9 @@
 		curr = 0p;
 	} // post: elts = null
+
+	forall( dtype T ) {
+		T * Curr( ColIter & ci ) with( ci ) {
+			return (T *)curr;
+		}
+	} // distribution
 } // distribution
Index: libcfa/src/bits/queue.hfa
===================================================================
--- libcfa/src/bits/queue.hfa	(revision b37515b1c02ee9d9ba7d60b5f6bee246234cde78)
+++ libcfa/src/bits/queue.hfa	(revision cc5cc27711f848c820ed0de9ac1b5f643d4d011f)
@@ -14,20 +14,4 @@
 			return (T *)head( (Collection &)q );
 		} // post: empty() & head() == 0 | !empty() & head() in *q
-
-		bool empty( Queue(T) & q ) with( q ) {			// 0 <=> *q contains no elements
-			return empty( (Collection &)q );
-		}
-
-		bool listed( T * n ) {
-			return Next( (Colable *)n ) != 0;
-		}
-
-		T *& Next( T * n ) {
-			return (T *)Next( (Colable *)n );
-		}
-
-		T * Root( Queue(T) & q ) with( q ) {
-			return (T *)root;
-		}
 
 		void ?{}( Queue(T) &, const Queue(T) & ) = void; // no copy
@@ -55,5 +39,5 @@
 #endif // __CFA_DEBUG__
 			if ( last ) {
-				Next( n ) = Root( q );
+				Next( n ) = head( q );
 				q.root = n;
 			} else {
@@ -81,5 +65,5 @@
 			if ( root ) {
 				root = Next( root );
-				if ( Root( q ) == t ) {
+				if ( head( q ) == t ) {
 					root = last = 0p;					// only one element
 				}
@@ -132,5 +116,5 @@
 				root = from.root;
 			} else {									// "to" list not empty
-				Next( last ) = Root( from );
+				Next( last ) = head( from );
 			}
 			last = from.last;
@@ -148,5 +132,5 @@
 			to.last = n;								// end of "to" list
 			from.root = Next( n );						// start of "from" list
-			if ( n == Root( from ) ) {					// last node in list ?
+			if ( n == head( from ) ) {					// last node in list ?
 				from.root = from.last = 0p;				// mark "from" list empty
 			} else {
@@ -164,9 +148,4 @@
 
 	inline {
-		// wrappers to make ColIter have T
-		T * Curr( QueueIter(T) & qi ) with( qi ) {
-			return (T *)curr;
-		}
-
 		void ?{}( QueueIter(T) & qi ) with( qi ) {
 			((ColIter &)qi){};
Index: libcfa/src/bits/sequence.hfa
===================================================================
--- libcfa/src/bits/sequence.hfa	(revision b37515b1c02ee9d9ba7d60b5f6bee246234cde78)
+++ libcfa/src/bits/sequence.hfa	(revision cc5cc27711f848c820ed0de9ac1b5f643d4d011f)
@@ -10,5 +10,5 @@
 inline {
 	void ?{}( Seqable & sq ) with( sq ) {
-		((Colable & ) sq){};
+		((Colable &) sq){};
 		back = 0p;
 	} // post: ! listed()
@@ -34,22 +34,6 @@
 		} // post: empty() & head() == 0 | !empty() & head() in *s
 
-		bool empty( Sequence(T) & s ) with( s ) {		// 0 <=> *s contains no elements
-			return empty( (Collection &)s );
-		}
-
-		bool listed( T * n ) {
-			return Next( (Colable *)n ) != 0;
-		}
-
-		T *& Next( T * n ) {
-			return (T *)Next( (Colable *)n );
-		}
-
 		T *& Back( T * n ) {
 			return (T *)Back( (Seqable *)n );
-		}
-
-		T * Root( Sequence(T) & s ) with( s ) {
-			return (T *)root;
 		}
 
@@ -63,5 +47,5 @@
 		// Return a pointer to the last sequence element, without removing it.	
 		T & tail( Sequence(T) & s ) with( s ) {
-			return root ? (T &)Back( Root( s ) ) : *0p;	// needs cast?
+			return root ? (T &)Back( head( s ) ) : *0p;	// needs cast?
 		}	// post: empty() & tail() == 0 | !empty() & tail() in *s
 
@@ -71,5 +55,5 @@
 			if ( ! listed( n ) ) abort( "(Sequence &)%p.succ( %p ) : Node is not on a list.", &s, n );
 #endif // __CFA_DEBUG__
-			return Next( n ) == Root( s ) ? 0p : Next( n );
+			return Next( n ) == head( s ) ? 0p : Next( n );
 		}	// post: n == tail() & succ(n) == 0 | n != tail() & *succ(n) in *s
 
@@ -79,5 +63,5 @@
 			if ( ! listed( n ) ) abort( "(Sequence &)%p.pred( %p ) : Node is not on a list.", &s, n );
 #endif // __CFA_DEBUG__
-			return n == Root( s ) ? 0p : Back( n );
+			return n == head( s ) ? 0p : Back( n );
 		}	// post: n == head() & head(n) == 0 | n != head() & *pred(n) in *s
 
@@ -88,11 +72,11 @@
 			if ( listed( &n ) ) abort( "(Sequence &)%p.insertBef( %p, %p ) : Node is already on another list.", &s, n, &bef );
 #endif // __CFA_DEBUG__
-			if ( &bef == Root( s ) ) {					// must change root
+			if ( &bef == head( s ) ) {					// must change root
 				if ( root ) {
-					Next( &n ) = Root( s );
-					Back( &n ) = Back( Root( s ) );
+					Next( &n ) = head( s );
+					Back( &n ) = Back( head( s ) );
 					// inserted node must be consistent before it is seen
 					asm( "" : : : "memory" );			// prevent code movement across barrier
-					Back( Root( s ) ) = &n;
+					Back( head( s ) ) = &n;
 					Next( Back( &n ) ) = &n;
 				} else {
@@ -104,5 +88,5 @@
 				root = &n;
 			} else {
-				if ( ! &bef ) &bef = Root( s );
+				if ( ! &bef ) &bef = head( s );
 				Next( &n ) = &bef;
 				Back( &n ) = Back( &bef );
@@ -122,9 +106,9 @@
 			if ( ! &aft ) {								// must change root
 				if ( root ) {
-					Next( &n ) = Root( s );
-					Back( &n ) = Back( Root( s ) );
+					Next( &n ) = head( s );
+					Back( &n ) = Back( head( s ) );
 					// inserted node must be consistent before it is seen
 					asm( "" : : : "memory" );			// prevent code movement across barrier
-					Back( Root( s ) ) = &n;
+					Back( head( s ) ) = &n;
 					Next( Back( &n ) ) = &n;
 				} else {
@@ -149,7 +133,7 @@
 			if ( ! listed( &n ) ) abort( "(Sequence &)%p.remove( %p ) : Node is not on a list.", &s, &n );
 #endif // __CFA_DEBUG__
-			if ( &n == Root( s ) ) {
-				if ( Next( Root( s ) ) == Root( s ) ) root = 0p;
-				else root = Next( Root(s ) );
+			if ( &n == head( s ) ) {
+				if ( Next( head( s ) ) == head( s ) ) root = 0p;
+				else root = Next( head(s ) );
 			} // if
 			Back( Next( &n ) ) = Back( &n );
@@ -191,10 +175,10 @@
 				root = from.root;
 			} else {									// "to" list not empty
-				T * toEnd = Back( Root( s ) );
-				T * fromEnd = Back( Root( from ) );
+				T * toEnd = Back( head( s ) );
+				T * fromEnd = Back( head( from ) );
 				Back( root ) = fromEnd;
-				Next( fromEnd ) = Root( s );
+				Next( fromEnd ) = head( s );
 				Back( from.root ) = toEnd;
-				Next( toEnd ) = Root( from );
+				Next( toEnd ) = head( from );
 			} // if
 			from.root = 0p;								// mark "from" list empty
@@ -213,8 +197,8 @@
 				from.root = 0p;							// mark "from" list empty
 			} else {
-				Back( Root( from ) ) = Back( Root( to ) ); // fix "from" list
-		 		Next( Back( Root( to ) ) ) = Root( from );
-				Next( n ) = Root( to );					// fix "to" list
-				Back( Root( to ) ) = n;
+				Back( head( from ) ) = Back( head( to ) ); // fix "from" list
+		 		Next( Back( head( to ) ) ) = head( from );
+				Next( n ) = head( to );					// fix "to" list
+				Back( head( to ) ) = n;
 			} // if
 			transfer( s, to );
@@ -231,11 +215,6 @@
 
 	inline {
-		// wrappers to make ColIter have T
-		T * Curr( SeqIter(T) & si ) with( si ) {
-			return (T *)curr;
-		}
-
-		void ?{}( SeqIter(T) & si ) with( si ) {	
-			((ColIter &) si){};
+		void ?{}( SeqIter(T) & si ) with( si ) {
+			((ColIter &)si){};
 			seq = 0p;
 		} // post: elts = null.
@@ -270,9 +249,4 @@
 
 	inline {
-		// wrappers to make ColIter have T
-		T * Curr( SeqIterRev(T) & si ) with( si ) {
-			return (T *)curr;
-		}
-
 		void ?{}( SeqIterRev(T) & si ) with( si ) {	
 			((ColIter &) si){};
Index: libcfa/src/bits/stack.hfa
===================================================================
--- libcfa/src/bits/stack.hfa	(revision b37515b1c02ee9d9ba7d60b5f6bee246234cde78)
+++ libcfa/src/bits/stack.hfa	(revision cc5cc27711f848c820ed0de9ac1b5f643d4d011f)
@@ -14,16 +14,4 @@
 		} // post: empty() & head() == 0 | !empty() & head() in *this
 
-		bool empty( Stack(T) & s ) with( s ) {			// 0 <=> *this contains no elements
-			return empty( (Collection &)s );
-		}
-
-		T *& Next( T * n ) {
-			return (T *)Next( (Colable *)n );
-		}
-
-		T * Root( Stack(T) & s ) with( s ) {
-			return (T *)root;
-		}
-
 		void ?{}( Stack(T) &, const Stack(T) & ) = void; // no copy
 		Stack(T) & ?=?( const Stack(T) & ) = void;		// no assignment
@@ -33,35 +21,35 @@
 		} // post: empty()
 
-		T * top( Stack(T) & s ) with( s ) {
-			return head( s );
+		T & top( Stack(T) & s ) with( s ) {
+			return *head( s );
 		}
 
-		void addHead( Stack(T) & s, T * n ) with( s ) {
+		void addHead( Stack(T) & s, T & n ) with( s ) {
 #ifdef __CFA_DEBUG__
-			if ( listed( (Colable &)(*n) ) ) abort( "(Stack &)%p.addHead( %p ) : Node is already on another list.", &s, n );
+			if ( listed( (Colable &)(n) ) ) abort( "(Stack &)%p.addHead( %p ) : Node is already on another list.", &s, n );
 #endif // __CFA_DEBUG__
-			Next( n ) = Root( s ) ? Root( s ) : n;
-			root = n;
+			Next( &n ) = head( s ) ? head( s ) : &n;
+			root = &n;
 		}
 
-		void add( Stack(T) & s, T * n ) with( s ) {
+		void add( Stack(T) & s, T & n ) with( s ) {
 			addHead( s, n );
 		}
 
-		void push( Stack(T) & s, T * n ) with( s ) {
+		void push( Stack(T) & s, T & n ) with( s ) {
 			addHead( s, n );
 		}
 
-		T * drop( Stack(T) & s ) with( s ) {
-			T * t = head( s );
+		T & drop( Stack(T) & s ) with( s ) {
+			T & t = *head( s );
 			if ( root ) {
 				root = ( T *)Next(root);
-				if ( Root( s ) == t ) root = 0p;		// only one element ?
-				Next( t ) = 0p;
+				if ( head( s ) == &t ) root = 0p;		// only one element ?
+				Next( &t ) = 0p;
 			} // if
 			return t;
 		}
 
-		T * pop( Stack(T) & s ) with( s ) {
+		T & pop( Stack(T) & s ) with( s ) {
 			return drop( s );
 		}
@@ -76,9 +64,4 @@
 
 	inline {
-		// wrappers to make ColIter have T
-		T * Curr( StackIter(T) & si ) with( si ) {
-			return (T *)curr;
-		}
-
 		void ?{}( StackIter(T) & si ) with( si ) {
 			((ColIter &)si){};
@@ -90,6 +73,6 @@
 		} // post: curr = {e in s}
 
-		void ?{}( StackIter(T) & si, T * start ) with( si ) {
-			curr = start;
+		void ?{}( StackIter(T) & si, T & start ) with( si ) {
+			curr = &start;
 		} // post: curr = {e in s}
 
@@ -103,5 +86,5 @@
 				&tp = Curr( si );
 				T * n = Next( Curr( si ) );
-				curr = (n == Curr( si ) ) ? 0p : n;
+				curr = n == Curr( si ) ? 0p : n;
 			} else &tp = 0p;
 			return &tp != 0p;
Index: libcfa/src/bits/stack_example.cfa
===================================================================
--- libcfa/src/bits/stack_example.cfa	(revision b37515b1c02ee9d9ba7d60b5f6bee246234cde78)
+++ libcfa/src/bits/stack_example.cfa	(revision cc5cc27711f848c820ed0de9ac1b5f643d4d011f)
@@ -27,5 +27,5 @@
 	
 	for ( i; 10 ) {
-		push( fred, new( 2 * i ) );
+		push( fred, *new( 2 * i ) );
 	}
 
@@ -36,5 +36,5 @@
 	
 	for ( i; 9 ) {
-		delete( pop( fred ) );
+		delete( &pop( fred ) );
 	}
 
@@ -45,5 +45,5 @@
 	
 	for ( i; 10 ) {
-		push( fred, new( 2 * i + 1 ) );
+		push( fred, *new( 2 * i + 1 ) );
 	}
 	for ( over( fredIter, fred ); fredIter >> f; ) {
@@ -78,5 +78,5 @@
 	
 	for ( i; 10 ) {
-		push( mary, new( 2 * i ) );
+		push( mary, *new( 2 * i ) );
 	}
 
@@ -87,5 +87,5 @@
 	
 	for ( i; 9 ) {
-		delete( pop( mary ) );
+		delete( &pop( mary ) );
 	}
 
@@ -96,5 +96,5 @@
 	
 	for ( i; 10 ) {
-		push( mary, new( 2 * i + 1 ) );
+		push( mary, *new( 2 * i + 1 ) );
 	}
 	for ( over( maryIter, mary ); maryIter >> m; ) {