Index: libcfa/src/bits/collection.hfa
===================================================================
--- libcfa/src/bits/collection.hfa	(revision 1e6f632fe210f10e8a5aeaa25a8be00593f7e333)
+++ libcfa/src/bits/collection.hfa	(revision 9536761620f1bf08b5d833198057a1e1aa2e5857)
@@ -68,5 +68,5 @@
 
 struct ColIter {
-	void * curr;										// element to be returned by >>
+	void * curr;										// element returned by |
 };
 
Index: libcfa/src/bits/queue.hfa
===================================================================
--- libcfa/src/bits/queue.hfa	(revision 1e6f632fe210f10e8a5aeaa25a8be00593f7e333)
+++ libcfa/src/bits/queue.hfa	(revision 9536761620f1bf08b5d833198057a1e1aa2e5857)
@@ -2,4 +2,10 @@
 
 #include "bits/collection.hfa"
+
+// A Queue(T) is a Collection(T) defining the ordering that nodes are returned by drop() in the same order from those
+// added by add(). T must be a public descendant of uColable.
+
+// The implementation is a typical singly-linked list, except the next field of the last element points to itself
+// instead of being null.
 
 forall( dtype T | { T *& Next ( T * ); } ) {
@@ -108,5 +114,5 @@
 		} // post: ! listed( n )
 
-		T & dropTail( Queue(T) & q ) with( q ) { // O(n)
+		T & dropTail( Queue(T) & q ) with( q ) {		// O(n)
 			T & n = tail( q );
 			return &n ? remove( q, n ), n : *0p;
@@ -155,5 +161,5 @@
 		} // post: curr == 0p
 
-		// create an iterator active in Queue q
+		// create an iterator active in queue q
 		void ?{}( QueueIter(T) & qi, Queue(T) & q ) with( qi ) {
 			curr = &head( q );
@@ -164,10 +170,10 @@
 		} // post: curr = {e in q}
 
-		// make existing iterator active in Queue q
+		// make existing iterator active in queue q
 		void over( QueueIter(T) & qi, Queue(T) & q ) with( qi ) {
 			curr = &head( q );
 		} // post: curr = {e in q}
 
-		bool ?>>?( QueueIter(T) & qi, T && tp ) with( qi ) {
+		bool ?|?( QueueIter(T) & qi, T && tp ) with( qi ) {
 			if ( curr ) {
 				&tp = Curr( qi );
@@ -177,5 +183,5 @@
 			return &tp != 0p;
 		}
-		// post: elts == null & !operator>>(tp) | elts != null & *tp' in elts & elts' == elts - *tp & operator>>(tp)
+		// post: elts == null & !operator|(tp) | elts != null & *tp' in elts & elts' == elts - *tp & operator|(tp)
 	} // distribution
 } // distribution
Index: libcfa/src/bits/sequence.hfa
===================================================================
--- libcfa/src/bits/sequence.hfa	(revision 1e6f632fe210f10e8a5aeaa25a8be00593f7e333)
+++ libcfa/src/bits/sequence.hfa	(revision 9536761620f1bf08b5d833198057a1e1aa2e5857)
@@ -36,4 +36,11 @@
 } // distribution
 
+
+// A Sequence(T) is a Collection(T) defining the ordering of a uStack and uQueue, and to insert and remove elements
+// anywhere in the sequence. T must be a public descendant of uSeqable.
+
+// The implementation is a typical doubly-linked list, except the next field of the last node points at the first node
+// and the back field of the last node points at the first node (circular).
+
 forall( dtype T | { T *& Back ( T * ); T *& Next ( T * ); } ) {
 	struct Sequence {
@@ -52,7 +59,7 @@
 		void ?{}( Sequence(T) & s ) with( s ) {	
 			((Collection &)s){};
-		}	// post: isEmpty().
-
-		// Return a pointer to the last sequence element, without removing it.	
+		}	// post: isEmpty()
+
+		// Return a pointer to the last sequence element, without removing it.
 		T & tail( Sequence(T) & s ) with( s ) {
 			return root ? (T &)*Back( &head( s ) ) : *0p;
@@ -67,5 +74,5 @@
 		} // post: n == tail() & succ(n) == 0 | n != tail() & *succ(n) in *s
 
-		// Return a pointer to the element before *n, or 0p if there isn't one.
+		// Return a pointer to the element before *n, or 0p if list empty.
 		T * pred( Sequence(T) & s, T * n ) with( s ) {	// pre: *n in *s
 			#ifdef __CFA_DEBUG__
@@ -73,8 +80,8 @@
 			#endif // __CFA_DEBUG__
 			return n == &head( s ) ? 0p : Back( n );
-		}	// post: n == head() & head(n) == 0 | n != head() & *pred(n) in *s
-
-
-		// Insert *n into the sequence before *bef, or at the end if bef == 0.
+		} // post: n == head() & head(n) == 0 | n != head() & *pred(n) in *s
+
+
+		// Insert *n into the sequence before *bef, or at the end if bef == 0p.
 		T & insertBef( Sequence(T) & s, T & n, T & bef ) with( s ) { // pre: !n->listed() & *bef in *s
 			#ifdef __CFA_DEBUG__
@@ -137,5 +144,5 @@
 			} // if
 			return n;
