Index: libcfa/src/bits/collection.hfa
===================================================================
--- libcfa/src/bits/collection.hfa	(revision 8b7352618c5c27061e25855af7388ced3d4af11e)
+++ libcfa/src/bits/collection.hfa	(revision e43aa144c4c08d30a277b5cafc1979cd08ae40af)
@@ -1,10 +1,12 @@
 #pragma once
+#include <stdio.h> // REMOVE THIS AFTER DEBUGGING
+
 
 struct Colable {
-	Colable * next;										// next node in the list
+	struct Colable * next;										// next node in the list
 	// invariant: (next != 0) <=> listed()
 };
-
-inline {
+#ifdef __cforall
+static inline {
 	// PUBLIC
 
@@ -28,14 +30,15 @@
 	}
 
-	// wrappers to make Collection have T
-	forall( dtype T ) {
-		T *& Next( T * n ) {
-			return (T *)Next( (Colable *)n );
-		}
+	// // wrappers to make Collection have T
+	// forall( dtype T ) {
+	// 	T *& Next( T * n ) {
+	// 		return (T *)Next( (Colable *)n );
+	// 	}
 
-		bool listed( T * n ) {
-			return Next( (Colable *)n ) != 0p;
-		}
-	} // distribution
+	// 	bool listed( T * n ) {
+	// 		fprintf(stderr, "inappropriate listed used");
+	// 		return Next( (Colable *)n ) != 0p;
+	// 	}
+	// } // distribution
 } // distribution
 
@@ -45,5 +48,5 @@
 };
 
-inline {
+static inline {
 	// class invariant: root == 0 & empty() | *root in *this
 	void ?{}( Collection &, const Collection & ) = void; // no copy
@@ -68,5 +71,5 @@
 };
 
-inline {
+static inline {
 	void ?{}( ColIter & colIter ) with( colIter ) {
 		curr = 0p;
@@ -79,2 +82,3 @@
 	} // distribution
 } // distribution
+#endif
Index: libcfa/src/bits/sequence.hfa
===================================================================
--- libcfa/src/bits/sequence.hfa	(revision 8b7352618c5c27061e25855af7388ced3d4af11e)
+++ libcfa/src/bits/sequence.hfa	(revision e43aa144c4c08d30a277b5cafc1979cd08ae40af)
@@ -2,11 +2,13 @@
 
 #include "bits/collection.hfa"
+#include "bits/defs.hfa"
 
 struct Seqable {
-	inline Colable;
-	Seqable * back;										// pointer to previous node in the list
+	__cfa_anonymous_object(Colable);
+	struct Seqable * back;										// pointer to previous node in the list
 };
 
-inline {
+#ifdef __cforall
+static inline {
 	// PUBLIC
 
@@ -26,18 +28,18 @@
 	}
 
-	// wrappers to make Collection have T
-	forall( dtype T ) {
-		T *& Back( T * n ) {
-			return (T *)Back( (Seqable *)n );
-		}
-	} // distribution
+	// // wrappers to make Collection have T
+	// forall( dtype T ) {
+	// 	T *& Back( T * n ) {
+	// 		return (T *)Back( (Seqable *)n );
+	// 	}
+	// } // distribution
 } // distribution
 
-forall( dtype T ) {
+forall( dtype T | { T *& Back ( T * ); T *& Next ( T * ); bool listed ( T * ); } ) {
 	struct Sequence {
 		inline Collection;								// Plan 9 inheritance
 	};
 
-	inline {
+	static inline {
 		// wrappers to make Collection have T
 		T & head( Sequence(T) & s ) with( s ) {
@@ -184,7 +186,7 @@
 				T * toEnd = Back( &head( s ) );
 				T * fromEnd = Back( &head( from ) );
-				Back( root ) = fromEnd;
+				Back( (T *)root ) = fromEnd;
 				Next( fromEnd ) = &head( s );
-				Back( from.root ) = toEnd;
+				Back( (T *)from.root ) = toEnd;
 				Next( toEnd ) = &head( from );
 			} // if
@@ -214,86 +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
-	};
-
-	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
-	};
-
-	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 ) {
+// 	// 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