Index: tests/forall.cfa
===================================================================
--- tests/forall.cfa	(revision 66812dd99f2cc97ee7d08f95d6b009fa64a41a6b)
+++ tests/forall.cfa	(revision dafbde8dedf38315f3298b109629f5e705f00ebe)
@@ -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; };