-		}	  // post: n->listed() & *n in *s & succ(n) == bef
+		} // post: n->listed() & *n in *s & succ(n) == bef
 		
 		// pre: n->listed() & *n in *s
@@ -152,5 +159,5 @@
 			Next( &n ) = Back( &n ) = 0p;
 			return n;
-		}							// post: !n->listed().
+		} // post: !n->listed()
 
 		// Add an element to the head of the sequence.
@@ -158,12 +165,15 @@
 			return insertAft( s, *0p, n );
 		}
+
 		// Add an element to the tail of the sequence.
 		T & addTail( Sequence(T) & s, T & n ) {			// pre: !n->listed(); post: n->listed() & head() == n
 			return insertBef( s, n, *0p );
 		}
+
 		// Add an element to the tail of the sequence.
 		T & add( Sequence(T) & s, T & n ) {				// pre: !n->listed(); post: n->listed() & head() == n
 			return addTail( s, n );
 		}
+
 		// Remove and return the head element in the sequence.
 		T & dropHead( Sequence(T) & s ) {
@@ -171,8 +181,10 @@
 			return &n ? remove( s, n ), n : *0p;
 		}
+
 		// Remove and return the head element in the sequence.
 		T & drop( Sequence(T) & s ) {
 			return dropHead( s );
 		}
+
 		// Remove and return the tail element in the sequence.
 		T & dropTail( Sequence(T) & s ) {
@@ -233,11 +245,12 @@
 			((ColIter &)si){};
 			seq = 0p;
-		} // post: elts = null.
-
+		} // post: elts = null
+
+		// Create a iterator active in sequence s.
 		void ?{}( SeqIter(T) & si, Sequence(T) & s ) with( si ) {
 			((ColIter &)si){};
 			seq = &s;
 			curr = &head( s );
-		} // post: elts = null.
+		} // post: elts = null
 
 		void ?{}( SeqIter(T) & si, Sequence(T) & s, T & start ) with( si ) {
@@ -245,12 +258,13 @@
 			seq = &s;
 			curr = &start;
-		} // post: elts = null.
-
+		} // post: elts = null
+
+		// Make the iterator active in sequence s.
 		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 ) {
+		} // post: elts = {e in s}
+
+		bool ?|?( SeqIter(T) & si, T && tp ) with( si ) {
 			if ( curr ) {
 				&tp = Curr( si );
@@ -274,11 +288,12 @@
 			((ColIter &)si){};
 			seq = 0p;
-		} // post: elts = null.
-
+		} // post: elts = null
+
+		// Create a iterator active in sequence s.
 		void ?{}( SeqIterRev(T) & si, Sequence(T) & s ) with( si ) {	
 			((ColIter &)si){};
 			seq = &s;
 			curr = &tail( s );
-		} // post: elts = null.
+		} // post: elts = null
 
 		void ?{}( SeqIterRev(T) & si, Sequence(T) & s, T & start ) with( si ) {	
@@ -286,12 +301,13 @@
 			seq = &s;
 			curr = &start;
-		} // post: elts = null.
-
+		} // post: elts = null
+
+		// Make the iterator active in sequence s.
 		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 ) {
+		} // post: elts = {e in s}
+
+		bool ?|?( SeqIterRev(T) & si, T && tp ) with( si ) {
 			if ( curr ) {
 				&tp = Curr( si );
Index: libcfa/src/bits/stack.hfa
===================================================================
--- libcfa/src/bits/stack.hfa	(revision 1e6f632fe210f10e8a5aeaa25a8be00593f7e333)
+++ libcfa/src/bits/stack.hfa	(revision 9536761620f1bf08b5d833198057a1e1aa2e5857)
@@ -2,4 +2,10 @@
 
 #include "bits/collection.hfa"
+
+// A Stack(T) is a Collection(T) defining the ordering that nodes are returned by drop() in the reverse order from those
+// added by add(). T must be a public descendant of uColable.
+
+// The implementation is a typical singly-linked list, except the next field of the last element points to itself
+// instead of being null.
 
 forall( dtype T | { T *& Next ( T * ); } ) {
@@ -58,4 +64,6 @@
 } // distribution
 
+// A StackIter(T) is a subclass of ColIter(T) that generates the elements of a Stack(T).  It returns the elements in the
+// order returned by drop().
 
 forall( dtype T | { T *& Next ( T * ); } ) {
@@ -69,5 +77,5 @@
 		} // post: curr == 0p
 
-		// create an iterator active in Stack s
+		// create an iterator active in stack s
 		void ?{}( StackIter(T) & si, Stack(T) & s ) with( si ) {
 			curr = &head( s );
@@ -78,10 +86,10 @@
 		} // post: curr = {e in s}
 
-		// make existing iterator active in Stack q
+		// make existing iterator active in stack s
 		void over( StackIter(T) & si, Stack(T) & s ) with( si ) {
 			curr = &head( s );
 		} // post: curr = {e in s}
 
-		bool ?>>?( StackIter(T) & si, T && tp ) with( si ) {
+		bool ?|?( StackIter(T) & si, T && tp ) with( si ) {
 			if ( curr ) {
 				&tp = Curr( si );