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) {