Index: libcfa/src/bits/sequence.hfa
===================================================================
--- libcfa/src/bits/sequence.hfa	(revision e43aa144c4c08d30a277b5cafc1979cd08ae40af)
+++ libcfa/src/bits/sequence.hfa	(revision 8a81b092ecea5683a5987e76b0118ed12616f1c4)
@@ -216,88 +216,88 @@
 } // distribution
 
-// forall( dtype T ) {
-// 	// SeqIter(T) is used to iterate over a Sequence(T) in head-to-tail order.
-// 	struct SeqIter {
-// 		inline ColIter;
-// 		// The Sequence must be passed to pred and succ to check for the end of the Sequence and return 0p. Without
-// 		// passing the sequence, traversing would require its length. Thus the iterator needs a pointer to the sequence
-// 		// to pass to succ/pred. Both stack and queue just encounter 0p since the lists are not circular.
-// 		Sequence(T) * seq;								// FIX ME: cannot be reference
-// 	};
-
-// 	static inline {
-// 		void ?{}( SeqIter(T) & si ) with( si ) {
-// 			((ColIter &)si){};
-// 			seq = 0p;
-// 		} // post: elts = null.
-
-// 		void ?{}( SeqIter(T) & si, Sequence(T) & s ) with( si ) {
-// 			((ColIter &)si){};
-// 			seq = &s;
-// 			curr = &head( s );
-// 		} // post: elts = null.
-
-// 		void ?{}( SeqIter(T) & si, Sequence(T) & s, T & start ) with( si ) {
-// 			((ColIter &)si){};
-// 			seq = &s;
-// 			curr = &start;
-// 		} // post: elts = null.
-
-// 		void over( SeqIter(T) & si, Sequence(T) & s ) with( si ) {
-// 			seq = &s;
-// 			curr = &head( s );
-// 		} // post: elts = {e in s}.
-
-// 		bool ?>>?( SeqIter(T) & si, T && tp ) with( si ) {
-// 			if ( curr ) {
-// 				&tp = Curr( si );
-// 				T * n = succ( *seq, Curr( si ) );
-// 				curr = n == &head( *seq ) ? 0p : n;
-// 			} else &tp = 0p;
-// 			return &tp != 0p;
-// 		}
-// 	} // distribution
-
-
-// 	// A SeqIterRev(T) is used to iterate over a Sequence(T) in tail-to-head order.
-// 	struct SeqIterRev {
-// 		inline ColIter;
-// 		// See above for explanation.
-// 		Sequence(T) * seq;								// FIX ME: cannot be reference
-// 	};
-
-// 	static inline {
-// 		void ?{}( SeqIterRev(T) & si ) with( si ) {	
-// 			((ColIter &)si){};
-// 			seq = 0p;
-// 		} // post: elts = null.
-
-// 		void ?{}( SeqIterRev(T) & si, Sequence(T) & s ) with( si ) {	
-// 			((ColIter &)si){};
-// 			seq = &s;
-// 			curr = &tail( s );
-// 		} // post: elts = null.
-
-// 		void ?{}( SeqIterRev(T) & si, Sequence(T) & s, T & start ) with( si ) {	
-// 			((ColIter &)si){};
-// 			seq = &s;
-// 			curr = &start;
-// 		} // post: elts = null.
-
-// 		void over( SeqIterRev(T) & si, Sequence(T) & s ) with( si ) {
-// 			seq = &s;
-// 			curr = &tail( s );
-// 		} // post: elts = {e in s}.
-
-// 		bool ?>>?( SeqIterRev(T) & si, T && tp ) with( si ) {
-// 			if ( curr ) {
-// 				&tp = Curr( si );
-// 				T * n = pred( *seq, Curr( si ) );
-// 				curr = n == &tail( *seq ) ? 0p : n;
-// 			} else &tp = 0p;
-// 			return &tp != 0p;
-// 		}
-// 	} // distribution
-// } // distribution
+forall( dtype T | { T *& Back ( T * ); T *& Next ( T * ); bool listed ( T * ); } ) {
+	// SeqIter(T) is used to iterate over a Sequence(T) in head-to-tail order.
+	struct SeqIter {
+		inline ColIter;
+		// The Sequence must be passed to pred and succ to check for the end of the Sequence and return 0p. Without
+		// passing the sequence, traversing would require its length. Thus the iterator needs a pointer to the sequence
+		// to pass to succ/pred. Both stack and queue just encounter 0p since the lists are not circular.
+		Sequence(T) * seq;								// FIX ME: cannot be reference
+	};
+
+	static inline {
+		void ?{}( SeqIter(T) & si ) with( si ) {
+			((ColIter &)si){};
+			seq = 0p;
+		} // post: elts = null.
+
+		void ?{}( SeqIter(T) & si, Sequence(T) & s ) with( si ) {
+			((ColIter &)si){};
+			seq = &s;
+			curr = &head( s );
+		} // post: elts = null.
+
+		void ?{}( SeqIter(T) & si, Sequence(T) & s, T & start ) with( si ) {
+			((ColIter &)si){};
+			seq = &s;
+			curr = &start;
+		} // post: elts = null.
+
+		void over( SeqIter(T) & si, Sequence(T) & s ) with( si ) {
+			seq = &s;
+			curr = &head( s );
+		} // post: elts = {e in s}.
+
+		bool ?>>?( SeqIter(T) & si, T && tp ) with( si ) {
+			if ( curr ) {
+				&tp = Curr( si );
+				T * n = succ( *seq, Curr( si ) );
+				curr = n == &head( *seq ) ? 0p : n;
+			} else &tp = 0p;
+			return &tp != 0p;
+		}
+	} // distribution
+
+
+	// A SeqIterRev(T) is used to iterate over a Sequence(T) in tail-to-head order.
+	struct SeqIterRev {
+		inline ColIter;
+		// See above for explanation.
+		Sequence(T) * seq;								// FIX ME: cannot be reference
+	};
+
+	static inline {
+		void ?{}( SeqIterRev(T) & si ) with( si ) {	
+			((ColIter &)si){};
+			seq = 0p;
+		} // post: elts = null.
+
+		void ?{}( SeqIterRev(T) & si, Sequence(T) & s ) with( si ) {	
+			((ColIter &)si){};
+			seq = &s;
+			curr = &tail( s );
+		} // post: elts = null.
+
+		void ?{}( SeqIterRev(T) & si, Sequence(T) & s, T & start ) with( si ) {	
+			((ColIter &)si){};
+			seq = &s;
+			curr = &start;
+		} // post: elts = null.
+
+		void over( SeqIterRev(T) & si, Sequence(T) & s ) with( si ) {
+			seq = &s;
+			curr = &tail( s );
+		} // post: elts = {e in s}.
+
+		bool ?>>?( SeqIterRev(T) & si, T && tp ) with( si ) {
+			if ( curr ) {
+				&tp = Curr( si );
+				T * n = pred( *seq, Curr( si ) );
+				curr = n == &tail( *seq ) ? 0p : n;
+			} else &tp = 0p;
+			return &tp != 0p;
+		}
+	} // distribution
+} // distribution
 
 #endif