Bind pattern slots with ?, drop parens from 0-ary tag constructors, translate 0-ary constructors as constants. Rustc loses ~300kb.

3 files changed, 24 insertions, 24 deletions

diff --git a/src/lib/deque.rs b/src/lib/deque.rs
index 21acdfc9..96a63880 100644
--- a/src/lib/deque.rs
+++ b/src/lib/deque.rs
@@ -38,7 +38,7 @@ fn create[T]() -> t[T] {
       if (i < nelts) {
         ret old.((lo + i) % nelts);
       } else {
-        ret util.none[T]();
+        ret util.none[T];
       }
     }
 
@@ -49,7 +49,7 @@ fn create[T]() -> t[T] {
 
   fn get[T](vec[cell[T]] elts, uint i) -> T {
     alt (elts.(i)) {
-      case (util.some[T](t)) { ret t; }
+      case (util.some[T](?t)) { ret t; }
       case (_) { fail; }
     }
   }
@@ -98,7 +98,7 @@ fn create[T]() -> t[T] {
      */
     fn pop_front() -> T {
       let T t = get[T](elts, lo);
-      elts.(lo) = util.none[T]();
+      elts.(lo) = util.none[T];
       lo = (lo + 1u) % _vec.len[cell[T]](elts);
       nelts -= 1u;
       ret t;
@@ -112,7 +112,7 @@ fn create[T]() -> t[T] {
       }
 
       let T t = get[T](elts, hi);
-      elts.(hi) = util.none[T]();
+      elts.(hi) = util.none[T];
       nelts -= 1u;
       ret t;
     }
@@ -131,7 +131,7 @@ fn create[T]() -> t[T] {
     }
 
   }
-  let vec[cell[T]] v = _vec.init_elt[cell[T]](util.none[T](),
+  let vec[cell[T]] v = _vec.init_elt[cell[T]](util.none[T],
                                               initial_capacity);
 
   ret deque[T](0u, 0u, 0u, v);
diff --git a/src/lib/map.rs b/src/lib/map.rs
index decc2216..14d76013 100644
--- a/src/lib/map.rs
+++ b/src/lib/map.rs
@@ -28,13 +28,13 @@ fn mk_hashmap[K, V](&hashfn[K] hasher, &eqfn[K] eqer) -> hashmap[K, V] {
   let util.rational load_factor = rec(num=3, den=4);
 
   tag bucket[K, V] {
-    nil();
-    deleted();
+    nil;
+    deleted;
     some(K, V);
   }
 
   fn make_buckets[K, V](uint nbkts) -> vec[mutable bucket[K, V]] {
-    ret _vec.init_elt[mutable bucket[K, V]](nil[K, V](), nbkts);
+    ret _vec.init_elt[mutable bucket[K, V]](nil[K, V], nbkts);
   }
 
   // Derive two hash functions from the one given by taking the upper
@@ -81,7 +81,7 @@ fn mk_hashmap[K, V](&hashfn[K] hasher, &eqfn[K] eqer) -> hashmap[K, V] {
     while (i < nbkts) {
       let uint j = hash[K](hasher, nbkts, key, i);
       alt (bkts.(j)) {
-        case (some[K, V](k, _)) {
+        case (some[K, V](?k, _)) {
           if (eqer(key, k)) {
             bkts.(j) = some[K, V](k, val);
             ret false;
@@ -108,19 +108,19 @@ fn mk_hashmap[K, V](&hashfn[K] hasher, &eqfn[K] eqer) -> hashmap[K, V] {
     while (i < nbkts) {
       let uint j = (hash[K](hasher, nbkts, key, i));
       alt (bkts.(j)) {
-        case (some[K, V](k, v)) {
+        case (some[K, V](?k, ?v)) {
           if (eqer(key, k)) {
             ret util.some[V](v);
           }
         }
         case (nil[K, V]()) {
-          ret util.none[V]();
+          ret util.none[V];
         }
         case (deleted[K, V]()) { }
       }
       i += 1u;
     }
-    ret util.none[V]();
+    ret util.none[V];
   }
 
 
@@ -131,7 +131,7 @@ fn mk_hashmap[K, V](&hashfn[K] hasher, &eqfn[K] eqer) -> hashmap[K, V] {
   {
     for (bucket[K, V] b in oldbkts) {
       alt (b) {
-        case (some[K, V](k, v)) {
+        case (some[K, V](?k, ?v)) {
           insert_common[K, V](hasher, eqer, newbkts, nnewbkts, k, v);
         }
         case (_) { }
@@ -174,7 +174,7 @@ fn mk_hashmap[K, V](&hashfn[K] hasher, &eqfn[K] eqer) -> hashmap[K, V] {
 
     fn get(&K key) -> V {
       alt (find_common[K, V](hasher, eqer, bkts, nbkts, key)) {
-        case (util.some[V](val)) { ret val; }
+        case (util.some[V](?val)) { ret val; }
         case (_) { fail; }
       }
     }
@@ -188,21 +188,21 @@ fn mk_hashmap[K, V](&hashfn[K] hasher, &eqfn[K] eqer) -> hashmap[K, V] {
       while (i < nbkts) {
         let uint j = (hash[K](hasher, nbkts, key, i));
         alt (bkts.(j)) {
-          case (some[K, V](k, v)) {
+          case (some[K, V](?k, ?v)) {
             if (eqer(key, k)) {
-              bkts.(j) = deleted[K, V]();
+              bkts.(j) = deleted[K, V];
               nelts -= 1u;
               ret util.some[V](v);
             }
           }
-          case (deleted[K, V]()) { }
-          case (nil[K, V]()) {
-            ret util.none[V]();
+          case (deleted[K, V]) { }
+          case (nil[K, V]) {
+            ret util.none[V];
           }
         }
         i += 1u;
       }
-      ret util.none[V]();
+      ret util.none[V];
     }
 
     fn rehash() {
diff --git a/src/lib/util.rs b/src/lib/util.rs
index dee93773..9b55d89a 100644
--- a/src/lib/util.rs
+++ b/src/lib/util.rs
@@ -1,5 +1,5 @@
 tag option[T] {
-  none();
+  none;
   some(T);
 }
 
@@ -7,11 +7,11 @@ type operator[T, U] = fn(&T) -> U;
 
 fn option_map[T, U](&operator[T, U] f, &option[T] opt) -> option[U] {
   alt (opt) {
-    case (some[T](x)) {
+    case (some[T](?x)) {
       ret some[U](f(x));
     }
-    case (none[T]()) {
-      ret none[U]();
+    case (none[T]) {
+      ret none[U];
     }
   }
 }