Index: tests/avltree/avl-private.cfa
===================================================================
--- tests/avltree/avl-private.cfa	(revision fcd0b9d7282c8c187cc0111baf35ab6d4fb846a2)
+++ tests/avltree/avl-private.cfa	(revision fd54fef231baeeb0016103bf19cc8e6d87287faf)
@@ -11,5 +11,5 @@
 // an AVL tree's height is easy to compute
 // just follow path with the larger balance
-forall(otype K | Comparable(K), otype V)
+forall(K | Comparable(K), V)
 int height(tree(K, V) * t){
   int helper(tree(K, V) * t, int ht){
@@ -27,5 +27,5 @@
 }
 
-forall(otype K | Comparable(K), otype V)
+forall(K | Comparable(K), V)
 int calcBalance(tree(K, V) * t){
   int l = height(t->left);
@@ -36,5 +36,5 @@
 
 // re-establish the link between parent and child
-forall(otype K | Comparable(K), otype V)
+forall(K | Comparable(K), V)
 void relinkToParent(tree(K, V) * t){
   tree(K, V) * parent = t->parent; // FIX ME!!
@@ -49,5 +49,5 @@
 
 // rotate left from t
-forall(otype K | Comparable(K), otype V)
+forall(K | Comparable(K), V)
 tree(K, V) * rotateLeft(tree(K, V) * t){
   tree(K, V) * newRoot = t->right;
@@ -68,5 +68,5 @@
 
 // rotate right from t
-forall(otype K | Comparable(K), otype V)
+forall(K | Comparable(K), V)
 tree(K, V) * rotateRight(tree(K, V) * t){
   tree(K, V) * newRoot = t->left;
@@ -87,5 +87,5 @@
 
 // balances a node that has balance factor -2 or 2
-forall(otype K | Comparable(K), otype V)
+forall(K | Comparable(K), V)
 tree(K, V) * fix(tree(K, V) * t){
   // ensure that t's balance factor is one of
@@ -113,5 +113,5 @@
 
 // attempt to fix the tree, if necessary
-forall(otype K | Comparable(K), otype V)
+forall(K | Comparable(K), V)
 tree(K, V) * tryFix(tree(K, V) * t){
   int b = calcBalance(t);
@@ -126,5 +126,5 @@
 
 // sets parent field of c to be p
-forall(otype K | Comparable(K), otype V)
+forall(K | Comparable(K), V)
 void setParent(tree(K, V) * c, tree(K, V) * p){
   if (! empty(c)){
Index: tests/avltree/avl-private.h
===================================================================
--- tests/avltree/avl-private.h	(revision fcd0b9d7282c8c187cc0111baf35ab6d4fb846a2)
+++ tests/avltree/avl-private.h	(revision fd54fef231baeeb0016103bf19cc8e6d87287faf)
@@ -5,11 +5,11 @@
 
 // attempt to fix the tree, if necessary
-forall(otype K | Comparable(K), otype V)
+forall(K | Comparable(K), V)
 tree(K, V) * tryFix(tree(K, V) * t);
 
 // sets parent field of c to be p
-forall(otype K | Comparable(K), otype V)
+forall(K | Comparable(K), V)
 void setParent(tree(K, V) * c, tree(K, V) * p);
 
-forall(otype K | Comparable(K), otype V)
+forall(K | Comparable(K), V)
 int height(tree(K, V) * t);
Index: tests/avltree/avl.h
===================================================================
--- tests/avltree/avl.h	(revision fcd0b9d7282c8c187cc0111baf35ab6d4fb846a2)
+++ tests/avltree/avl.h	(revision fd54fef231baeeb0016103bf19cc8e6d87287faf)
@@ -9,12 +9,12 @@
 // #include <lib.h>
 
-trait Comparable(otype T) {
+trait Comparable(T) {
   int ?<?(T, T);
 };
 
-forall(otype T | Comparable(T))
+forall(T | Comparable(T))
 int ?==?(T t1, T t2);
 
-forall(otype T | Comparable(T))
+forall(T | Comparable(T))
 int ?>?(T t1, T t2);
 
@@ -41,8 +41,8 @@
 
 // temporary: need forward decl to get around typedef problem
-forall(otype K | Comparable(K), otype V)
+forall(K | Comparable(K), V)
 struct tree;
 
-forall(otype K | Comparable(K), otype V)
+forall(K | Comparable(K), V)
 struct tree {
   K key;
@@ -54,30 +54,30 @@
 };
 
-forall(otype K | Comparable(K), otype V)
+forall(K | Comparable(K), V)
 void ?{}(tree(K, V) &t, K key, V value);
 
-forall(otype K | Comparable(K), otype V)
+forall(K | Comparable(K), V)
 void ^?{}(tree(K, V) & t);
 
-forall(otype K | Comparable(K), otype V)
+forall(K | Comparable(K), V)
 tree(K, V) * create(K key, V value);
 
-forall(otype K | Comparable(K), otype V)
+forall(K | Comparable(K), V)
 V * find(tree(K, V) * t, K key);
 
-forall(otype K | Comparable(K), otype V)
+forall(K | Comparable(K), V)
 int empty(tree(K, V) * t);
 
 // returns the root of the tree
-forall(otype K | Comparable(K), otype V)
+forall(K | Comparable(K), V)
 int insert(tree(K, V) ** t, K key, V value);
 
-forall(otype K | Comparable(K), otype V)
+forall(K | Comparable(K), V)
 int remove(tree(K, V) ** t, K key);
 
-forall(otype K | Comparable(K), otype V)
+forall(K | Comparable(K), V)
 void copy(tree(K, V) * src, tree(K, V) ** ret);
 
-forall(otype K | Comparable(K), otype V)
+forall(K | Comparable(K), V)
 void for_each(tree(K, V) * t, void (*func)(V));
 
Index: tests/avltree/avl0.cfa
===================================================================
--- tests/avltree/avl0.cfa	(revision fcd0b9d7282c8c187cc0111baf35ab6d4fb846a2)
+++ tests/avltree/avl0.cfa	(revision fd54fef231baeeb0016103bf19cc8e6d87287faf)
@@ -1,10 +1,10 @@
 #include "avl.h"
 
-forall(otype T | Comparable(T))
+forall(T | Comparable(T))
 int ?==?(T t1, T t2) {
   return !(t1 < t2) && !(t2 < t1);
 }
 
-forall(otype T | Comparable(T))
+forall(T | Comparable(T))
 int ?>?(T t1, T t2) {
   return t2 < t1;
Index: tests/avltree/avl1.cfa
===================================================================
--- tests/avltree/avl1.cfa	(revision fcd0b9d7282c8c187cc0111baf35ab6d4fb846a2)
+++ tests/avltree/avl1.cfa	(revision fd54fef231baeeb0016103bf19cc8e6d87287faf)
@@ -3,5 +3,5 @@
 #include <stdlib.hfa>
 
-forall(otype K | Comparable(K), otype V)
+forall(K | Comparable(K), V)
 void ?{}(tree(K, V) &t, K key, V value){
   (t.key) { key };
@@ -13,5 +13,5 @@
 }
 
-forall(otype K| Comparable(K), otype V)
+forall(K| Comparable(K), V)
 void ^?{}(tree(K, V) & t){
   delete(t.left);
@@ -21,5 +21,5 @@
 }
 
-forall(otype K | Comparable(K), otype V)
+forall(K | Comparable(K), V)
 tree(K, V) * create(K key, V value) {
   // infinite loop trying to resolve ... t = malloc();
Index: tests/avltree/avl2.cfa
===================================================================
--- tests/avltree/avl2.cfa	(revision fcd0b9d7282c8c187cc0111baf35ab6d4fb846a2)
+++ tests/avltree/avl2.cfa	(revision fd54fef231baeeb0016103bf19cc8e6d87287faf)
@@ -2,5 +2,5 @@
 #include "avl-private.h"
 
-forall(otype K | Comparable(K), otype V)
+forall(K | Comparable(K), V)
 V * find(tree(K, V) * t, K key){
   if (empty(t)){
@@ -18,5 +18,5 @@
 }
 
-forall(otype K | Comparable(K), otype V)
+forall(K | Comparable(K), V)
 int empty(tree(K, V) * t){
   return t == NULL;
@@ -24,5 +24,5 @@
 
 // returns the root of the tree
-forall(otype K | Comparable(K), otype V)
+forall(K | Comparable(K), V)
 int insert(tree(K, V) ** t, K key, V value) {
   // handles a non-empty tree
Index: tests/avltree/avl3.cfa
===================================================================
--- tests/avltree/avl3.cfa	(revision fcd0b9d7282c8c187cc0111baf35ab6d4fb846a2)
+++ tests/avltree/avl3.cfa	(revision fd54fef231baeeb0016103bf19cc8e6d87287faf)
@@ -4,5 +4,5 @@
 
 // swaps the data within two tree nodes
-forall(otype K | Comparable(K), otype V)
+forall(K | Comparable(K), V)
 void node_swap(tree(K, V) * t, tree(K, V) * t2){
 	swap( t->key,  t2->key);
@@ -11,5 +11,5 @@
 
 // go left as deep as possible from within the right subtree
-forall(otype K | Comparable(K), otype V)
+forall(K | Comparable(K), V)
 tree(K, V) * find_successor(tree(K, V) * t){
 	tree(K, V) * find_successor_helper(tree(K, V) * t){
@@ -25,5 +25,5 @@
 
 // cleanup - don't want to deep delete, so set children to NULL first.
-forall(otype K | Comparable(K), otype V)
+forall(K | Comparable(K), V)
 void deleteSingleNode(tree(K, V) * t) {
 	t->left = NULL;
@@ -33,5 +33,5 @@
 
 // does the actual remove operation once we've found the node in question
-forall(otype K | Comparable(K), otype V)
+forall(K | Comparable(K), V)
 tree(K, V) * remove_node(tree(K, V) * t){
 	// is the node a leaf?
@@ -85,5 +85,5 @@
 
 // finds the node that needs to be removed
-forall(otype K | Comparable(K), otype V)
+forall(K | Comparable(K), V)
 tree(K, V) * remove_helper(tree(K, V) * t, K key, int * worked){
 	if (empty(t)){
@@ -106,5 +106,5 @@
 }
 
-forall(otype K | Comparable(K), otype V)
+forall(K | Comparable(K), V)
 int remove(tree(K, V) ** t, K key){
 	int worked = 0;
Index: tests/avltree/avl4.cfa
===================================================================
--- tests/avltree/avl4.cfa	(revision fcd0b9d7282c8c187cc0111baf35ab6d4fb846a2)
+++ tests/avltree/avl4.cfa	(revision fd54fef231baeeb0016103bf19cc8e6d87287faf)
@@ -4,5 +4,5 @@
 // Perform a shallow copy of src, return the
 // new tree in ret
-forall(otype K | Comparable(K), otype V)
+forall(K | Comparable(K), V)
 int copy(tree(K, V) * src, tree(K, V) ** ret){
   tree(K, V) * helper(tree(K, V) * t, int * worked){
@@ -35,5 +35,5 @@
 
 // Apply func to every value element in t, using an in order traversal
-forall(otype K | Comparable(K), otype V)
+forall(K | Comparable(K), V)
 void for_each(tree(K, V) * t, int (*func)(V)) {
   if (t == NULL) {
Index: tests/bugs/10.cfa
===================================================================
--- tests/bugs/10.cfa	(revision fcd0b9d7282c8c187cc0111baf35ab6d4fb846a2)
+++ tests/bugs/10.cfa	(revision fd54fef231baeeb0016103bf19cc8e6d87287faf)
@@ -2,5 +2,5 @@
 // https://cforall.uwaterloo.ca/trac/ticket/10
 
-forall(otype T)
+forall(T)
 struct result {
       union {
Index: tests/bugs/104.cfa
===================================================================
--- tests/bugs/104.cfa	(revision fcd0b9d7282c8c187cc0111baf35ab6d4fb846a2)
+++ tests/bugs/104.cfa	(revision fd54fef231baeeb0016103bf19cc8e6d87287faf)
@@ -4,5 +4,5 @@
 [ float, float ] modf_( float x );
 
-forall(otype T | { [T, T] modf_(T); })
+forall(T | { [T, T] modf_(T); })
 void modf(T);
 
Index: tests/bugs/194.cfa
===================================================================
--- tests/bugs/194.cfa	(revision fcd0b9d7282c8c187cc0111baf35ab6d4fb846a2)
+++ tests/bugs/194.cfa	(revision fd54fef231baeeb0016103bf19cc8e6d87287faf)
@@ -2,9 +2,9 @@
 // https://cforall.uwaterloo.ca/trac/ticket/194
 
-forall( dtype T | sized(T) ) T * foo( void ) {
+forall( T & | sized(T) ) T * foo( void ) {
       printf( "foo1\n" );
 	return (T *)0;
 }
-forall( dtype T | sized(T) ) T & foo( void ) {
+forall( T & | sized(T) ) T & foo( void ) {
 	printf( "foo2\n" );
 	return (T &)*(T *)0;
Index: tests/bugs/196.cfa
===================================================================
--- tests/bugs/196.cfa	(revision fcd0b9d7282c8c187cc0111baf35ab6d4fb846a2)
+++ tests/bugs/196.cfa	(revision fd54fef231baeeb0016103bf19cc8e6d87287faf)
@@ -2,8 +2,8 @@
 // https://cforall.uwaterloo.ca/trac/ticket/196
 
-forall(dtype T)
+forall(T &)
 struct link;
 
-forall(dtype T)
+forall(T &)
 struct link {
 	link(T) * next;
@@ -12,13 +12,13 @@
 // -----
 
-forall(dtype T)
+forall(T &)
 struct foo;
 
-forall(dtype U)
+forall(U &)
 struct bar {
 	foo(U) * data;
 };
 
-forall(dtype T)
+forall(T &)
 struct foo {};
 
Index: tests/bugs/203-2.cfa
===================================================================
--- tests/bugs/203-2.cfa	(revision fcd0b9d7282c8c187cc0111baf35ab6d4fb846a2)
+++ tests/bugs/203-2.cfa	(revision fd54fef231baeeb0016103bf19cc8e6d87287faf)
@@ -1,10 +1,10 @@
 // Trac ticket: https://cforall.uwaterloo.ca/trac/ticket/203
 
-forall(dtype A)
+forall(A &)
 struct empty {
 	// Nothing.
 };
 
-forall(dtype C)
+forall(C &)
 struct wrap_e {
 	empty(C) field;
Index: tests/bugs/203-7.cfa
===================================================================
--- tests/bugs/203-7.cfa	(revision fcd0b9d7282c8c187cc0111baf35ab6d4fb846a2)
+++ tests/bugs/203-7.cfa	(revision fd54fef231baeeb0016103bf19cc8e6d87287faf)
@@ -1,10 +1,10 @@
 // Trac ticket: https://cforall.uwaterloo.ca/trac/ticket/203
 
-forall(dtype A)
+forall(A &)
 struct empty {
 	// Nothing.
 };
 
-forall(dtype C)
+forall(C &)
 struct wrap_e {
 	empty(C) field;
Index: tests/bugs/203-9.cfa
===================================================================
--- tests/bugs/203-9.cfa	(revision fcd0b9d7282c8c187cc0111baf35ab6d4fb846a2)
+++ tests/bugs/203-9.cfa	(revision fd54fef231baeeb0016103bf19cc8e6d87287faf)
@@ -1,10 +1,10 @@
 // Trac ticket: https://cforall.uwaterloo.ca/trac/ticket/203
 
-forall(dtype A)
+forall(A &)
 struct empty {
 	// Nothing.
 };
 
-forall(dtype C)
+forall(C &)
 struct wrap_e {
 	empty(C) field;
Index: tests/bugs/7.cfa
===================================================================
--- tests/bugs/7.cfa	(revision fcd0b9d7282c8c187cc0111baf35ab6d4fb846a2)
+++ tests/bugs/7.cfa	(revision fd54fef231baeeb0016103bf19cc8e6d87287faf)
@@ -8,8 +8,8 @@
 
 // (Bug 1 unresolved as of this test.)
-forall(otype T)
+forall(T)
 struct stack_node;
 
-forall(otype T)
+forall(T)
 struct stack_node {
     stack_node(T) * next;
@@ -17,14 +17,14 @@
 };
 
-forall(otype T)
+forall(T)
 struct stack {
     stack_node(T) * head;
 };
 
-trait stack_errors(otype T) {
+trait stack_errors(T) {
     T emptyStackHandler (stack(T) * this);
 };
 
-forall(otype T | stack_errors(T))
+forall(T | stack_errors(T))
 T pop (stack(T) * this) {
     return (T){};
Index: tests/castError.cfa
===================================================================
--- tests/castError.cfa	(revision fcd0b9d7282c8c187cc0111baf35ab6d4fb846a2)
+++ tests/castError.cfa	(revision fd54fef231baeeb0016103bf19cc8e6d87287faf)
@@ -14,5 +14,5 @@
 // 
 
-forall(otype T) struct S { T p; };
+forall(T) struct S { T p; };
 int f;
 S(int) sint;
Index: tests/concurrent/examples/boundedBufferEXT.cfa
===================================================================
--- tests/concurrent/examples/boundedBufferEXT.cfa	(revision fcd0b9d7282c8c187cc0111baf35ab6d4fb846a2)
+++ tests/concurrent/examples/boundedBufferEXT.cfa	(revision fd54fef231baeeb0016103bf19cc8e6d87287faf)
@@ -24,5 +24,5 @@
 enum { BufferSize = 50 };
 
-forall( otype T ) {
+forall( T ) {
 	monitor Buffer {
 		int front, back, count;
Index: tests/concurrent/examples/boundedBufferINT.cfa
===================================================================
--- tests/concurrent/examples/boundedBufferINT.cfa	(revision fcd0b9d7282c8c187cc0111baf35ab6d4fb846a2)
+++ tests/concurrent/examples/boundedBufferINT.cfa	(revision fd54fef231baeeb0016103bf19cc8e6d87287faf)
@@ -24,5 +24,5 @@
 enum { BufferSize = 50 };
 
-forall( otype T ) {
+forall( T ) {
 	monitor Buffer {
 		condition full, empty;
Index: tests/concurrent/examples/quickSort.generic.cfa
===================================================================
--- tests/concurrent/examples/quickSort.generic.cfa	(revision fcd0b9d7282c8c187cc0111baf35ab6d4fb846a2)
+++ tests/concurrent/examples/quickSort.generic.cfa	(revision fd54fef231baeeb0016103bf19cc8e6d87287faf)
@@ -21,5 +21,5 @@
 #include <string.h>										// strcmp
 
-forall( otype T | { int ?<?( T, T ); } ) {
+forall( T | { int ?<?( T, T ); } ) {
 	thread Quicksort {
 		T * values;										// communication variables
Index: tests/concurrent/multi-monitor.cfa
===================================================================
--- tests/concurrent/multi-monitor.cfa	(revision fcd0b9d7282c8c187cc0111baf35ab6d4fb846a2)
+++ tests/concurrent/multi-monitor.cfa	(revision fd54fef231baeeb0016103bf19cc8e6d87287faf)
@@ -38,5 +38,5 @@
 }
 
-forall(dtype T | sized(T) | { void ^?{}(T & mutex); })
+forall(T & | sized(T) | { void ^?{}(T & mutex); })
 void delete_mutex(T * x) {
 	^(*x){};
Index: tests/errors/completeType.cfa
===================================================================
--- tests/errors/completeType.cfa	(revision fcd0b9d7282c8c187cc0111baf35ab6d4fb846a2)
+++ tests/errors/completeType.cfa	(revision fd54fef231baeeb0016103bf19cc8e6d87287faf)
@@ -1,7 +1,7 @@
 void foo(int *) {}
 void bar(void *) {}
-forall(otype T) void baz(T *);
-forall(dtype T) void qux(T *);
-forall(dtype T | sized(T)) void quux(T *);
+forall(T) void baz(T *);
+forall(T &) void qux(T *);
+forall(T & | sized(T)) void quux(T *);
 
 struct A;	// incomplete
@@ -39,5 +39,5 @@
 
 
-forall(otype T)
+forall(T)
 void baz(T * x) {
 	// okay
@@ -49,5 +49,5 @@
 }
 
-forall(dtype T)
+forall(T &)
 void qux(T * y) {
 	// okay
@@ -61,5 +61,5 @@
 }
 
-forall(dtype T | sized(T))
+forall(T & | sized(T))
 void quux(T * z) {
 	// okay
Index: tests/exceptions/defaults.cfa
===================================================================
--- tests/exceptions/defaults.cfa	(revision fcd0b9d7282c8c187cc0111baf35ab6d4fb846a2)
+++ tests/exceptions/defaults.cfa	(revision fd54fef231baeeb0016103bf19cc8e6d87287faf)
@@ -55,5 +55,5 @@
 
 void unhandled_test(void) {
-	forall(dtype T, dtype V | is_exception(T, V))
+	forall(T &, V & | is_exception(T, V))
 	void defaultTerminationHandler(T &) {
 		throw (unhandled_exception){};
Index: tests/exceptions/polymorphic.cfa
===================================================================
--- tests/exceptions/polymorphic.cfa	(revision fcd0b9d7282c8c187cc0111baf35ab6d4fb846a2)
+++ tests/exceptions/polymorphic.cfa	(revision fd54fef231baeeb0016103bf19cc8e6d87287faf)
@@ -3,6 +3,6 @@
 #include <exception.hfa>
 
-FORALL_TRIVIAL_EXCEPTION(proxy, (otype T), (T));
-FORALL_TRIVIAL_INSTANCE(proxy, (otype U), (U))
+FORALL_TRIVIAL_EXCEPTION(proxy, (T), (T));
+FORALL_TRIVIAL_INSTANCE(proxy, (U), (U))
 
 const char * msg(proxy(int) * this) { return "proxy(int)"; }
@@ -33,9 +33,9 @@
 }
 
-FORALL_DATA_EXCEPTION(cell, (otype T), (T))(
+FORALL_DATA_EXCEPTION(cell, (T), (T))(
 	T data;
 );
 
-FORALL_DATA_INSTANCE(cell, (otype T), (T))
+FORALL_DATA_INSTANCE(cell, (T), (T))
 
 const char * msg(cell(int) * this) { return "cell(int)"; }
Index: tests/exceptions/virtual-poly.cfa
===================================================================
--- tests/exceptions/virtual-poly.cfa	(revision fcd0b9d7282c8c187cc0111baf35ab6d4fb846a2)
+++ tests/exceptions/virtual-poly.cfa	(revision fd54fef231baeeb0016103bf19cc8e6d87287faf)
@@ -16,10 +16,10 @@
 };
 
-forall(otype T)
+forall(T)
 struct mono_child_vtable {
 	mono_base_vtable const * const parent;
 };
 
-forall(otype T)
+forall(T)
 struct mono_child {
 	mono_child_vtable(T) const * virtual_table;
@@ -37,20 +37,20 @@
 }
 
-forall(otype U)
+forall(U)
 struct poly_base_vtable {
 	poly_base_vtable(U) const * const parent;
 };
 
-forall(otype U)
+forall(U)
 struct poly_base {
 	poly_base_vtable(U) const * virtual_table;
 };
 
-forall(otype V)
+forall(V)
 struct poly_child_vtable {
 	poly_base_vtable(V) const * const parent;
 };
 
-forall(otype V)
+forall(V)
 struct poly_child {
 	poly_child_vtable(V) const * virtual_table;
Index: tests/forall.cfa
===================================================================
--- tests/forall.cfa	(revision fcd0b9d7282c8c187cc0111baf35ab6d4fb846a2)
+++ tests/forall.cfa	(revision fd54fef231baeeb0016103bf19cc8e6d87287faf)
@@ -15,5 +15,5 @@
 
 void g1() {
-	forall( otype T ) T f( T ) {};
+	forall( T ) T f( T ) {};
 	void f( int ) {};
 	void h( void (*p)(void) ) {};
@@ -32,6 +32,6 @@
 
 void g2() {
-	forall( otype T ) void f( T, T ) {}
-	forall( otype T, otype U ) void f( T, U ) {}
+	forall( T ) void f( T, T ) {}
+	forall( T, U ) void f( T, U ) {}
 
 	int x;
@@ -45,7 +45,7 @@
 }
 
-typedef forall ( otype T ) int (* f)( int );
-
-forall( otype T )
+typedef forall ( T ) int (* f)( int );
+
+forall( T )
 void swap( T left, T right ) {
 	T temp = left;
@@ -54,5 +54,5 @@
 }
 
-trait sumable( otype T ) {
+trait sumable( T ) {
 	void ?{}( T &, zero_t );							// 0 literal constructor
 	T ?+?( T, T );										// assortment of additions
@@ -62,5 +62,5 @@
 }; // sumable
 
-forall( otype T | sumable( T ) )						// use trait
+forall( T | sumable( T ) )						// use trait
 T sum( size_t size, T a[] ) {
 	T total = 0;										// initialize by 0 constructor
@@ -70,10 +70,10 @@
 } // sum
 
-forall( otype T | { T ?+?( T, T ); T ?++( T & ); [T] ?+=?( T &,T ); } )
+forall( T | { T ?+?( T, T ); T ?++( T & ); [T] ?+=?( T &,T ); } )
 T twice( T t ) {
 	return t + t;
 }
 
-forall( otype T | { int ?<?(T, T); } )
+forall( T | { int ?<?(T, T); } )
 T min( T t1, T t2 ) {
 	return t1 < t2 ? t1 : t2;
@@ -91,23 +91,23 @@
 
 // Multiple forall
-forall( otype T ) forall( otype S ) struct { int i; };
-forall( otype T ) struct { int i; } forall( otype S );
-struct { int i; } forall( otype T ) forall( otype S );
-forall( otype W ) struct { int i; } forall( otype T ) forall( otype S );
+forall( T ) forall( S ) struct { int i; };
+forall( T ) struct { int i; } forall( S );
+struct { int i; } forall( T ) forall( S );
+forall( W ) struct { int i; } forall( T ) forall( S );
 
 // Distribution
 struct P { int i; };
-forall( otype T ) struct Q { T i; };
-forall( otype T ) struct { int i; };
+forall( T ) struct Q { T i; };
+forall( T ) struct { int i; };
 struct KK { int i; };
 inline static {
  	void RT1() {}
 }
-forall( otype T ) {
+forall( T ) {
 	T RT2( T ) {
 		typedef int TD1;
 		struct S1 { T t; };
 	}
-	forall( otype X ) {
+	forall( X ) {
 		typedef int TD2;
 		struct S2 {};
@@ -117,5 +117,5 @@
 	}
 	extern "C" {
-		forall( otype W ) {
+		forall( W ) {
 			W RT3( W ) {}
 			struct S3 {};
@@ -123,5 +123,5 @@
 	}
 	void RT4() {
-		forall( otype W ) struct S4 {};
+		forall( W ) struct S4 {};
 		typedef int TD3;
 	}
@@ -147,22 +147,22 @@
 
 static inline {
-	forall( otype T ) {
+	forall( T ) {
 		int RT6( T p );
 	}
-	forall( otype T, otype U ) {
+	forall( T, U ) {
 		int RT7( T, U );
 	}
 }
-static forall( otype T ) {
+static forall( T ) {
 	int RT8( T );
 }
-forall( otype T ) inline static {
+forall( T ) inline static {
 	int RT9( T ) { T t; return 3; }
 }
 
-forall( otype T | { T ?+?( T, T ); } ) {
-	forall( otype S | { T ?+?( T, S ); } ) {
-		forall( otype W ) T bar( T t, S s ) { return t + s; }
-		forall( otype W | { W ?+?( T, W ); } ) W baz( T t, S s, W w ) { return t + s + w; }
+forall( T | { T ?+?( T, T ); } ) {
+	forall( S | { T ?+?( T, S ); } ) {
+		forall( W ) T bar( T t, S s ) { return t + s; }
+		forall( W | { W ?+?( T, W ); } ) W baz( T t, S s, W w ) { return t + s + w; }
 		struct W { T t; } (int,int) ww;
 		struct P pp;
@@ -170,18 +170,18 @@
 }
 
-forall( otype T | { T ?+?( T, T ); } ) forall( otype S | { T ?+?( T, S ); } ) 
+forall( T | { T ?+?( T, T ); } ) forall( S | { T ?+?( T, S ); } ) 
 struct XW { T t; };
 XW(int,int) xww;
 
-forall( otype T ) struct S { T t; } (int) x, y, z;
-forall( otype T ) struct { T t; } (int) a, b, c;
-
-forall( otype T ) static forall( otype S ) {
-    forall( otype X ) struct U {
+forall( T ) struct S { T t; } (int) x, y, z;
+forall( T ) struct { T t; } (int) a, b, c;
+
+forall( T ) static forall( S ) {
+    forall( X ) struct U {
 		T x;
     };
 }
 
-forall( otype T ) {
+forall( T ) {
 	extern "C" {
 		struct SS { T t; };
Index: tests/function-operator.cfa
===================================================================
--- tests/function-operator.cfa	(revision fcd0b9d7282c8c187cc0111baf35ab6d4fb846a2)
+++ tests/function-operator.cfa	(revision fd54fef231baeeb0016103bf19cc8e6d87287faf)
@@ -22,9 +22,9 @@
 
 // STL-like Algorithms
-trait Assignable(dtype T, dtype U) { T ?=?(T &, U); };
-trait Copyable(dtype T) { void ?{}(T &, T); };
-trait Destructable(dtype T) { void ^?{}(T &); };
+trait Assignable(T &, U &) { T ?=?(T &, U); };
+trait Copyable(T &) { void ?{}(T &, T); };
+trait Destructable(T &) { void ^?{}(T &); };
 
-trait Iterator(dtype iter | sized(iter) | Copyable(iter) | Destructable(iter), otype T) {
+trait Iterator(iter & | sized(iter) | Copyable(iter) | Destructable(iter), T) {
 	T & *?(iter);
 	iter ++?(iter &);
@@ -32,5 +32,5 @@
 };
 
-forall(otype Tin, dtype Input | Iterator(Input, Tin), otype Tout, dtype Output | Iterator(Output, Tout) | Assignable(Tout, Tin))
+forall(Tin, Input & | Iterator(Input, Tin), Tout, Output & | Iterator(Output, Tout) | Assignable(Tout, Tin))
 Output copy(Input first, Input last, Output result) {
 	while (first != last) {
@@ -42,5 +42,5 @@
 
 // test ?()(T *, ...) -- ?() with function call-by-pointer
-forall(otype Tin, dtype Input | Iterator(Input, Tin), otype Tout, dtype Output | Iterator(Output, Tout), otype FuncRet, dtype Func | { FuncRet ?()(Func *, Tin); } | Assignable(Tout, FuncRet))
+forall(Tin, Input & | Iterator(Input, Tin), Tout, Output & | Iterator(Output, Tout), FuncRet, Func & | { FuncRet ?()(Func *, Tin); } | Assignable(Tout, FuncRet))
 Output transform (Input first, Input last, Output result, Func * op) {
 	while (first != last) {
@@ -52,5 +52,5 @@
 
 // test ?()(T, ...) -- ?() with function call-by-value
-forall(dtype Iter, otype T | Iterator(Iter, T), otype Pred | { int ?()(Pred, T); })
+forall(Iter &, T | Iterator(Iter, T), Pred | { int ?()(Pred, T); })
 Iter find_if (Iter first, Iter last, Pred pred) {
 	while (first != last) {
@@ -62,5 +62,5 @@
 
 // test ?()(T, ...) -- ?() with function call-by-reference
-forall(otype Generator, otype GenRet | { GenRet ?()(Generator &); }, dtype Iter, otype T | Iterator(Iter, T) | Assignable(T, GenRet))
+forall(Generator, GenRet | { GenRet ?()(Generator &); }, Iter &, T | Iterator(Iter, T) | Assignable(T, GenRet))
 void generate(Iter first, Iter last, Generator & gen) {
 	int i = 0;
@@ -108,20 +108,20 @@
 }
 
-forall(otype T | { int ?==?(T, T); })
+forall(T | { int ?==?(T, T); })
 struct Equals {
 	T val;
 };
 
-forall(otype T | { int ?==?(T, T); })
+forall(T | { int ?==?(T, T); })
 int ?()(Equals(T) eq, T x) {
 	return eq.val == x;
 }
 
-forall(otype T | { T ?*?(T, T); })
+forall(T | { T ?*?(T, T); })
 struct Multiply {
 	T val;
 };
 
-forall(otype T | { T ?*?(T, T); })
+forall(T | { T ?*?(T, T); })
 T ?()(Multiply(T) * mult, T x) {
 	return mult->val * x;
@@ -130,5 +130,5 @@
 // TODO: generalize to ttype return; doesn't work yet
 // like std::function
-forall(otype Return, ttype Args)
+forall(Return, Args...)
 struct function {
 	Return (*f)(Args);
Index: tests/genericUnion.cfa
===================================================================
--- tests/genericUnion.cfa	(revision fcd0b9d7282c8c187cc0111baf35ab6d4fb846a2)
+++ tests/genericUnion.cfa	(revision fd54fef231baeeb0016103bf19cc8e6d87287faf)
@@ -16,5 +16,5 @@
 #include <limits.hfa>
 
-forall(otype T)
+forall(T)
 union ByteView {
 	T val;
@@ -22,5 +22,5 @@
 };
 
-forall(otype T)
+forall(T)
 void print(ByteView(T) x) {
 	for (int i = 0; i < sizeof(int); i++) {				// want to change to sizeof(T)
@@ -29,5 +29,5 @@
 }
 
-forall(otype T)
+forall(T)
 void f(ByteView(T) x, T val) {
 	print(x);
Index: tests/global-monomorph.cfa
===================================================================
--- tests/global-monomorph.cfa	(revision fcd0b9d7282c8c187cc0111baf35ab6d4fb846a2)
+++ tests/global-monomorph.cfa	(revision fd54fef231baeeb0016103bf19cc8e6d87287faf)
@@ -1,11 +1,11 @@
 // Create monomorphic instances of polymorphic types at global scope.
 
-forall(dtype T)
+forall(T &)
 void poly0(T &) {}
 
-forall(dtype T | sized(T))
+forall(T & | sized(T))
 void poly1(T &) {}
 
-forall(otype T)
+forall(T)
 void poly2(T &) {}
 
Index: tests/identity.cfa
===================================================================
--- tests/identity.cfa	(revision fcd0b9d7282c8c187cc0111baf35ab6d4fb846a2)
+++ tests/identity.cfa	(revision fd54fef231baeeb0016103bf19cc8e6d87287faf)
@@ -16,5 +16,5 @@
 #include <fstream.hfa>
 
-forall( otype T )
+forall( T )
 T identity( T t ) {
 	return t;
Index: tests/init1.cfa
===================================================================
--- tests/init1.cfa	(revision fcd0b9d7282c8c187cc0111baf35ab6d4fb846a2)
+++ tests/init1.cfa	(revision fd54fef231baeeb0016103bf19cc8e6d87287faf)
@@ -120,10 +120,10 @@
 }
 
-forall (dtype T, dtype S)
+forall (T &, S &)
 T & anycvt( S & s ) {
     return s;               // mismatched referenced type
 }
 
-forall (dtype T, dtype S)
+forall (T &, S &)
 T * anycvt( S * s ) {
     return s;               // mismatched referenced type
Index: tests/nested-types.cfa
===================================================================
--- tests/nested-types.cfa	(revision fcd0b9d7282c8c187cc0111baf35ab6d4fb846a2)
+++ tests/nested-types.cfa	(revision fd54fef231baeeb0016103bf19cc8e6d87287faf)
@@ -16,5 +16,5 @@
 typedef int N;
 struct A {
-	forall(otype T)
+	forall(T)
 	struct N {
 		T x;
Index: tests/poly-d-cycle.cfa
===================================================================
--- tests/poly-d-cycle.cfa	(revision fcd0b9d7282c8c187cc0111baf35ab6d4fb846a2)
+++ tests/poly-d-cycle.cfa	(revision fd54fef231baeeb0016103bf19cc8e6d87287faf)
@@ -1,13 +1,13 @@
 // Check that a cycle of polymorphic dtype structures can be instancated.
 
-forall(dtype T)
+forall(T &)
 struct func_table;
 
-forall(dtype U)
+forall(U &)
 struct object {
 	func_table(U) * virtual_table;
 };
 
-forall(dtype T)
+forall(T &)
 struct func_table {
 	void (*object_func)(object(T) *);
Index: tests/poly-o-cycle.cfa
===================================================================
--- tests/poly-o-cycle.cfa	(revision fcd0b9d7282c8c187cc0111baf35ab6d4fb846a2)
+++ tests/poly-o-cycle.cfa	(revision fd54fef231baeeb0016103bf19cc8e6d87287faf)
@@ -1,13 +1,13 @@
 // Check that a cycle of polymorphic otype structures can be instancated.
 
-forall(otype T)
+forall(T)
 struct func_table;
 
-forall(otype U)
+forall(U)
 struct object {
 	func_table(U) * virtual_table;
 };
 
-forall(otype T)
+forall(T)
 struct func_table {
 	void (*object_func)(object(T) *);
Index: tests/poly-selection.cfa
===================================================================
--- tests/poly-selection.cfa	(revision fcd0b9d7282c8c187cc0111baf35ab6d4fb846a2)
+++ tests/poly-selection.cfa	(revision fd54fef231baeeb0016103bf19cc8e6d87287faf)
@@ -16,15 +16,15 @@
 
 void testSpecializationFromGenericOverBareTyvar() {
-    forall( dtype T )
+    forall( T & )
     void friend( T & ) {
         printf("friending generically\n");
     }
 
-    forall(dtype T)
+    forall(T &)
     struct thing {
         int x;
     };
 
-    forall( dtype T )
+    forall( T & )
     void friend( thing(T) & ) {
         printf("friending specifically\n");
@@ -37,13 +37,13 @@
 void testSpecializationFromGenericAccessibleWithExtraTyvars() {
 
-    forall( dtype T, dtype U )
+    forall( T &, U & )
     struct map {};
 
-    forall( dtype T )
+    forall( T & )
     void f( T & ) {
         printf("f-generic\n");
     }
 
-    forall( dtype T )
+    forall( T & )
     void f( map(T, T) & ) {
         printf("f-specific\n");
Index: tests/polymorphism.cfa
===================================================================
--- tests/polymorphism.cfa	(revision fcd0b9d7282c8c187cc0111baf35ab6d4fb846a2)
+++ tests/polymorphism.cfa	(revision fd54fef231baeeb0016103bf19cc8e6d87287faf)
@@ -18,5 +18,5 @@
 #include <fstream.hfa>
 
-forall(otype T)
+forall(T)
 T f(T x, T y) {
 	x = y;
@@ -24,9 +24,9 @@
 }
 
-forall(otype T) T ident(T x) {
+forall(T) T ident(T x) {
 	return x;
 }
 
-forall( otype T, otype U )
+forall( T, U )
 size_t struct_size( T i, U j ) {
 	struct S { T i; U j; };
@@ -34,5 +34,5 @@
 }
 
-forall( otype T, otype U )
+forall( T, U )
 size_t union_size( T i, U j ) {
 	union B { T i; U j; };
@@ -41,5 +41,5 @@
 
 // perform some simple operations on aggregates of T and U
-forall( otype T | { void print(T); int ?==?(T, T); }, otype U | { void print(U); U ?=?(U&, zero_t); } )
+forall( T | { void print(T); int ?==?(T, T); }, U | { void print(U); U ?=?(U&, zero_t); } )
 U foo(T i, U j) {
 	struct S { T i; U j; };
Index: tests/raii/ctor-autogen.cfa
===================================================================
--- tests/raii/ctor-autogen.cfa	(revision fcd0b9d7282c8c187cc0111baf35ab6d4fb846a2)
+++ tests/raii/ctor-autogen.cfa	(revision fd54fef231baeeb0016103bf19cc8e6d87287faf)
@@ -33,5 +33,5 @@
 
 // dtype-static generic type is otype
-forall(dtype T)
+forall(T &)
 struct DtypeStaticStruct {
   T * data;
@@ -39,5 +39,5 @@
 };
 
-forall(dtype T)
+forall(T &)
 union DtypeStaticUnion {
   T * data;
@@ -46,10 +46,10 @@
 
 // dynamic generic type is otype
-forall(otype T)
+forall(T)
 struct DynamicStruct {
 	T x;
 };
 
-forall(otype T)
+forall(T)
 union DynamicUnion {
 	T x;
@@ -80,5 +80,5 @@
 
 
-forall(otype T)
+forall(T)
 T identity(T x) { return x; }
 
Index: tests/simpleGenericTriple.cfa
===================================================================
--- tests/simpleGenericTriple.cfa	(revision fcd0b9d7282c8c187cc0111baf35ab6d4fb846a2)
+++ tests/simpleGenericTriple.cfa	(revision fd54fef231baeeb0016103bf19cc8e6d87287faf)
@@ -14,10 +14,10 @@
 //
 
-forall(otype T)
+forall(T)
 struct T3 {
 	T f0, f1, f2;
 };
 
-forall(otype T | { T ?+?(T, T); })
+forall(T | { T ?+?(T, T); })
 T3(T) ?+?(T3(T) x, T3(T) y) {
 	T3(T) z = { x.f0+y.f0, x.f1+y.f1, x.f2+y.f2 };
Index: tests/sum.cfa
===================================================================
--- tests/sum.cfa	(revision fcd0b9d7282c8c187cc0111baf35ab6d4fb846a2)
+++ tests/sum.cfa	(revision fd54fef231baeeb0016103bf19cc8e6d87287faf)
@@ -18,5 +18,5 @@
 #include <stdlib.hfa>
 
-trait sumable( otype T ) {
+trait sumable( T ) {
 	void ?{}( T &, zero_t );							// 0 literal constructor
 	T ?+?( T, T );										// assortment of additions
@@ -26,5 +26,5 @@
 }; // sumable
 
-forall( otype T | sumable( T ) )						// use trait
+forall( T | sumable( T ) )						// use trait
 T sum( size_t size, T a[] ) {
 	T total = 0;										// initialize by 0 constructor
@@ -107,5 +107,5 @@
 		 | sum( size, (S *)a ) | ", check" | (S)s;
 
-	forall( otype Impl | sumable( Impl ) )
+	forall( Impl | sumable( Impl ) )
 	struct GS {
 		Impl * x, * y;
@@ -194,5 +194,5 @@
 		 sum( size, (S *)a ).[i, j], s.[i, j] );
 
-	forall( otype Impl | sumable( Impl ) )
+	forall( Impl | sumable( Impl ) )
 	struct GS {
 		Impl * x, * y;
Index: tests/tuple/tuplePolymorphism.cfa
===================================================================
--- tests/tuple/tuplePolymorphism.cfa	(revision fcd0b9d7282c8c187cc0111baf35ab6d4fb846a2)
+++ tests/tuple/tuplePolymorphism.cfa	(revision fd54fef231baeeb0016103bf19cc8e6d87287faf)
@@ -29,9 +29,9 @@
 // ensure that f is a viable candidate for g, even though its parameter structure does not exactly match
 [A] f([A, B] x, B y) { printf("%g %c %g %lld %c %lld %lld %c %lld\n", x.0.[x,y,z], x.1.[x,y,z], y.[x,y,z]); return x.0; }
-forall(otype T, otype U | { T f(T, U, U); })
+forall(T, U | { T f(T, U, U); })
 void g(T x, U y) { f(x, y, y); }
 
 // add two triples
-forall(otype T | { T ?+?(T, T); })
+forall(T | { T ?+?(T, T); })
 [T, T, T] ?+?([T, T, T] x, [T, T, T] y) {
 	return [x.0+y.0, x.1+y.1, x.2+y.2];
@@ -64,5 +64,5 @@
 }
 
-forall(otype T)
+forall(T)
 [T, T] foo([T, T] y) {
 	[T, T] x;
Index: tests/tuple/tupleVariadic.cfa
===================================================================
--- tests/tuple/tupleVariadic.cfa	(revision fcd0b9d7282c8c187cc0111baf35ab6d4fb846a2)
+++ tests/tuple/tupleVariadic.cfa	(revision fd54fef231baeeb0016103bf19cc8e6d87287faf)
@@ -19,5 +19,5 @@
 	printf("called func(void)\n");
 }
-forall(otype T, ttype Params | { void process(T); void func(Params); })
+forall(T, Params... | { void process(T); void func(Params); })
 void func(T arg1, Params p) {
 	process(arg1);
@@ -92,5 +92,5 @@
 }
 
-forall(otype T)
+forall(T)
 T * copy(T x) {
 	// test calling new inside a polymorphic function
@@ -98,5 +98,5 @@
 }
 
-forall(ttype T | { void foo(T); }) void bar(T x) {}
+forall(T... | { void foo(T); }) void bar(T x) {}
 void foo(int) {}
 
Index: tests/zombies/ArrayN.c
===================================================================
--- tests/zombies/ArrayN.c	(revision fcd0b9d7282c8c187cc0111baf35ab6d4fb846a2)
+++ tests/zombies/ArrayN.c	(revision fd54fef231baeeb0016103bf19cc8e6d87287faf)
@@ -6,5 +6,5 @@
 // }
 
-forall(otype index_t)
+forall(index_t)
 index_t offset_to_index(unsigned offset, index_t size) {
     return [offset / size.0, offset % size.1];
Index: tests/zombies/Members.c
===================================================================
--- tests/zombies/Members.c	(revision fcd0b9d7282c8c187cc0111baf35ab6d4fb846a2)
+++ tests/zombies/Members.c	(revision fd54fef231baeeb0016103bf19cc8e6d87287faf)
@@ -2,6 +2,6 @@
 int ?=?( int*, int );
 float ?=?( float*, float );
-forall( dtype DT ) DT * ?=?( DT**, DT* );
-forall(otype T) lvalue T *?( T* );
+forall( DT & ) DT * ?=?( DT**, DT* );
+forall(T) lvalue T *?( T* );
 char *__builtin_memcpy();
 
Index: tests/zombies/Rank2.c
===================================================================
--- tests/zombies/Rank2.c	(revision fcd0b9d7282c8c187cc0111baf35ab6d4fb846a2)
+++ tests/zombies/Rank2.c	(revision fd54fef231baeeb0016103bf19cc8e6d87287faf)
@@ -1,8 +1,8 @@
 int ?=?( int &, int );
-forall(dtype DT) DT * ?=?( DT *&, DT * );
+forall(DT &) DT * ?=?( DT *&, DT * );
 
 void a() {
-	forall( otype T ) void f( T );
-	void g( forall( otype U ) void p( U ) );
+	forall( T ) void f( T );
+	void g( forall( U ) void p( U ) );
 	g( f );
 }
@@ -10,5 +10,5 @@
 void g() {
 	void h( int *null );
-	forall( otype T ) T id( T );
+	forall( T ) T id( T );
 //	forall( dtype T ) T *0;
 //	int 0;
Index: tests/zombies/abstype.c
===================================================================
--- tests/zombies/abstype.c	(revision fcd0b9d7282c8c187cc0111baf35ab6d4fb846a2)
+++ tests/zombies/abstype.c	(revision fd54fef231baeeb0016103bf19cc8e6d87287faf)
@@ -21,8 +21,8 @@
 }
 
-forall( otype T ) T *?( T * );
+forall( T ) T *?( T * );
 int ?++( int * );
 int ?=?( int *, int );
-forall( dtype DT ) DT * ?=?( DT **, DT * );
+forall( DT & ) DT * ?=?( DT **, DT * );
 
 otype U = int *;
Index: tests/zombies/context.cfa
===================================================================
--- tests/zombies/context.cfa	(revision fcd0b9d7282c8c187cc0111baf35ab6d4fb846a2)
+++ tests/zombies/context.cfa	(revision fd54fef231baeeb0016103bf19cc8e6d87287faf)
@@ -1,10 +1,10 @@
 // trait declaration
 
-trait has_q( otype T ) {
+trait has_q( T ) {
 	T q( T );
 };
 
-forall( otype z | has_q( z ) ) void f() {
-	trait has_r( otype T, otype U ) {
+forall( z | has_q( z ) ) void f() {
+	trait has_r( T, U ) {
 		T r( T, T (T,U) );
 	};
Index: tests/zombies/gc_no_raii/bug-repro/blockers/explicit_cast.c
===================================================================
--- tests/zombies/gc_no_raii/bug-repro/blockers/explicit_cast.c	(revision fcd0b9d7282c8c187cc0111baf35ab6d4fb846a2)
+++ tests/zombies/gc_no_raii/bug-repro/blockers/explicit_cast.c	(revision fd54fef231baeeb0016103bf19cc8e6d87287faf)
@@ -9,5 +9,5 @@
 };
 
-forall(otype T)
+forall(T)
 struct gcpointer
 {
@@ -15,5 +15,5 @@
 };
 
-forall(otype T)
+forall(T)
 static inline gcpointer(T) gcmalloc()
 {
Index: tests/zombies/gc_no_raii/bug-repro/blockers/recursive_realloc.c
===================================================================
--- tests/zombies/gc_no_raii/bug-repro/blockers/recursive_realloc.c	(revision fcd0b9d7282c8c187cc0111baf35ab6d4fb846a2)
+++ tests/zombies/gc_no_raii/bug-repro/blockers/recursive_realloc.c	(revision fd54fef231baeeb0016103bf19cc8e6d87287faf)
@@ -3,10 +3,10 @@
 #include <stdlib.hfa>
 
-trait allocator_c(otype T, otype allocator_t)
+trait allocator_c(T, allocator_t)
 {
 	void realloc(allocator_t* const, size_t);
 };
 
-forall(otype T)
+forall(T)
 struct heap_allocator
 {
@@ -15,5 +15,5 @@
 };
 
-forall(otype T)
+forall(T)
 inline void realloc(heap_allocator(T) *const this, size_t size)
 {
Index: tests/zombies/gc_no_raii/bug-repro/deref.c
===================================================================
--- tests/zombies/gc_no_raii/bug-repro/deref.c	(revision fcd0b9d7282c8c187cc0111baf35ab6d4fb846a2)
+++ tests/zombies/gc_no_raii/bug-repro/deref.c	(revision fd54fef231baeeb0016103bf19cc8e6d87287faf)
@@ -1,3 +1,3 @@
-    forall(otype T)
+    forall(T)
     struct wrap
     {
@@ -5,5 +5,5 @@
     };
 
-    forall(otype T)
+    forall(T)
     T *? (wrap(T) rhs)
     {
Index: tests/zombies/gc_no_raii/bug-repro/field.c
===================================================================
--- tests/zombies/gc_no_raii/bug-repro/field.c	(revision fcd0b9d7282c8c187cc0111baf35ab6d4fb846a2)
+++ tests/zombies/gc_no_raii/bug-repro/field.c	(revision fd54fef231baeeb0016103bf19cc8e6d87287faf)
@@ -8,5 +8,5 @@
 //------------------------------------------------------------------------------
 //Declaration
-trait allocator_c(otype T, otype allocator_t)
+trait allocator_c(T, allocator_t)
 {
 	void ctor(allocator_t* const);
@@ -16,5 +16,5 @@
 };
 
-forall(otype T, otype allocator_t | allocator_c(T, allocator_t))
+forall(T, allocator_t | allocator_c(T, allocator_t))
 struct vector
 {
Index: tests/zombies/gc_no_raii/bug-repro/malloc.c
===================================================================
--- tests/zombies/gc_no_raii/bug-repro/malloc.c	(revision fcd0b9d7282c8c187cc0111baf35ab6d4fb846a2)
+++ tests/zombies/gc_no_raii/bug-repro/malloc.c	(revision fd54fef231baeeb0016103bf19cc8e6d87287faf)
@@ -1,3 +1,3 @@
-forall(otype T)
+forall(T)
 struct wrapper
 {
@@ -5,5 +5,5 @@
 };
 
-forall(otype T)
+forall(T)
 void ctor(wrapper(T)* this)
 {
@@ -11,5 +11,5 @@
 }
 
-forall(otype T)
+forall(T)
 wrapper(T) gcmalloc()
 {
@@ -19,5 +19,5 @@
 }
 
-forall(otype T)
+forall(T)
 wrapper(T)* ?=? (wrapper(T)* lhs, wrapper(T)* rhs)
 {
Index: tests/zombies/gc_no_raii/bug-repro/oddtype.c
===================================================================
--- tests/zombies/gc_no_raii/bug-repro/oddtype.c	(revision fcd0b9d7282c8c187cc0111baf35ab6d4fb846a2)
+++ tests/zombies/gc_no_raii/bug-repro/oddtype.c	(revision fd54fef231baeeb0016103bf19cc8e6d87287faf)
@@ -1,10 +1,10 @@
-forall(dtype T)
+forall(T &)
 struct wrap {
 	int i;
 };
 
-forall(otype T) void ?{}(wrap(T)* this) {}
-forall(otype T) void ?=?(wrap(T)* this) {}
-forall(otype T) void ^?{}(wrap(T)* this) {}
+forall(T) void ?{}(wrap(T)* this) {}
+forall(T) void ?=?(wrap(T)* this) {}
+forall(T) void ^?{}(wrap(T)* this) {}
 
 struct List_t {
Index: tests/zombies/gc_no_raii/bug-repro/push_back.h
===================================================================
--- tests/zombies/gc_no_raii/bug-repro/push_back.h	(revision fcd0b9d7282c8c187cc0111baf35ab6d4fb846a2)
+++ tests/zombies/gc_no_raii/bug-repro/push_back.h	(revision fd54fef231baeeb0016103bf19cc8e6d87287faf)
@@ -1,5 +1,5 @@
 //------------------------------------------------------------------------------
 //Declaration
-trait allocator_c(otype T, otype allocator_t) {
+trait allocator_c(T, allocator_t) {
 	void ctor(allocator_t* const);
 	void dtor(allocator_t* const);
@@ -8,5 +8,5 @@
 };
 
-forall(otype T, otype allocator_t | allocator_c(T, allocator_t))
+forall(T, allocator_t | allocator_c(T, allocator_t))
 struct vector
 {
@@ -17,13 +17,13 @@
 //------------------------------------------------------------------------------
 //Initialization
-forall(otype T, otype allocator_t | allocator_c(T, allocator_t))
+forall(T, allocator_t | allocator_c(T, allocator_t))
 void vector_ctor(vector(T, allocator_t) *const this);
 
-forall(otype T, otype allocator_t | allocator_c(T, allocator_t))
+forall(T, allocator_t | allocator_c(T, allocator_t))
 void dtor(vector(T, allocator_t) *const this);
 
 //------------------------------------------------------------------------------
 //Allocator
-forall(otype T)
+forall(T)
 struct heap_allocator
 {
@@ -32,14 +32,14 @@
 };
 
-forall(otype T)
+forall(T)
 void ctor(heap_allocator(T) *const this);
 
-forall(otype T)
+forall(T)
 void dtor(heap_allocator(T) *const this);
 
-forall(otype T)
+forall(T)
 void realloc(heap_allocator(T) *const this, size_t size);
 
-forall(otype T)
+forall(T)
 inline T* data(heap_allocator(T) *const this)
 {
@@ -49,5 +49,5 @@
 //------------------------------------------------------------------------------
 //Capacity
-forall(otype T, otype allocator_t | allocator_c(T, allocator_t))
+forall(T, allocator_t | allocator_c(T, allocator_t))
 inline bool empty(vector(T, allocator_t) *const this)
 {
@@ -55,5 +55,5 @@
 }
 
-forall(otype T, otype allocator_t | allocator_c(T, allocator_t))
+forall(T, allocator_t | allocator_c(T, allocator_t))
 inline bool size(vector(T, allocator_t) *const this)
 {
@@ -61,5 +61,5 @@
 }
 
-forall(otype T, otype allocator_t | allocator_c(T, allocator_t))
+forall(T, allocator_t | allocator_c(T, allocator_t))
 inline void reserve(vector(T, allocator_t) *const this, size_t size)
 {
@@ -69,4 +69,4 @@
 //------------------------------------------------------------------------------
 //Modifiers
-forall(otype T, otype allocator_t | allocator_c(T, allocator_t))
+forall(T, allocator_t | allocator_c(T, allocator_t))
 void push_back(vector(T, allocator_t) *const this, T value);
Index: tests/zombies/gc_no_raii/bug-repro/realloc.c
===================================================================
--- tests/zombies/gc_no_raii/bug-repro/realloc.c	(revision fcd0b9d7282c8c187cc0111baf35ab6d4fb846a2)
+++ tests/zombies/gc_no_raii/bug-repro/realloc.c	(revision fd54fef231baeeb0016103bf19cc8e6d87287faf)
@@ -1,5 +1,5 @@
 void* realloc(void*, unsigned long int);
 
-forall(otype T)
+forall(T)
 struct wrap
 {
@@ -7,5 +7,5 @@
 };
 
-forall(otype T)
+forall(T)
 static inline void realloc(wrap(T) *const this, unsigned long int size)
 {
Index: tests/zombies/gc_no_raii/bug-repro/return.c
===================================================================
--- tests/zombies/gc_no_raii/bug-repro/return.c	(revision fcd0b9d7282c8c187cc0111baf35ab6d4fb846a2)
+++ tests/zombies/gc_no_raii/bug-repro/return.c	(revision fd54fef231baeeb0016103bf19cc8e6d87287faf)
@@ -1,3 +1,3 @@
-forall(otype T)
+forall(T)
 struct wrapper
 {
@@ -5,5 +5,5 @@
 };
 
-forall(otype T)
+forall(T)
 wrapper(T) create()
 {
@@ -12,5 +12,5 @@
 }
 
-forall(otype T)
+forall(T)
 wrapper(T)* ?=?(wrapper(T)* lhs, wrapper(T)* rhs)
 {
Index: tests/zombies/gc_no_raii/bug-repro/return_template.c
===================================================================
--- tests/zombies/gc_no_raii/bug-repro/return_template.c	(revision fcd0b9d7282c8c187cc0111baf35ab6d4fb846a2)
+++ tests/zombies/gc_no_raii/bug-repro/return_template.c	(revision fd54fef231baeeb0016103bf19cc8e6d87287faf)
@@ -1,3 +1,3 @@
-forall(otype T)
+forall(T)
 struct wrap
 {
@@ -5,10 +5,10 @@
 };
 
-forall(otype T) void ?{}(wrap(T)* this);
-forall(otype T) void ?{}(wrap(T)* this, wrap(T)* rhs);
-forall(otype T) void ^?{}(wrap(T)* this);
-forall(otype T) void ?=?(wrap(T)* this, wrap(T)* rhs);
+forall(T) void ?{}(wrap(T)* this);
+forall(T) void ?{}(wrap(T)* this, wrap(T)* rhs);
+forall(T) void ^?{}(wrap(T)* this);
+forall(T) void ?=?(wrap(T)* this, wrap(T)* rhs);
 
-forall(otype T)
+forall(T)
 wrap(T) test()
 {
Index: tests/zombies/gc_no_raii/bug-repro/slow_malloc.c
===================================================================
--- tests/zombies/gc_no_raii/bug-repro/slow_malloc.c	(revision fcd0b9d7282c8c187cc0111baf35ab6d4fb846a2)
+++ tests/zombies/gc_no_raii/bug-repro/slow_malloc.c	(revision fd54fef231baeeb0016103bf19cc8e6d87287faf)
@@ -1,5 +1,5 @@
 #include <stdlib.hfa>
 
-forall(otype T)
+forall(T)
 struct heap_allocator
 {
Index: tests/zombies/gc_no_raii/bug-repro/zero.c
===================================================================
--- tests/zombies/gc_no_raii/bug-repro/zero.c	(revision fcd0b9d7282c8c187cc0111baf35ab6d4fb846a2)
+++ tests/zombies/gc_no_raii/bug-repro/zero.c	(revision fd54fef231baeeb0016103bf19cc8e6d87287faf)
@@ -1,3 +1,3 @@
-forall(otype T)
+forall(T)
 struct wrap
 {
@@ -5,5 +5,5 @@
 };
 
-forall(otype T)
+forall(T)
 int ?==? (wrap(T) lhs, wrap(T) rhs)
 {
@@ -14,5 +14,5 @@
 struct wrap(int) 0;
 /*/
-forall(otype T)
+forall(T)
 struct wrap(T) 0;
 //*/
Index: tests/zombies/gc_no_raii/src/gc.h
===================================================================
--- tests/zombies/gc_no_raii/src/gc.h	(revision fcd0b9d7282c8c187cc0111baf35ab6d4fb846a2)
+++ tests/zombies/gc_no_raii/src/gc.h	(revision fd54fef231baeeb0016103bf19cc8e6d87287faf)
@@ -13,5 +13,5 @@
 // }
 
-forall(otype T)
+forall(T)
 static inline void gcmalloc(gcpointer(T)* ptr)
 {
Index: tests/zombies/gc_no_raii/src/gcpointers.c
===================================================================
--- tests/zombies/gc_no_raii/src/gcpointers.c	(revision fcd0b9d7282c8c187cc0111baf35ab6d4fb846a2)
+++ tests/zombies/gc_no_raii/src/gcpointers.c	(revision fd54fef231baeeb0016103bf19cc8e6d87287faf)
@@ -113,21 +113,21 @@
 #endif
 
-forall(otype T) void ?{}(gcpointer(T)* this) {
+forall(T) void ?{}(gcpointer(T)* this) {
 	(&this->internal) {};
 }
 
-forall(otype T) void ?{}(gcpointer(T)* this, void* address) {
+forall(T) void ?{}(gcpointer(T)* this, void* address) {
 	(&this->internal) { address };
 }
 
-forall(otype T) void ?{}(gcpointer(T)* this, gcpointer(T) other) {
+forall(T) void ?{}(gcpointer(T)* this, gcpointer(T) other) {
 	(&this->internal) { other.internal };
 }
 
-forall(otype T) void ^?{}(gcpointer(T)* this) {
+forall(T) void ^?{}(gcpointer(T)* this) {
 	^?{}(&this->internal);
 }
 
-forall(otype T) gcpointer(T) ?=?(gcpointer(T)* this, gcpointer(T) rhs) {
+forall(T) gcpointer(T) ?=?(gcpointer(T)* this, gcpointer(T) rhs) {
 	this->internal = rhs.internal;
 	return *this;
@@ -136,10 +136,10 @@
 // forall(otype T) T *?(gcpointer(T) this);
 
-forall(otype T) T* get(gcpointer(T)* this) {
+forall(T) T* get(gcpointer(T)* this) {
 	return (T*)this->internal.ptr;
 }
 //
 // //Logical operators
-forall(otype T) int ?!=?(gcpointer(T) this, int zero) {
+forall(T) int ?!=?(gcpointer(T) this, int zero) {
 	return this.internal.ptr != 0;
 }
Index: tests/zombies/gc_no_raii/src/gcpointers.h
===================================================================
--- tests/zombies/gc_no_raii/src/gcpointers.h	(revision fcd0b9d7282c8c187cc0111baf35ab6d4fb846a2)
+++ tests/zombies/gc_no_raii/src/gcpointers.h	(revision fd54fef231baeeb0016103bf19cc8e6d87287faf)
@@ -4,5 +4,5 @@
 #include <stdint.h>
 
-forall(dtype T)
+forall(T &)
 struct gcpointer;
 
@@ -29,5 +29,5 @@
 #endif
 
-forall(dtype T)
+forall(T &)
 struct gcpointer
 {
@@ -36,16 +36,16 @@
 
 //
-forall(otype T) void ?{}(gcpointer(T)* this);
-forall(otype T) void ?{}(gcpointer(T)* this, void* address);
-forall(otype T) void ?{}(gcpointer(T)* this, gcpointer(T) other);
-forall(otype T) void ^?{}(gcpointer(T)* this);
-forall(otype T) gcpointer(T) ?=?(gcpointer(T)* this, gcpointer(T) rhs);
+forall(T) void ?{}(gcpointer(T)* this);
+forall(T) void ?{}(gcpointer(T)* this, void* address);
+forall(T) void ?{}(gcpointer(T)* this, gcpointer(T) other);
+forall(T) void ^?{}(gcpointer(T)* this);
+forall(T) gcpointer(T) ?=?(gcpointer(T)* this, gcpointer(T) rhs);
 
 
 // forall(otype T) T *?(gcpointer(T) this);
-forall(otype T) T* get(gcpointer(T)* this);
+forall(T) T* get(gcpointer(T)* this);
 
 //Logical operators
-forall(otype T) int ?!=?(gcpointer(T) this, int zero);
-forall(otype T) int ?!=?(gcpointer(T) this, gcpointer(T) rhs);
-forall(otype T) int ?==?(gcpointer(T) this, gcpointer(T) rhs);
+forall(T) int ?!=?(gcpointer(T) this, int zero);
+forall(T) int ?!=?(gcpointer(T) this, gcpointer(T) rhs);
+forall(T) int ?==?(gcpointer(T) this, gcpointer(T) rhs);
Index: tests/zombies/gc_no_raii/src/tools.h
===================================================================
--- tests/zombies/gc_no_raii/src/tools.h	(revision fcd0b9d7282c8c187cc0111baf35ab6d4fb846a2)
+++ tests/zombies/gc_no_raii/src/tools.h	(revision fd54fef231baeeb0016103bf19cc8e6d87287faf)
@@ -12,10 +12,10 @@
 // }
 
-trait has_equal(otype T)
+trait has_equal(T)
 {
 	signed int ?==?(T a, T b);
 };
 
-trait InputIterator_t(otype T, otype InputIterator)
+trait InputIterator_t(T, InputIterator)
 {
 	signed int ?==?(InputIterator a, InputIterator b);
@@ -26,5 +26,5 @@
 };
 
-forall(otype T | has_equal(T), otype InputIterator | InputIterator_t(T, InputIterator))
+forall(T | has_equal(T), InputIterator | InputIterator_t(T, InputIterator))
 static inline InputIterator find( InputIterator first, const InputIterator* const last, T val)
 {
Index: tests/zombies/hashtable.cfa
===================================================================
--- tests/zombies/hashtable.cfa	(revision fcd0b9d7282c8c187cc0111baf35ab6d4fb846a2)
+++ tests/zombies/hashtable.cfa	(revision fd54fef231baeeb0016103bf19cc8e6d87287faf)
@@ -14,14 +14,14 @@
 
 
-trait has_hash( otype K ) {
+trait has_hash( K ) {
     size_t hash(K);
     int ?==?( K, K );
 };
 
-trait hkey( otype K, dtype tN | has_hash(K) ) {
+trait hkey( K, tN & | has_hash(K) ) {
     K key(tN &);
 };
 
-forall( otype K, dtype tN, dtype tE | $dlistable(tN, tE) | hkey(K, tN) ) {
+forall( K, tN &, tE & | $dlistable(tN, tE) | hkey(K, tN) ) {
 
     struct hashtable {
@@ -39,5 +39,5 @@
 }
 
-forall( otype K, dtype tN, dtype tE | $dlistable(tN, tE) | hkey(K, tN) | { void defaultResumptionHandler(ht_fill_limit_crossed &); } ) {
+forall( K, tN &, tE & | $dlistable(tN, tE) | hkey(K, tN) | { void defaultResumptionHandler(ht_fill_limit_crossed &); } ) {
 
     void ?{}( hashtable(K, tN, tE) & this, size_t n_buckets, dlist(tN, tE) *buckets ) {
@@ -57,5 +57,5 @@
 }
 
-forall( otype K, dtype tN, dtype tE | $dlistable(tN, tE) | hkey(K, tN) ) {
+forall( K, tN &, tE & | $dlistable(tN, tE) | hkey(K, tN) ) {
 
     float fill_frac( hashtable(K, tN, tE) & this ) with(this) {
@@ -124,5 +124,5 @@
 
 
-trait heaped(dtype T) {
+trait heaped(T &) {
     T * alloc( size_t );
     void free( void * ); 
@@ -133,5 +133,5 @@
 }
 
-forall( otype K, dtype tN, dtype tE | $dlistable(tN, tE) | hkey(K, tN) | heaped( dlist(tN, tE) ) ) {
+forall( K, tN &, tE & | $dlistable(tN, tE) | hkey(K, tN) | heaped( dlist(tN, tE) ) ) {
 
     struct hashtable_dynamic { 
Index: tests/zombies/hashtable2.cfa
===================================================================
--- tests/zombies/hashtable2.cfa	(revision fcd0b9d7282c8c187cc0111baf35ab6d4fb846a2)
+++ tests/zombies/hashtable2.cfa	(revision fd54fef231baeeb0016103bf19cc8e6d87287faf)
@@ -69,9 +69,9 @@
 
 
-trait pretendsToMatter( dtype TTT ) {
+trait pretendsToMatter( TTT & ) {
     void actsmart(TTT &);
 };
 
-forall( dtype TTTx )
+forall( TTTx & )
 void actsmart(TTTx &) {}
 
@@ -86,5 +86,5 @@
 //   2. shows up in -CFA output as hashtable_rbs(), which is bad C; expecting hashtable_rbs*
 
-forall( otype Tt_unused | pretendsToMatter(Tt_unused) ) {
+forall( Tt_unused | pretendsToMatter(Tt_unused) ) {
 
     // hashtable of request by source
@@ -104,5 +104,5 @@
 }
 
-forall( otype Tt_unused | pretendsToMatter(Tt_unused) | { void defaultResumptionHandler(ht_fill_limit_crossed &); } ) {
+forall( Tt_unused | pretendsToMatter(Tt_unused) | { void defaultResumptionHandler(ht_fill_limit_crossed &); } ) {
 
     void ?{}( hashtable_rbs(Tt_unused) & this, size_t n_buckets, dlist(request_in_ht_by_src, request) *buckets,
@@ -135,5 +135,5 @@
 void defaultResumptionHandler( ht_auto_resize_pending & ex );
 
-forall( otype Tt_unused | pretendsToMatter(Tt_unused) ) {
+forall( Tt_unused | pretendsToMatter(Tt_unused) ) {
 
     float fill_frac( hashtable_rbs(Tt_unused) & this ) with(this) {
@@ -221,5 +221,5 @@
 
 
-trait heaped(dtype T) {
+trait heaped(T &) {
     T * alloc( size_t );
     void free( void * ); 
@@ -228,5 +228,5 @@
 void __dynamic_defaultResumptionHandler(ht_fill_limit_crossed &);
 
-forall( otype Tt_unused ) {
+forall( Tt_unused ) {
 
     struct hashtable_rbs_dynamic { 
@@ -263,5 +263,5 @@
 
 
-forall( otype Tt_unused | heaped( dlist(request_in_ht_by_src, request) ) ) {
+forall( Tt_unused | heaped( dlist(request_in_ht_by_src, request) ) ) {
 
     void ?{}( hashtable_rbs_dynamic(Tt_unused).resize_policy & this, size_t nbuckets_floor ) {
@@ -325,5 +325,5 @@
 }
 
-forall( otype Tt_unused ) {
+forall( Tt_unused ) {
     void rehashToLarger_STEP( hashtable_rbs_dynamic(Tt_unused) & this, size_t new_n_buckets ) with (this) {
         rehashToLarger( this, new_n_buckets );
Index: tests/zombies/huge.c
===================================================================
--- tests/zombies/huge.c	(revision fcd0b9d7282c8c187cc0111baf35ab6d4fb846a2)
+++ tests/zombies/huge.c	(revision fd54fef231baeeb0016103bf19cc8e6d87287faf)
@@ -14,5 +14,5 @@
 //
 
-int huge( int n, forall( otype T ) T (*f)( T ) ) {
+int huge( int n, forall( T ) T (*f)( T ) ) {
 	if ( n <= 0 )
 		return f( 0 );
Index: tests/zombies/it_out.c
===================================================================
--- tests/zombies/it_out.c	(revision fcd0b9d7282c8c187cc0111baf35ab6d4fb846a2)
+++ tests/zombies/it_out.c	(revision fd54fef231baeeb0016103bf19cc8e6d87287faf)
@@ -16,18 +16,18 @@
 typedef unsigned long streamsize_type;
 
-trait ostream( dtype os_type ) {
+trait ostream( os_type & ) {
 	os_type *write( os_type *, const char *, streamsize_type );
 	int fail( os_type * );
 };
 
-trait writeable( otype T ) {
-	forall( dtype os_type | ostream( os_type ) ) os_type * ?<<?( os_type *, T );
+trait writeable( T ) {
+	forall( os_type & | ostream( os_type ) ) os_type * ?<<?( os_type *, T );
 };
 
-forall( dtype os_type | ostream( os_type ) ) os_type * ?<<?( os_type *, char );
-forall( dtype os_type | ostream( os_type ) ) os_type * ?<<?( os_type *, int );
-forall( dtype os_type | ostream( os_type ) ) os_type * ?<<?( os_type *, const char * );
+forall( os_type & | ostream( os_type ) ) os_type * ?<<?( os_type *, char );
+forall( os_type & | ostream( os_type ) ) os_type * ?<<?( os_type *, int );
+forall( os_type & | ostream( os_type ) ) os_type * ?<<?( os_type *, const char * );
 
-trait istream( dtype is_type ) {
+trait istream( is_type & ) {
 	is_type *read( is_type *, char *, streamsize_type );
 	is_type *unread( is_type *, char );
@@ -36,12 +36,12 @@
 };
 
-trait readable( otype T ) {
-	forall( dtype is_type | istream( is_type ) ) is_type * ?<<?( is_type *, T );
+trait readable( T ) {
+	forall( is_type & | istream( is_type ) ) is_type * ?<<?( is_type *, T );
 };
 
-forall( dtype is_type | istream( is_type ) ) is_type * ?>>?( is_type *, char* );
-forall( dtype is_type | istream( is_type ) ) is_type * ?>>?( is_type *, int* );
+forall( is_type & | istream( is_type ) ) is_type * ?>>?( is_type *, char* );
+forall( is_type & | istream( is_type ) ) is_type * ?>>?( is_type *, int* );
 
-trait iterator( otype iterator_type, otype elt_type ) {
+trait iterator( iterator_type, elt_type ) {
 	iterator_type ?++( iterator_type* );
 	iterator_type ++?( iterator_type* );
@@ -52,12 +52,12 @@
 };
 
-forall( otype elt_type | writeable( elt_type ),
-		otype iterator_type | iterator( iterator_type, elt_type ),
-		dtype os_type | ostream( os_type ) )
+forall( elt_type | writeable( elt_type ),
+		iterator_type | iterator( iterator_type, elt_type ),
+		os_type & | ostream( os_type ) )
 void write_all( iterator_type begin, iterator_type end, os_type *os );
 
-forall( otype elt_type | writeable( elt_type ),
-		otype iterator_type | iterator( iterator_type, elt_type ),
-		dtype os_type | ostream( os_type ) )
+forall( elt_type | writeable( elt_type ),
+		iterator_type | iterator( iterator_type, elt_type ),
+		os_type & | ostream( os_type ) )
 void write_all( elt_type begin, iterator_type end, os_type *os ) {
 	os << begin;
Index: tests/zombies/new.c
===================================================================
--- tests/zombies/new.c	(revision fcd0b9d7282c8c187cc0111baf35ab6d4fb846a2)
+++ tests/zombies/new.c	(revision fd54fef231baeeb0016103bf19cc8e6d87287faf)
@@ -14,5 +14,5 @@
 //
 
-forall( otype T )
+forall( T )
 void f( T *t ) {
 	t--;
Index: tests/zombies/occursError.cfa
===================================================================
--- tests/zombies/occursError.cfa	(revision fcd0b9d7282c8c187cc0111baf35ab6d4fb846a2)
+++ tests/zombies/occursError.cfa	(revision fd54fef231baeeb0016103bf19cc8e6d87287faf)
@@ -1,5 +1,5 @@
-forall( otype T ) void f( void (*)( T, T * ) );
-forall( otype U ) void g( U,  U * );
-forall( otype U ) void h( U *, U );
+forall( T ) void f( void (*)( T, T * ) );
+forall( U ) void g( U,  U * );
+forall( U ) void h( U *, U );
 
 void test() {
Index: tests/zombies/prolog.c
===================================================================
--- tests/zombies/prolog.c	(revision fcd0b9d7282c8c187cc0111baf35ab6d4fb846a2)
+++ tests/zombies/prolog.c	(revision fd54fef231baeeb0016103bf19cc8e6d87287faf)
@@ -25,13 +25,13 @@
 void is_integer( int x ) {}
 
-trait ArithmeticType( otype T ) {
+trait ArithmeticType( T ) {
 	void is_arithmetic( T );
 };
 
-trait IntegralType( otype T | ArithmeticType( T ) ) {
+trait IntegralType( T | ArithmeticType( T ) ) {
 	void is_integer( T );
 };
 
-forall( otype T | IntegralType( T ) | { void printResult( T ); } )
+forall( T | IntegralType( T ) | { void printResult( T ); } )
 void hornclause( T param ) {
 	printResult( param );
Index: tests/zombies/quad.c
===================================================================
--- tests/zombies/quad.c	(revision fcd0b9d7282c8c187cc0111baf35ab6d4fb846a2)
+++ tests/zombies/quad.c	(revision fd54fef231baeeb0016103bf19cc8e6d87287faf)
@@ -16,10 +16,10 @@
 #include <fstream.hfa>
 
-forall( otype T | { T ?*?( T, T ); } )
+forall( T | { T ?*?( T, T ); } )
 T square( T t ) {
 	return t * t;
 }
 
-forall( otype U | { U square( U ); } )
+forall( U | { U square( U ); } )
 U quad( U u ) {
 	return square( square( u ) );
Index: tests/zombies/scope.cfa
===================================================================
--- tests/zombies/scope.cfa	(revision fcd0b9d7282c8c187cc0111baf35ab6d4fb846a2)
+++ tests/zombies/scope.cfa	(revision fd54fef231baeeb0016103bf19cc8e6d87287faf)
@@ -20,9 +20,9 @@
 y p;
 
-trait has_u( otype z ) {
+trait has_u( z ) {
 	z u(z);
 };
 
-forall( otype t | has_u( t ) )
+forall( t | has_u( t ) )
 y q( t the_t ) {
 	t y = u( the_t );
Index: tests/zombies/simplePoly.c
===================================================================
--- tests/zombies/simplePoly.c	(revision fcd0b9d7282c8c187cc0111baf35ab6d4fb846a2)
+++ tests/zombies/simplePoly.c	(revision fd54fef231baeeb0016103bf19cc8e6d87287faf)
@@ -14,5 +14,5 @@
 //
 
-forall( otype T, otype U | { T f( T, U ); } )
+forall( T, U | { T f( T, U ); } )
 T q( T t, U u ) {
 	return f( t, u );
Index: tests/zombies/simpler.c
===================================================================
--- tests/zombies/simpler.c	(revision fcd0b9d7282c8c187cc0111baf35ab6d4fb846a2)
+++ tests/zombies/simpler.c	(revision fd54fef231baeeb0016103bf19cc8e6d87287faf)
@@ -14,5 +14,5 @@
 //
 
-forall( otype T ) T id( T, T );
+forall( T ) T id( T, T );
 
 int main() {
Index: tests/zombies/specialize.c
===================================================================
--- tests/zombies/specialize.c	(revision fcd0b9d7282c8c187cc0111baf35ab6d4fb846a2)
+++ tests/zombies/specialize.c	(revision fd54fef231baeeb0016103bf19cc8e6d87287faf)
@@ -39,5 +39,5 @@
 }
 
-forall( otype T ) T f( T t )
+forall( T ) T f( T t )
 {
 	printf( "in f; sizeof T is %d\n", sizeof( T ) );
Index: tests/zombies/square.c
===================================================================
--- tests/zombies/square.c	(revision fcd0b9d7282c8c187cc0111baf35ab6d4fb846a2)
+++ tests/zombies/square.c	(revision fd54fef231baeeb0016103bf19cc8e6d87287faf)
@@ -16,5 +16,5 @@
 #include <fstream.hfa>
 
-forall( otype T | { T ?*?( T, T ); } )
+forall( T | { T ?*?( T, T ); } )
 T square( T t ) {
 	return t * t;
Index: tests/zombies/structMember.cfa
===================================================================
--- tests/zombies/structMember.cfa	(revision fcd0b9d7282c8c187cc0111baf35ab6d4fb846a2)
+++ tests/zombies/structMember.cfa	(revision fd54fef231baeeb0016103bf19cc8e6d87287faf)
@@ -66,5 +66,5 @@
 	S.T;
 	.S.T;
-	forall( otype S, otype T ) struct W {
+	forall( S, T ) struct W {
 		struct X {};
 	};
Index: tests/zombies/subrange.cfa
===================================================================
--- tests/zombies/subrange.cfa	(revision fcd0b9d7282c8c187cc0111baf35ab6d4fb846a2)
+++ tests/zombies/subrange.cfa	(revision fd54fef231baeeb0016103bf19cc8e6d87287faf)
@@ -1,5 +1,5 @@
 // A small context defining the notion of an ordered otype.  (The standard
 // library should probably contain a context for this purpose.)
-trait ordered(otype T) {
+trait ordered(T) {
     int ?<?(T, T), ?<=?(T, T);
 };
@@ -7,5 +7,5 @@
 // A subrange otype resembling an Ada subotype with a base otype and a range
 // constraint.
-otype subrange(otype base_t | ordered(base_t), base_t low = 0, base_t high = 8) = base_t;
+otype subrange(base_t | ordered(base_t), base_t low = 0, base_t high = 8) = base_t;
 
 // Note that subrange() can be applied to floating-point and pointer otypes, not
@@ -28,10 +28,10 @@
 
 // Convenient access to subrange bounds, for instance for iteration:
-forall (otype T, T low, T high)
+forall (T, T low, T high)
 T lbound( subrange(T, low, high) v) {
     return low;
 }
 
-forall (otype T, T low, T high)
+forall (T, T low, T high)
 T hbound( subrange(T, low, high) v) {
     return high;
@@ -44,5 +44,5 @@
 // of exception handling here.  Inlining allows the compiler to eliminate
 // bounds checks.
-forall (otype T | ordered(T), T low, T high)
+forall (T | ordered(T), T low, T high)
 inline subrange(T, low, high) ?=?(subrange(T, low, high)* target, T source) {
     if (low <= source && source <= high) *((T*)target) = source;
@@ -54,5 +54,5 @@
 // compares range bounds so that the compiler can optimize checks away when the
 // ranges are known to overlap.
-forall (otype T | ordered(T), T t_low, T t_high, T s_low, T s_high)
+forall (T | ordered(T), T t_low, T t_high, T s_low, T s_high)
 inline subrange(T, t_low, t_high) ?=?(subrange(T, t_low, t_high)* target,
 				      subrange(T, s_low, s_high) source) {
Index: tests/zombies/twice.c
===================================================================
--- tests/zombies/twice.c	(revision fcd0b9d7282c8c187cc0111baf35ab6d4fb846a2)
+++ tests/zombies/twice.c	(revision fd54fef231baeeb0016103bf19cc8e6d87287faf)
@@ -16,5 +16,5 @@
 #include <fstream.hfa>
 
-forall( otype T | { T ?+?( T, T ); } )
+forall( T | { T ?+?( T, T ); } )
 T twice( const T t ) {
 	return t + t;
Index: tests/zombies/typeGenerator.cfa
===================================================================
--- tests/zombies/typeGenerator.cfa	(revision fcd0b9d7282c8c187cc0111baf35ab6d4fb846a2)
+++ tests/zombies/typeGenerator.cfa	(revision fd54fef231baeeb0016103bf19cc8e6d87287faf)
@@ -1,8 +1,8 @@
-context addable( otype T ) {
+context addable( T ) {
 	T ?+?( T,T );
 	T ?=?( T*, T);
 };
 
-otype List1( otype T | addable( T ) ) = struct { T data; List1( T ) *next; } *;
+otype List1( T | addable( T ) ) = struct { T data; List1( T ) *next; } *;
 typedef List1( int ) ListOfIntegers;
 //List1( int ) li;
@@ -11,11 +11,11 @@
 [int] h( * List1( int ) p );							// new declaration syntax
 
-struct( otype T ) S2 { T i; };							// actual definition
+struct( T ) S2 { T i; };							// actual definition
 struct( int ) S3 v1, *p;								// expansion and instantiation
-struct( otype T )( int ) S24 { T i; } v2;				// actual definition, expansion and instantiation
-struct( otype T )( int ) { T i; } v2;					// anonymous actual definition, expansion and instantiation
+struct( T )( int ) S24 { T i; } v2;				// actual definition, expansion and instantiation
+struct( T )( int ) { T i; } v2;					// anonymous actual definition, expansion and instantiation
 
-struct( otype T | addable( T ) ) node { T data; struct( T ) node *next; };
-otype List( otype T ) = struct( T ) node *;
+struct( T | addable( T ) ) node { T data; struct( T ) node *next; };
+otype List( T ) = struct( T ) node *;
 List( int ) my_list;
 
Index: tests/zombies/withStatement.cfa
===================================================================
--- tests/zombies/withStatement.cfa	(revision fcd0b9d7282c8c187cc0111baf35ab6d4fb846a2)
+++ tests/zombies/withStatement.cfa	(revision fd54fef231baeeb0016103bf19cc8e6d87287faf)
@@ -54,10 +54,10 @@
 }
 
-forall( otype T )
+forall( T )
 struct Box {
 	T x;
 };
 
-forall( otype T )
+forall( T )
 void ?{}( Box(T) & this ) with( this ) { // with clause in polymorphic function
 	x{};
@@ -66,5 +66,5 @@
 void print( int i ) { sout | i; }
 
-forall( otype T | { void print( T ); })
+forall( T | { void print( T ); })
 void foo( T t ) {
 	Box( T ) b = { t };
Index: tests/zombies/wrapper/src/pointer.h
===================================================================
--- tests/zombies/wrapper/src/pointer.h	(revision fcd0b9d7282c8c187cc0111baf35ab6d4fb846a2)
+++ tests/zombies/wrapper/src/pointer.h	(revision fd54fef231baeeb0016103bf19cc8e6d87287faf)
@@ -8,5 +8,5 @@
 // type safe malloc / free
 
-forall(otype T)
+forall(T)
 T* new()
 {
@@ -16,5 +16,5 @@
 }
 
-forall(otype T)
+forall(T)
 void delete(T* p)
 {