Index: tests/collections/multi_list.cfa
===================================================================
--- tests/collections/multi_list.cfa	(revision de2f969977d4924d0f35043c08b1b172e7f5af19)
+++ tests/collections/multi_list.cfa	(revision de2f969977d4924d0f35043c08b1b172e7f5af19)
@@ -0,0 +1,113 @@
+#include <fstream.hfa>
+#include <stdlib.hfa>
+#include <bits/stack.hfa>
+#include <bits/queue.hfa>
+#include <bits/sequence.hfa>
+
+struct Task;											// node type
+
+struct TaskDL {
+	inline Seqable;
+	Task & node;
+};
+void ?{}( TaskDL & this, Task & task ) with( this ) {
+	((Seqable &)this){};
+	&node = &task;										// pointer to containing node
+}
+Task & task( TaskDL & this ) with( this ) {				// getter routine for containing node
+	return node;
+}
+
+TaskDL *& Back( TaskDL * n ) {
+	return (TaskDL *)Back( (Seqable *)n );
+}
+
+TaskDL *& Next( TaskDL * n ) {
+	return (TaskDL *)Next( (Colable *)n );
+}
+
+struct TaskSL {
+	inline Colable;
+	Task & node;
+};
+void ?{}( TaskSL & this, Task & task ) with( this ) {
+	((Colable &)this){};
+	&node = &task;										// pointer to containing node
+}
+Task & task( TaskSL & this ) with( this ) {				// getter routine for containing node
+	return node;
+}
+
+TaskSL *& Next( TaskSL * n ) {
+	return (TaskSL *)Next( (Colable *)n );
+}
+
+struct Task {
+	TaskDL clusterRef;									// list of tasks on cluster
+	TaskDL readyRef;									// list of tasks on ready queue
+	TaskSL mutexRef;									// list of tasks on mutex queue
+	int id;
+};
+void ?{}( Task & this, int id ) with( this ) {
+	((TaskDL &)clusterRef){ this };
+	((TaskDL &)readyRef){ this };
+	((TaskSL &)mutexRef){ this };
+	this.id = id;
+}
+
+int main() {
+	Sequence(TaskDL) clustList, readyList;				// task lists
+	Queue(TaskSL) mutexList;
+	enum { Lnth = 10 };
+
+	for ( id; Lnth ) {
+		Task & task = *new( id );						// create task node
+		addHead( clustList, task.clusterRef );			// insert on lists in opposite directions
+		addTail( readyList, task.readyRef );
+		addHead( mutexList, task.mutexRef );
+	}
+
+	SeqIter(TaskDL) sqiter;
+	TaskDL & dl;										// iterator index
+	TaskSL & sl;
+
+	sout | nlOff;
+	for ( over( sqiter, clustList ); sqiter >> dl; ) {	// print lists
+		Task & tmp = task( dl ); sout | tmp.id;
+		// sout | task( dl ).id;
+	}
+	sout | nl;
+	for ( over( sqiter, readyList ); sqiter >> dl; ) {
+		Task & tmp = task( dl ); sout | tmp.id;
+		// sout | task( dl ).id;
+	}
+	sout | nl;
+	for ( QueueIter(TaskSL) qiter = { mutexList }; qiter >> sl; ) {	// print lists
+		Task & tmp = task( sl ); sout | tmp.id;
+		// sout | task( sl ).id;
+	}
+	sout | nl;
+	for ( Lnth ) {										// remove nodes from clustList. mutexList
+		dropHead( clustList );
+		drop( mutexList );
+	}
+	// Simultaneous deletion only safe if all nodes are traversed in same direction.
+	for ( Lnth ) {										// remove nodes from readyList and safe to delete nodes
+		delete( &task( dropHead( readyList ) ) );
+	}
+
+	// Re-purpose Seqable as Colable
+	Stack(TaskDL) mutexStack;
+	for ( id; Lnth ) {
+		Task & task = *new( id );						// create task node
+		push( mutexStack, task.clusterRef );			// insert on lists in opposite directions
+	}
+	for ( StackIter(TaskDL) stiter = { mutexStack }; stiter >> dl; ) {
+		Task & tmp = task( dl ); sout | tmp.id;
+		// sout | task( dl ).id;
+	}
+	sout | nl;
+	for ( Lnth ) {										// remove nodes from readyList and safe to delete nodes
+		delete( &task( pop( mutexStack ) ) );
+	}
+}
Index: tests/collections/queue.cfa
===================================================================
--- tests/collections/queue.cfa	(revision de2f969977d4924d0f35043c08b1b172e7f5af19)
+++ tests/collections/queue.cfa	(revision de2f969977d4924d0f35043c08b1b172e7f5af19)
@@ -0,0 +1,169 @@
+#include <fstream.hfa>
+#include <stdlib.hfa>									// new, delete
+#include <bits/queue.hfa>
+
+int main() {
+	// Fred test
+
+	struct Fred {
+		inline Colable;									// Plan 9 inheritance
+		int i;
+	};
+	void ?{}( Fred & fred ) { abort(); }
+	void ?{}( Fred & fred, int p ) with( fred ) {
+		i = p;
+	}
+	Fred *& Next( Fred * n ) {
+		return (Fred *)Next( (Colable *)n );
+	}
+
+	Queue(Fred) fred;
+	QueueIter(Fred) fredIter = { fred };
+	Fred & f;
+
+	sout | nlOff;										// turn off auto newline
+
+	for ( ; fredIter >> f; ) {							// empty list
+		sout | f.i | ' ';
+	}
+	sout | "empty" | nl;
+	
+	for ( i; 10 ) {
+		add( fred, *new( 2 * i ) );
+	}
+
+	sout | head(fred).i | nl;
+	sout | tail(fred).i | nl;
+
+	for ( QueueIter(Fred) iter = { fred }; iter >> f; ) {
+		sout | f.i | ' ';
+	}
+	sout | nl;
+
+	for ( i; 9 ) {
+		delete( &drop( fred ) );
+	}
+
+	for ( over( fredIter, fred ); fredIter >> f; ) {
+		sout | f.i | ' ';
+	}
+	sout | nl;
+	
+	for ( i; 10 ) {
+		add( fred, *new( 2 * i + 1 ) );
+	}
+
+	Fred * front = new( -1 );
+	addHead( fred, *front );
+	sout | succ( fred, front )->i | nl;
+	remove( fred, *front );
+	delete( front );
+
+	Fred & end = dropTail( fred );
+	delete( &end );
+
+	for ( over( fredIter, fred ); fredIter >> f; ) {
+		sout | f.i | ' ';
+	}
+	sout | nl;
+
+	for ( over( fredIter, fred ); fredIter >> f; ) {
+		delete( &f );
+	}
+
+	Queue(Fred) fred0;
+	Fred * middle;
+	for ( i; 10 ) {
+		if( i == 5) {
+			middle = new( i );
+			add( fred0, *middle );
+			continue;
+		}
+		add( fred0, *new( i ) );
+	}
+
+	for ( QueueIter(Fred) iter = { fred0 }; iter >> f; ) {
+		sout | f.i | ' ';
+	}
+	sout | nl;
+
+	Queue(Fred) fred2;
+
+	split( fred2, fred0, *middle);
+
+	for ( over( fredIter, fred0 ); fredIter >> f; ) {
+		sout | f.i | ' ';
+	}
+	sout | nl;
+
+	for ( over( fredIter, fred2 ); fredIter >> f; ) {
+		sout | f.i | ' ';
+	}
+	sout | nl;
+
+	transfer( fred0, fred2);
+
+	for ( over( fredIter, fred0 ); fredIter >> f; ) {
+		sout | f.i | ' ';
+	}
+	sout | nl;
+
+	for ( over( fredIter, fred0 ); fredIter >> f; ) {
+		delete( &f );
+	}
+
+	// Mary test
+
+	struct Mary {
+		inline Fred;									// Plan 9 inheritance
+		int j;
+	};
+	void ?{}( Mary & mary ) { abort(); }
+	void ?{}( Mary & mary, int p ) with( mary ) {
+		((Fred &)mary){ p };
+		j = i = p;
+	}
+
+	Mary *& Next( Mary * n ) {
+		return (Mary *)Next( (Fred *)n );
+	}
+
+	Queue(Mary) mary;
+	QueueIter(Mary) maryIter = { mary };
+	Mary & m;
+
+	for ( ; maryIter >> m; ) {							// empty list
+		sout | m.i | m.j | ' ';
+	}
+	sout | "empty" | nl;
+	
+	for ( i; 10 ) {
+		add( mary, *new( 2 * i ) );
+	}
+
+	for ( QueueIter(Mary) iter = { mary }; iter >> m; ) {
+		sout | m.i | m.j | ' ';
+	}
+	sout | nl;
+	
+	for ( i; 9 ) {
+		delete( &drop( mary ) );
+	}
+
+	for ( over( maryIter, mary ); maryIter >> m; ) {
+		sout | m.i | m.j | ' ';
+	}
+	sout | nl;
+	
+	for ( i; 10 ) {
+		add( mary, *new( 2 * i + 1 ) );
+	}
+	for ( over( maryIter, mary ); maryIter >> m; ) {
+		sout | m.i | m.j | ' ';
+	}
+	sout | nl;
+
+	for ( over( maryIter, mary ); maryIter >> m; ) {
+		delete( &m );
+	}
+}
Index: tests/collections/sequence.cfa
===================================================================
--- tests/collections/sequence.cfa	(revision de2f969977d4924d0f35043c08b1b172e7f5af19)
+++ tests/collections/sequence.cfa	(revision de2f969977d4924d0f35043c08b1b172e7f5af19)
@@ -0,0 +1,210 @@
+#include <fstream.hfa>
+#include <stdlib.hfa>									// new, delete
+#include <bits/sequence.hfa>
+
+int main() {
+	// Fred test
+
+	struct Fred {
+		inline Seqable;									// Plan 9 inheritance
+		int i;
+	};
+	void ?{}( Fred & fred ) { abort(); }
+	void ?{}( Fred & fred, int p ) with( fred ) {
+		i = p;
+	}
+
+	Fred *& Back( Fred * n ) {
+		return (Fred *)Back( (Seqable *)n );
+	}
+
+	Fred *& Next( Fred * n ) {
+		return (Fred *)Next( (Colable *)n );
+	}
+
+	Sequence(Fred) fred;
+	SeqIter(Fred) fredIter = { fred };
+	Fred & f;
+
+	sout | nlOff;										// turn off auto newline
+
+	for ( ; fredIter >> f; ) {							// empty list
+		sout | f.i | ' ';
+	}
+	sout | "empty" | nl;
+	
+	for ( i; 10 ) {
+		add( fred, *new( 2 * i ) );
+	}
+
+	for ( SeqIter(Fred) iter = { fred }; iter >> f; ) {
+		sout | f.i | ' ';
+	}
+	sout | nl;
+
+	for ( i; 9 ) {
+		delete( &dropHead( fred ) );
+	}
+
+	for ( over( fredIter, fred ); fredIter >> f; ) {
+		sout | f.i | ' ';
+	}
+	sout | nl;
+	
+	for ( i; 10 ) {
+		addTail( fred, *new( 2 * i + 1 ) );
+	}
+	for ( over( fredIter, fred ); fredIter >> f; ) {
+		sout | f.i | ' ';
+	}
+	sout | nl;
+
+	for ( i; 9 ) {
+		delete( &dropTail( fred ) );
+	}
+	for ( over( fredIter, fred ); fredIter >> f; ) {
+		sout | f.i | ' ';
+	}
+	sout | nl;
+
+	for ( over( fredIter, fred ); fredIter >> f; ) {
+		delete( &f );
+	}
+
+	Sequence(Fred) fred0;
+	Fred * middle;
+	for ( i; 10 ) {
+		if( i == 5) {
+			middle = new( i );
+			addHead( fred0, *middle );
+			continue;
+		}
+		addHead( fred0, *new( i ) );
+	}
+
+	for ( SeqIterRev(Fred) iter = { fred0 }; iter >> f; ) {
+		sout | f.i | ' ';
+	}
+	sout | nl;
+
+	Fred * front = new( -1 );
+	insertBef( fred0, *front, tail(fred0));
+	insertAft( fred0, *front, *new( -2 ) );
+	remove( fred0, *front );
+	delete( front );
+
+	sout | head(fred0).i | nl;
+	Fred & end = dropTail( fred );
+	delete( &end );
+
+	for ( over( fredIter, fred0 ); fredIter >> f; ) {
+		sout | f.i | ' ';
+	}
+	sout | nl;
+
+	Sequence(Fred) fred2;
+
+	split( fred2, fred0, *middle);
+
+	for ( over( fredIter, fred0 ); fredIter >> f; ) {
+		sout | f.i | ' ';
+	}
+	sout | nl;
+
+	for ( over( fredIter, fred2 ); fredIter >> f; ) {
+		sout | f.i | ' ';
+	}
+	sout | nl;
+
+	transfer( fred0, fred2);
+
+	for ( over( fredIter, fred0 ); fredIter >> f; ) {
+		sout | f.i | ' ';
+	}
+	sout | nl;
+
+	for ( over( fredIter, fred0 ); fredIter >> f; ) {
+		delete( &f );
+	}
+
+	// Mary test
+
+	struct Mary {
+		inline Fred;									// Plan 9 inheritance
+		int j;
+	};
+	void ?{}( Mary & mary ) { abort(); }
+	void ?{}( Mary & mary, int p ) with( mary ) {
+		((Fred &)mary){ p };
+		j = p;
+	}
+
+	Mary *& Back( Mary * n ) {
+		return (Mary *)Back( (Fred *)n );
+	}
+
+	Mary *& Next( Mary * n ) {
+		return (Mary *)Next( (Fred *)n );
+	}
+
+	Sequence(Mary) mary;
+	Sequence(Mary) baz;
+	SeqIter(Mary) maryIter = { mary };
+	Mary & m;
+
+	for ( ; maryIter >> m; ) {							// empty list
+		sout | m.i | m.j | ' ';
+	}
+	sout | "empty" | nl;
+	
+	for ( i; 10 ) {
+		add( mary, *new( 2 * i ) );
+		add( baz, *new( 2 * i ) );
+	}
+
+	for ( SeqIter(Mary) iter = { mary }; iter >> m; ) {
+		sout | m.i | m.j | ' ';
+	}
+	sout | nl;
+	
+	for ( i; 9 ) {
+		delete( &dropHead( mary ) );
+	}
+
+	for ( over( maryIter, mary ); maryIter >> m; ) {
+		sout | m.i | m.j | ' ';
+	}
+	sout | nl;
+	
+	for ( i; 10 ) {
+		addTail( mary, *new( 2 * i + 1 ) );
+	}
+	for ( over( maryIter, mary ); maryIter >> m; ) {
+		sout | m.i | m.j | ' ';
+	}
+	sout | nl;
+
+	for ( i; 9 ) {
+		delete( &dropTail( mary ) );
+	}
+	for ( over( maryIter, mary ); maryIter >> m; ) {
+		sout | m.i | m.j | ' ';
+	}
+	sout | nl;
+
+	transfer( mary, baz );
+
+	for ( over( maryIter, baz ); maryIter >> m; ) {
+		sout | m.i | m.j | ' ';
+	}
+	sout | "empty" | nl;
+
+	for ( over( maryIter, mary ); maryIter >> m; ) {
+		sout | m.i | m.j | ' ';
+	}
+	sout | nl;
+
+	for ( over( maryIter, mary ); maryIter >> m; ) {
+		delete( &m );
+	}
+}
Index: tests/collections/stack.cfa
===================================================================
--- tests/collections/stack.cfa	(revision de2f969977d4924d0f35043c08b1b172e7f5af19)
+++ tests/collections/stack.cfa	(revision de2f969977d4924d0f35043c08b1b172e7f5af19)
@@ -0,0 +1,117 @@
+#include <fstream.hfa>
+#include <stdlib.hfa>									// new, delete
+#include <bits/stack.hfa>
+
+int main() {
+	// Fred test
+
+	struct Fred {
+		inline Colable;									// Plan 9 inheritance
+		int i;
+	};
+	void ?{}( Fred & fred ) { abort(); }
+	void ?{}( Fred & fred, int p ) with( fred ) {
+		i = p;
+	}
+	Fred *& Next( Fred * n ) {
+		return (Fred *)Next( (Colable *)n );
+	}
+
+	Stack(Fred) fred;
+	StackIter(Fred) fredIter = { fred };
+	Fred & f;
+
+	sout | nlOff;										// turn off auto newline
+
+	for ( ; fredIter >> f; ) {							// empty list
+		sout | f.i | ' ';
+	}
+	sout | "empty" | nl;
+	
+	for ( i; 10 ) {
+		push( fred, *new( 2 * i ) );
+	}
+
+	for ( StackIter(Fred) iter = { fred }; iter >> f; ) {
+		sout | f.i | ' ';
+	}
+	sout | nl;
+
+	sout | head(fred).i | nl;
+	
+	for ( i; 9 ) {
+		delete( &pop( fred ) );
+	}
+
+	for ( over( fredIter, fred ); fredIter >> f; ) {
+		sout | f.i | ' ';
+	}
+	sout | nl;
+	
+	for ( i; 10 ) {
+		push( fred, *new( 2 * i + 1 ) );
+	}
+	for ( over( fredIter, fred ); fredIter >> f; ) {
+		sout | f.i | ' ';
+	}
+	sout | nl;
+
+	for ( over( fredIter, fred ); fredIter >> f; ) {
+		delete( &f );
+	}
+
+	// Mary test
+
+	struct Mary {
+		inline Fred;									// Plan 9 inheritance
+		int j;
+	};
+	void ?{}( Mary & mary ) { abort(); }
+	void ?{}( Mary & mary, int p ) with( mary ) {
+		((Fred &)mary){ p };
+		j = i = p;
+	}
+
+	Mary *& Next( Mary * n ) {
+		return (Mary *)Next( (Fred *)n );
+	}
+
+	Stack(Mary) mary;
+	StackIter(Mary) maryIter = { mary };
+	Mary & m;
+
+	for ( ; maryIter >> m; ) {							// empty list
+		sout | m.i | m.j | ' ';
+	}
+	sout | "empty" | nl;
+	
+	for ( i; 10 ) {
+		push( mary, *new( 2 * i ) );
+	}
+
+	for ( StackIter(Mary) iter = { mary }; iter >> m; ) {
+		sout | m.i | m.j | ' ';
+	}
+	sout | nl;
+	
+	for ( i; 9 ) {
+		delete( &pop( mary ) );
+	}
+
+	for ( over( maryIter, mary ); maryIter >> m; ) {
+		sout | m.i | m.j | ' ';
+	}
+	sout | nl;
+	
+	for ( i; 10 ) {
+		push( mary, *new( 2 * i + 1 ) );
+	}
+	for ( over( maryIter, mary ); maryIter >> m; ) {
+		sout | m.i | m.j | ' ';
+	}
+	sout | nl;
+
+	for ( over( maryIter, mary ); maryIter >> m; ) {
+		delete( &m );
+	}
+}