Switch alts to use arrows

25 files changed, 829 insertions, 972 deletions

diff --git a/src/libstd/base64.rs b/src/libstd/base64.rs
index 8ee0253ba40..e76d3093c17 100644
--- a/src/libstd/base64.rs
+++ b/src/libstd/base64.rs
@@ -31,15 +31,15 @@ impl of to_base64 for ~[u8] {
         }
 
         alt check len % 3u {
-          0u { }
-          1u {
+          0u => (),
+          1u => {
             let n = (self[i] as uint) << 16u;
             str::push_char(s, chars[(n >> 18u) & 63u]);
             str::push_char(s, chars[(n >> 12u) & 63u]);
             str::push_char(s, '=');
             str::push_char(s, '=');
           }
-          2u {
+          2u => {
             let n = (self[i] as uint) << 16u | (self[i + 1u] as uint) << 8u;
             str::push_char(s, chars[(n >> 18u) & 63u]);
             str::push_char(s, chars[(n >> 12u) & 63u]);
@@ -97,18 +97,16 @@ impl of from_base64 for ~[u8] {
                     n |= 0x3Fu;
                 } else if ch == '=' {
                     alt len - i {
-                      1u {
+                      1u => {
                         vec::push(r, ((n >> 16u) & 0xFFu) as u8);
                         vec::push(r, ((n >> 8u ) & 0xFFu) as u8);
                         return copy r;
                       }
-                      2u {
+                      2u => {
                         vec::push(r, ((n >> 10u) & 0xFFu) as u8);
                         return copy r;
                       }
-                      _ {
-                        fail ~"invalid base64 padding";
-                      }
+                      _ => fail ~"invalid base64 padding"
                     }
                 } else {
                     fail ~"invalid base64 character";
diff --git a/src/libstd/bitv.rs b/src/libstd/bitv.rs
index 94a4f1ba977..de51e2b7f51 100644
--- a/src/libstd/bitv.rs
+++ b/src/libstd/bitv.rs
@@ -180,35 +180,25 @@ class bitv {
                 self.die();
             }
             alt self.rep {
-              small(s) {
-                alt other.rep {
-                  small(s1) {
-                    alt op {
-                      union      { s.union(s1) }
-                      intersect  { s.intersect(s1) }
-                      assign     { s.become(s1) }
-                      difference { s.difference(s1) }
-                    }
-                  }
-                 big(s1) {
-                     self.die();
-                 }
+              small(s) => alt other.rep {
+                small(s1) => alt op {
+                  union      => s.union(s1),
+                  intersect  => s.intersect(s1),
+                  assign     => s.become(s1),
+                  difference => s.difference(s1)
+                }
+                big(s1) => self.die()
               }
-            }
-            big(s) {
-                alt other.rep {
-                  small(_) { self.die(); }
-                  big(s1) {
-                    alt op {
-                      union      { s.union(s1) }
-                      intersect  { s.intersect(s1) }
-                      assign     { s.become(s1) }
-                      difference { s.difference(s1) }
-                    }
-                  }
+              big(s) => alt other.rep {
+                small(_) => self.die(),
+                big(s1) => alt op {
+                  union      => s.union(s1),
+                  intersect  => s.intersect(s1),
+                  assign     => s.become(s1),
+                  difference => s.difference(s1)
                 }
+              }
             }
-          }
         }
     }
 
@@ -243,10 +233,10 @@ class bitv {
     #[inline(always)]
     fn clone() -> ~bitv {
         ~alt self.rep {
-          small(b) {
+          small(b) => {
             bitv{nbits: self.nbits, rep: small(~small_bitv{bits: b.bits})}
           }
-          big(b) {
+          big(b) => {
             let st = to_mut(from_elem(self.nbits / uint_bits + 1, 0));
             let len = st.len();
             for uint::range(0, len) |i| { st[i] = b.storage[i]; };
@@ -260,8 +250,8 @@ class bitv {
     pure fn get(i: uint) -> bool {
        assert (i < self.nbits);
        alt self.rep {
-         big(b)   { b.get(i) }
-         small(s) { s.get(i) }
+         big(b)   => b.get(i),
+         small(s) => s.get(i)
        }
     }
 
@@ -274,8 +264,8 @@ class bitv {
     fn set(i: uint, x: bool) {
       assert (i < self.nbits);
       alt self.rep {
-        big(b) { b.set(i, x); }
-        small(s) { s.set(i, x); }
+        big(b)   => b.set(i, x),
+        small(s) => s.set(i, x)
       }
     }
 
@@ -289,19 +279,13 @@ class bitv {
     fn equal(v1: bitv) -> bool {
       if self.nbits != v1.nbits { return false; }
       alt self.rep {
-        small(b) {
-          alt v1.rep {
-            small(b1) { b.equals(b1) }
-            _ { false }
-          }
+        small(b) => alt v1.rep {
+          small(b1) => b.equals(b1),
+          _ => false
         }
-        big(s) {
-          alt v1.rep {
-            big(s1) {
-              s.equals(s1)
-            }
-            small(_) { return false; }
-          }
+        big(s) => alt v1.rep {
+          big(s1) => s.equals(s1),
+          small(_) => return false
         }
       }
     }
@@ -310,10 +294,8 @@ class bitv {
     #[inline(always)]
     fn clear() {
         alt self.rep {
-          small(b) { b.clear(); }
-          big(s) {
-            for s.each_storage() |w| { w = 0u }
-          }
+          small(b) => b.clear(),
+          big(s) => for s.each_storage() |w| { w = 0u }
         }
     }
 
@@ -321,20 +303,16 @@ class bitv {
     #[inline(always)]
     fn set_all() {
       alt self.rep {
-        small(b) { b.set_all(); }
-        big(s) {
-          for s.each_storage() |w| { w = !0u } }
-      }
+        small(b) => b.set_all(),
+        big(s) => for s.each_storage() |w| { w = !0u } }
     }
 
     /// Invert all bits
     #[inline(always)]
     fn invert() {
       alt self.rep {
-        small(b) { b.invert(); }
-        big(s) {
-          for s.each_storage() |w| { w = !w } }
-      }
+        small(b) => b.invert(),
+        big(s) => for s.each_storage() |w| { w = !w } }
     }
 
 /**
@@ -352,8 +330,8 @@ class bitv {
     #[inline(always)]
     fn is_true() -> bool {
       alt self.rep {
-        small(b) { b.is_true() }
-        _ {
+        small(b) => b.is_true(),
+        _ => {
           for self.each() |i| { if !i { return false; } }
           true
         }
@@ -373,8 +351,8 @@ class bitv {
 
     fn is_false() -> bool {
       alt self.rep {
-        small(b) { b.is_false() }
-        big(_) {
+        small(b) => b.is_false(),
+        big(_) => {
           for self.each() |i| { if i { return false; } }
           true
         }
diff --git a/src/libstd/c_vec.rs b/src/libstd/c_vec.rs
index b80ec82bcf3..e00ee13949b 100644
--- a/src/libstd/c_vec.rs
+++ b/src/libstd/c_vec.rs
@@ -47,8 +47,8 @@ class dtor_res {
   new(dtor: option<fn@()>) { self.dtor = dtor; }
   drop {
     alt self.dtor {
-      option::none { }
-      option::some(f) { f(); }
+      option::none => (),
+      option::some(f) => f()
     }
   }
 }
diff --git a/src/libstd/deque.rs b/src/libstd/deque.rs
index f3feb26ebb6..5e98f3c7054 100644
--- a/src/libstd/deque.rs
+++ b/src/libstd/deque.rs
@@ -41,7 +41,7 @@ fn create<T: copy>() -> t<T> {
         return rv;
     }
     fn get<T: copy>(elts: dvec<cell<T>>, i: uint) -> T {
-        alt elts.get_elt(i) { some(t) { t } _ { fail } }
+        alt elts.get_elt(i) { some(t) => t, _ => fail }
     }
 
     type repr<T> = {mut nelts: uint,
@@ -239,45 +239,35 @@ mod tests {
         fn intboxeq(&&a: @int, &&b: @int) -> bool { return a == b; }
         fn taggyeq(a: taggy, b: taggy) -> bool {
             alt a {
-              one(a1) {
-                alt b { one(b1) {return a1 == b1; } _ { return false; } }
+              one(a1) => alt b {
+                one(b1) => return a1 == b1,
+                _ => return false
               }
-              two(a1, a2) {
-                alt b {
-                  two(b1, b2) { return a1 == b1 && a2 == b2; }
-                  _ { return false; }
-                }
+              two(a1, a2) => alt b {
+                two(b1, b2) => return a1 == b1 && a2 == b2,
+                _ => return false
               }
-              three(a1, a2, a3) {
-                alt b {
-                  three(b1, b2, b3) {
-                    return a1 == b1 && a2 == b2 && a3 == b3;
-                  }
-                  _ { return false; }
-                }
+              three(a1, a2, a3) => alt b {
+                three(b1, b2, b3) => return a1 == b1 && a2 == b2 && a3 == b3,
+                _ => return false
               }
             }
         }
         fn taggypareq<T>(a: taggypar<T>, b: taggypar<T>) -> bool {
             alt a {
-              onepar::<T>(a1) {
-                alt b {
-                  onepar::<T>(b1) { return a1 == b1; } _ { return false; }
-                }
+              onepar::<T>(a1) => alt b {
+                onepar::<T>(b1) => return a1 == b1,
+                _ => return false
               }
-              twopar::<T>(a1, a2) {
-                alt b {
-                  twopar::<T>(b1, b2) { return a1 == b1 && a2 == b2; }
-                  _ { return false; }
-                }
+              twopar::<T>(a1, a2) => alt b {
+                twopar::<T>(b1, b2) => return a1 == b1 && a2 == b2,
+                _ => return false
               }
-              threepar::<T>(a1, a2, a3) {
-                alt b {
-                  threepar::<T>(b1, b2, b3) {
-                    return a1 == b1 && a2 == b2 && a3 == b3;
-                  }
-                  _ { return false; }
+              threepar::<T>(a1, a2, a3) => alt b {
+                threepar::<T>(b1, b2, b3) => {
+                    return a1 == b1 && a2 == b2 && a3 == b3
                 }
+                _ => return false
               }
             }
         }
diff --git a/src/libstd/ebml.rs b/src/libstd/ebml.rs
index 46ccaa2d096..78ec45659cc 100644
--- a/src/libstd/ebml.rs
+++ b/src/libstd/ebml.rs
@@ -114,8 +114,8 @@ fn maybe_get_doc(d: doc, tg: uint) -> option<doc> {
 
 fn get_doc(d: doc, tg: uint) -> doc {
     alt maybe_get_doc(d, tg) {
-      some(d) { return d; }
-      none {
+      some(d) => return d,
+      none => {
         error!{"failed to find block with tag %u", tg};
         fail;
       }
@@ -190,21 +190,13 @@ enum writer {
 
 fn write_sized_vuint(w: io::writer, n: uint, size: uint) {
     alt size {
-      1u {
-        w.write(&[0x80u8 | (n as u8)]);
-      }
-      2u {
-        w.write(&[0x40u8 | ((n >> 8_u) as u8), n as u8]);
-      }
-      3u {
-        w.write(&[0x20u8 | ((n >> 16_u) as u8), (n >> 8_u) as u8,
-                 n as u8]);
-      }
-      4u {
-        w.write(&[0x10u8 | ((n >> 24_u) as u8), (n >> 16_u) as u8,
-                 (n >> 8_u) as u8, n as u8]);
-      }
-      _ { fail fmt!{"vint to write too big: %?", n}; }
+      1u => w.write(&[0x80u8 | (n as u8)]),
+      2u => w.write(&[0x40u8 | ((n >> 8_u) as u8), n as u8]),
+      3u => w.write(&[0x20u8 | ((n >> 16_u) as u8), (n >> 8_u) as u8,
+                      n as u8]),
+      4u => w.write(&[0x10u8 | ((n >> 24_u) as u8), (n >> 16_u) as u8,
+                      (n >> 8_u) as u8, n as u8]),
+      _ => fail fmt!{"vint to write too big: %?", n}
     };
 }
 
@@ -602,10 +594,9 @@ fn test_option_int() {
     fn serialize_0<S: serialization::serializer>(s: S, v: option<int>) {
         do s.emit_enum(~"core::option::t") {
             alt v {
-              none {
-                s.emit_enum_variant(~"core::option::none", 0u, 0u, || { } );
-              }
-              some(v0) {
+              none => s.emit_enum_variant(
+                  ~"core::option::none", 0u, 0u, || { } ),
+              some(v0) => {
                 do s.emit_enum_variant(~"core::option::some", 1u, 1u) {
                     s.emit_enum_variant_arg(0u, || serialize_1(s, v0));
                 }
@@ -622,8 +613,8 @@ fn test_option_int() {
         do s.read_enum(~"core::option::t") {
             do s.read_enum_variant |i| {
                 alt check i {
-                  0u { none }
-                  1u {
+                  0u => none,
+                  1u => {
                     let v0 = do s.read_enum_variant_arg(0u) {
                         deserialize_1(s)
                     };
diff --git a/src/libstd/fun_treemap.rs b/src/libstd/fun_treemap.rs
index 6a3b40b88ff..e849d77ded6 100644
--- a/src/libstd/fun_treemap.rs
+++ b/src/libstd/fun_treemap.rs
@@ -31,8 +31,8 @@ fn init<K, V>() -> treemap<K, V> { @empty }
 /// Insert a value into the map
 fn insert<K: copy, V: copy>(m: treemap<K, V>, k: K, v: V) -> treemap<K, V> {
     @alt m {
-       @empty { node(@k, @v, @empty, @empty) }
-       @node(@kk, vv, left, right) {
+       @empty => node(@k, @v, @empty, @empty),
+       @node(@kk, vv, left, right) => {
          if k < kk {
              node(@kk, vv, insert(left, k, v), right)
          } else if k == kk {
@@ -45,8 +45,8 @@ fn insert<K: copy, V: copy>(m: treemap<K, V>, k: K, v: V) -> treemap<K, V> {
 /// Find a value based on the key
 fn find<K, V: copy>(m: treemap<K, V>, k: K) -> option<V> {
     alt *m {
-      empty { none }
-      node(@kk, @v, left, right) {
+      empty => none,
+      node(@kk, @v, left, right) => {
         if k == kk {
             some(v)
         } else if k < kk { find(left, k) } else { find(right, k) }
@@ -57,13 +57,13 @@ fn find<K, V: copy>(m: treemap<K, V>, k: K) -> option<V> {
 /// Visit all pairs in the map in order.
 fn traverse<K, V: copy>(m: treemap<K, V>, f: fn(K, V)) {
     alt *m {
-      empty { }
+      empty => (),
       /*
         Previously, this had what looked like redundant
         matches to me, so I changed it. but that may be a
         de-optimization -- tjc
        */
-      node(@k, @v, left, right) {
+      node(@k, @v, left, right) => {
         // copy v to make aliases work out
         let v1 = v;
         traverse(left, f);
diff --git a/src/libstd/getopts.rs b/src/libstd/getopts.rs
index ed0ee4ff5ed..c05c685daa8 100644
--- a/src/libstd/getopts.rs
+++ b/src/libstd/getopts.rs
@@ -140,7 +140,10 @@ fn is_arg(arg: ~str) -> bool {
 }
 
 fn name_str(nm: name) -> ~str {
-    return alt nm { short(ch) { str::from_char(ch) } long(s) { s } };
+    return alt nm {
+      short(ch) => str::from_char(ch),
+      long(s) => s
+    };
 }
 
 fn find_opt(opts: ~[opt], nm: name) -> option<uint> {
@@ -162,18 +165,14 @@ enum fail_ {
 /// Convert a `fail_` enum into an error string
 fn fail_str(f: fail_) -> ~str {
     return alt f {
-          argument_missing(nm) {
-            ~"Argument to option '" + nm + ~"' missing."
-          }
-          unrecognized_option(nm) { ~"Unrecognized option: '" + nm + ~"'." }
-          option_missing(nm) { ~"Required option '" + nm + ~"' missing." }
-          option_duplicated(nm) {
-            ~"Option '" + nm + ~"' given more than once."
-          }
-          unexpected_argument(nm) {
-            ~"Option " + nm + ~" does not take an argument."
-          }
-        };
+      argument_missing(nm) => ~"Argument to option '" + nm + ~"' missing.",
+      unrecognized_option(nm) => ~"Unrecognized option: '" + nm + ~"'.",
+      option_missing(nm) => ~"Required option '" + nm + ~"' missing.",
+      option_duplicated(nm) => ~"Option '" + nm + ~"' given more than once.",
+      unexpected_argument(nm) => {
+        ~"Option " + nm + ~" does not take an argument."
+      }
+    };
 }
 
 /**
@@ -235,15 +234,13 @@ fn getopts(args: ~[~str], opts: ~[opt]) -> result unsafe {
                     */
 
                     alt find_opt(opts, opt) {
-                      some(id) {
-                        last_valid_opt_id = option::some(id);
-                      }
-                      none {
+                      some(id) => last_valid_opt_id = option::some(id),
+                      none => {
                         let arg_follows =
                             option::is_some(last_valid_opt_id) &&
                             alt opts[option::get(last_valid_opt_id)].hasarg {
-                              yes | maybe { true }
-                              no { false }
+                              yes | maybe => true,
+                              no => false
                             };
                         if arg_follows && j + 1 < curlen {
                             i_arg = option::some(str::slice(cur, j, curlen));
@@ -261,17 +258,17 @@ fn getopts(args: ~[~str], opts: ~[opt]) -> result unsafe {
             for vec::each(names) |nm| {
                 name_pos += 1u;
                 let optid = alt find_opt(opts, nm) {
-                  some(id) { id }
-                  none { return err(unrecognized_option(name_str(nm))); }
+                  some(id) => id,
+                  none => return err(unrecognized_option(name_str(nm)))
                 };
                 alt opts[optid].hasarg {
-                  no {
+                  no => {
                     if !option::is_none::<~str>(i_arg) {
                         return err(unexpected_argument(name_str(nm)));
                     }
                     vec::push(vals[optid], given);
                   }
-                  maybe {
+                  maybe => {
                     if !option::is_none::<~str>(i_arg) {
                         vec::push(vals[optid], val(option::get(i_arg)));
                     } else if name_pos < vec::len::<name>(names) ||
@@ -279,7 +276,7 @@ fn getopts(args: ~[~str], opts: ~[opt]) -> result unsafe {
                         vec::push(vals[optid], given);
                     } else { i += 1u; vec::push(vals[optid], val(args[i])); }
                   }
-                  yes {
+                  yes => {
                     if !option::is_none::<~str>(i_arg) {
                         vec::push(vals[optid],
                                   val(option::get::<~str>(i_arg)));
@@ -313,9 +310,12 @@ fn getopts(args: ~[~str], opts: ~[opt]) -> result unsafe {
 
 fn opt_vals(m: matches, nm: ~str) -> ~[optval] {
     return alt find_opt(m.opts, mkname(nm)) {
-          some(id) { m.vals[id] }
-          none { error!{"No option '%s' defined", nm}; fail }
-        };
+      some(id) => m.vals[id],
+      none => {
+        error!{"No option '%s' defined", nm};
+        fail
+      }
+    };
 }
 
 fn opt_val(m: matches, nm: ~str) -> optval { return opt_vals(m, nm)[0]; }
@@ -329,8 +329,8 @@ fn opt_present(m: matches, nm: ~str) -> bool {
 fn opts_present(m: matches, names: ~[~str]) -> bool {
     for vec::each(names) |nm| {
         alt find_opt(m.opts, mkname(nm)) {
-          some(_) { return true; }
-          _ { }
+          some(_) => return true,
+          _ => ()
         }
     }
     return false;
@@ -344,7 +344,7 @@ fn opts_present(m: matches, names: ~[~str]) -> bool {
  * argument
  */
 fn opt_str(m: matches, nm: ~str) -> ~str {
-    return alt opt_val(m, nm) { val(s) { s } _ { fail } };
+    return alt opt_val(m, nm) { val(s) => s, _ => fail };
 }
 
 /**
@@ -356,8 +356,8 @@ fn opt_str(m: matches, nm: ~str) -> ~str {
 fn opts_str(m: matches, names: ~[~str]) -> ~str {
     for vec::each(names) |nm| {
         alt opt_val(m, nm) {
-          val(s) { return s }
-          _ {  }
+          val(s) => return s,
+          _ => ()
         }
     }
     fail;
@@ -373,7 +373,7 @@ fn opts_str(m: matches, names: ~[~str]) -> ~str {
 fn opt_strs(m: matches, nm: ~str) -> ~[~str] {
     let mut acc: ~[~str] = ~[];
     for vec::each(opt_vals(m, nm)) |v| {
-        alt v { val(s) { vec::push(acc, s); } _ { } }
+        alt v { val(s) => vec::push(acc, s), _ => () }
     }
     return acc;
 }
@@ -382,7 +382,7 @@ fn opt_strs(m: matches, nm: ~str) -> ~[~str] {
 fn opt_maybe_str(m: matches, nm: ~str) -> option<~str> {
     let vals = opt_vals(m, nm);
     if vec::len::<optval>(vals) == 0u { return none::<~str>; }
-    return alt vals[0] { val(s) { some::<~str>(s) } _ { none::<~str> } };
+    return alt vals[0] { val(s) => some::<~str>(s), _ => none::<~str> };
 }
 
 
@@ -396,7 +396,7 @@ fn opt_maybe_str(m: matches, nm: ~str) -> option<~str> {
 fn opt_default(m: matches, nm: ~str, def: ~str) -> option<~str> {
     let vals = opt_vals(m, nm);
     if vec::len::<optval>(vals) == 0u { return none::<~str>; }
-    return alt vals[0] { val(s) { some::<~str>(s) } _ { some::<~str>(def) } }
+    return alt vals[0] { val(s) => some::<~str>(s), _ => some::<~str>(def) }
 }
 
 #[cfg(test)]
@@ -414,11 +414,11 @@ mod tests {
 
     fn check_fail_type(f: fail_, ft: fail_type) {
         alt f {
-          argument_missing(_) { assert (ft == argument_missing_); }
-          unrecognized_option(_) { assert (ft == unrecognized_option_); }
-          option_missing(_) { assert (ft == option_missing_); }
-          option_duplicated(_) { assert (ft == option_duplicated_); }
-          unexpected_argument(_) { assert (ft == unexpected_argument_); }
+          argument_missing(_) => assert ft == argument_missing_,
+          unrecognized_option(_) => assert ft == unrecognized_option_,
+          option_missing(_) => assert ft == option_missing_,
+          option_duplicated(_) => assert ft == option_duplicated_,
+          unexpected_argument(_) => assert ft == unexpected_argument_
         }
     }
 
@@ -430,7 +430,7 @@ mod tests {
         let opts = ~[reqopt(~"test")];
         let rs = getopts(args, opts);
         alt check rs {
-          ok(m) {
+          ok(m) => {
             assert (opt_present(m, ~"test"));
             assert (opt_str(m, ~"test") == ~"20");
           }
@@ -443,8 +443,8 @@ mod tests {
         let opts = ~[reqopt(~"test")];
         let rs = getopts(args, opts);
         alt rs {
-          err(f) { check_fail_type(f, option_missing_); }
-          _ { fail; }
+          err(f) => check_fail_type(f, option_missing_),
+          _ => fail
         }
     }
 
@@ -454,8 +454,8 @@ mod tests {
         let opts = ~[reqopt(~"test")];
         let rs = getopts(args, opts);
         alt rs {
-          err(f) { check_fail_type(f, argument_missing_); }
-          _ { fail; }
+          err(f) => check_fail_type(f, argument_missing_),
+          _ => fail
         }
     }
 
@@ -465,8 +465,8 @@ mod tests {
         let opts = ~[reqopt(~"test")];
         let rs = getopts(args, opts);
         alt rs {
-          err(f) { check_fail_type(f, option_duplicated_); }
-          _ { fail; }
+          err(f) => check_fail_type(f, option_duplicated_),
+          _ => fail
         }
     }
 
@@ -476,11 +476,11 @@ mod tests {
         let opts = ~[reqopt(~"t")];
         let rs = getopts(args, opts);
         alt rs {
-          ok(m) {
+          ok(m) => {
             assert (opt_present(m, ~"t"));
             assert (opt_str(m, ~"t") == ~"20");
           }
-          _ { fail; }
+          _ => fail
         }
     }
 
@@ -490,8 +490,8 @@ mod tests {
         let opts = ~[reqopt(~"t")];
         let rs = getopts(args, opts);
         alt rs {
-          err(f) { check_fail_type(f, option_missing_); }
-          _ { fail; }
+          err(f) => check_fail_type(f, option_missing_),
+          _ => fail
         }
     }
 
@@ -501,8 +501,8 @@ mod tests {
         let opts = ~[reqopt(~"t")];
         let rs = getopts(args, opts);
         alt rs {
-          err(f) { check_fail_type(f, argument_missing_); }
-          _ { fail; }
+          err(f) => check_fail_type(f, argument_missing_),
+          _ => fail
         }
     }
 
@@ -512,8 +512,8 @@ mod tests {
         let opts = ~[reqopt(~"t")];
         let rs = getopts(args, opts);
         alt rs {
-          err(f) { check_fail_type(f, option_duplicated_); }
-          _ { fail; }
+          err(f) => check_fail_type(f, option_duplicated_),
+          _ => fail
         }
     }
 
@@ -525,11 +525,11 @@ mod tests {
         let opts = ~[optopt(~"test")];
         let rs = getopts(args, opts);
         alt rs {
-          ok(m) {
+          ok(m) => {
             assert (opt_present(m, ~"test"));
             assert (opt_str(m, ~"test") == ~"20");
           }
-          _ { fail; }
+          _ => fail
         }
     }
 
@@ -539,8 +539,8 @@ mod tests {
         let opts = ~[optopt(~"test")];
         let rs = getopts(args, opts);
         alt rs {
-          ok(m) { assert (!opt_present(m, ~"test")); }
-          _ { fail; }
+          ok(m) => assert (!opt_present(m, ~"test")),
+          _ => fail
         }
     }
 
@@ -550,8 +550,8 @@ mod tests {
         let opts = ~[optopt(~"test")];
         let rs = getopts(args, opts);
         alt rs {
-          err(f) { check_fail_type(f, argument_missing_); }
-          _ { fail; }
+          err(f) => check_fail_type(f, argument_missing_),
+          _ => fail
         }
     }
 
@@ -561,8 +561,8 @@ mod tests {
         let opts = ~[optopt(~"test")];
         let rs = getopts(args, opts);
         alt rs {
-          err(f) { check_fail_type(f, option_duplicated_); }
-          _ { fail; }
+          err(f) => check_fail_type(f, option_duplicated_),
+          _ => fail
         }
     }
 
@@ -572,11 +572,11 @@ mod tests {
         let opts = ~[optopt(~"t")];
         let rs = getopts(args, opts);
         alt rs {
-          ok(m) {
+          ok(m) => {
             assert (opt_present(m, ~"t"));
             assert (opt_str(m, ~"t") == ~"20");
           }
-          _ { fail; }
+          _ => fail
         }
     }
 
@@ -586,8 +586,8 @@ mod tests {
         let opts = ~[optopt(~"t")];
         let rs = getopts(args, opts);
         alt rs {
-          ok(m) { assert (!opt_present(m, ~"t")); }
-          _ { fail; }
+          ok(m) => assert (!opt_present(m, ~"t")),
+          _ => fail
         }
     }
 
@@ -597,8 +597,8 @@ mod tests {
         let opts = ~[optopt(~"t")];
         let rs = getopts(args, opts);
         alt rs {
-          err(f) { check_fail_type(f, argument_missing_); }
-          _ { fail; }
+          err(f) => check_fail_type(f, argument_missing_),
+          _ => fail
         }
     }
 
@@ -608,8 +608,8 @@ mod tests {
         let opts = ~[optopt(~"t")];
         let rs = getopts(args, opts);
         alt rs {
-          err(f) { check_fail_type(f, option_duplicated_); }
-          _ { fail; }
+          err(f) => check_fail_type(f, option_duplicated_),
+          _ => fail
         }
     }
 
@@ -621,8 +621,8 @@ mod tests {
         let opts = ~[optflag(~"test")];
         let rs = getopts(args, opts);
         alt rs {
-          ok(m) { assert (opt_present(m, ~"test")); }
-          _ { fail; }
+          ok(m) => assert (opt_present(m, ~"test")),
+          _ => fail
         }
     }
 
@@ -632,8 +632,8 @@ mod tests {
         let opts = ~[optflag(~"test")];
         let rs = getopts(args, opts);
         alt rs {
-          ok(m) { assert (!opt_present(m, ~"test")); }
-          _ { fail; }
+          ok(m) => assert (!opt_present(m, ~"test")),
+          _ => fail
         }
     }
 
@@ -643,11 +643,11 @@ mod tests {
         let opts = ~[optflag(~"test")];
         let rs = getopts(args, opts);
         alt rs {
-          err(f) {
+          err(f) => {
             log(error, fail_str(f));
             check_fail_type(f, unexpected_argument_);
           }
-          _ { fail; }
+          _ => fail
         }
     }
 
@@ -657,8 +657,8 @@ mod tests {
         let opts = ~[optflag(~"test")];
         let rs = getopts(args, opts);
         alt rs {
-          err(f) { check_fail_type(f, option_duplicated_); }
-          _ { fail; }
+          err(f) => check_fail_type(f, option_duplicated_),
+          _ => fail
         }
     }
 
@@ -668,8 +668,8 @@ mod tests {
         let opts = ~[optflag(~"t")];
         let rs = getopts(args, opts);
         alt rs {
-          ok(m) { assert (opt_present(m, ~"t")); }
-          _ { fail; }
+          ok(m) => assert (opt_present(m, ~"t")),
+          _ => fail
         }
     }
 
@@ -679,8 +679,8 @@ mod tests {
         let opts = ~[optflag(~"t")];
         let rs = getopts(args, opts);
         alt rs {
-          ok(m) { assert (!opt_present(m, ~"t")); }
-          _ { fail; }
+          ok(m) => assert (!opt_present(m, ~"t")),
+          _ => fail
         }
     }
 
@@ -690,12 +690,12 @@ mod tests {
         let opts = ~[optflag(~"t")];
         let rs = getopts(args, opts);
         alt rs {
-          ok(m) {
+          ok(m) => {
             // The next variable after the flag is just a free argument
 
             assert (m.free[0] == ~"20");
           }
-          _ { fail; }
+          _ => fail
         }
     }
 
@@ -705,8 +705,8 @@ mod tests {
         let opts = ~[optflag(~"t")];
         let rs = getopts(args, opts);
         alt rs {
-          err(f) { check_fail_type(f, option_duplicated_); }
-          _ { fail; }
+          err(f) => check_fail_type(f, option_duplicated_),
+          _ => fail
         }
     }
 
@@ -718,11 +718,11 @@ mod tests {
         let opts = ~[optmulti(~"test")];
         let rs = getopts(args, opts);
         alt rs {
-          ok(m) {
+          ok(m) => {
             assert (opt_present(m, ~"test"));
             assert (opt_str(m, ~"test") == ~"20");
           }
-          _ { fail; }
+          _ => fail
         }
     }
 
@@ -732,8 +732,8 @@ mod tests {
         let opts = ~[optmulti(~"test")];
         let rs = getopts(args, opts);
         alt rs {
-          ok(m) { assert (!opt_present(m, ~"test")); }
-          _ { fail; }
+          ok(m) => assert (!opt_present(m, ~"test")),
+          _ => fail
         }
     }
 
@@ -743,8 +743,8 @@ mod tests {
         let opts = ~[optmulti(~"test")];
         let rs = getopts(args, opts);
         alt rs {
-          err(f) { check_fail_type(f, argument_missing_); }
-          _ { fail; }
+          err(f) => check_fail_type(f, argument_missing_),
+          _ => fail
         }
     }
 
@@ -754,13 +754,13 @@ mod tests {
         let opts = ~[optmulti(~"test")];
         let rs = getopts(args, opts);
         alt rs {
-          ok(m) {
+          ok(m) => {
             assert (opt_present(m, ~"test"));
             assert (opt_str(m, ~"test") == ~"20");
             assert (opt_strs(m, ~"test")[0] == ~"20");
             assert (opt_strs(m, ~"test")[1] == ~"30");
           }
-          _ { fail; }
+          _ => fail
         }
     }
 
@@ -770,11 +770,11 @@ mod tests {
         let opts = ~[optmulti(~"t")];
         let rs = getopts(args, opts);
         alt rs {
-          ok(m) {
+          ok(m) => {
             assert (opt_present(m, ~"t"));
             assert (opt_str(m, ~"t") == ~"20");
           }
-          _ { fail; }
+          _ => fail
         }
     }
 
@@ -784,8 +784,8 @@ mod tests {
         let opts = ~[optmulti(~"t")];
         let rs = getopts(args, opts);
         alt rs {
-          ok(m) { assert (!opt_present(m, ~"t")); }
-          _ { fail; }
+          ok(m) => assert (!opt_present(m, ~"t")),
+          _ => fail
         }
     }
 
@@ -795,8 +795,8 @@ mod tests {
         let opts = ~[optmulti(~"t")];
         let rs = getopts(args, opts);
         alt rs {
-          err(f) { check_fail_type(f, argument_missing_); }
-          _ { fail; }
+          err(f) => check_fail_type(f, argument_missing_),
+          _ => fail
         }
     }
 
@@ -806,13 +806,13 @@ mod tests {
         let opts = ~[optmulti(~"t")];
         let rs = getopts(args, opts);
         alt rs {
-          ok(m) {
+          ok(m) => {
             assert (opt_present(m, ~"t"));
             assert (opt_str(m, ~"t") == ~"20");
             assert (opt_strs(m, ~"t")[0] == ~"20");
             assert (opt_strs(m, ~"t")[1] == ~"30");
           }
-          _ { fail; }
+          _ => fail
         }
     }
 
@@ -822,8 +822,8 @@ mod tests {
         let opts = ~[optmulti(~"t")];
         let rs = getopts(args, opts);
         alt rs {
-          err(f) { check_fail_type(f, unrecognized_option_); }
-          _ { fail; }
+          err(f) => check_fail_type(f, unrecognized_option_),
+          _ => fail
         }
     }
 
@@ -833,8 +833,8 @@ mod tests {
         let opts = ~[optmulti(~"test")];
         let rs = getopts(args, opts);
         alt rs {
-          err(f) { check_fail_type(f, unrecognized_option_); }
-          _ { fail; }
+          err(f) => check_fail_type(f, unrecognized_option_),
+          _ => fail
         }
     }
 
@@ -850,7 +850,7 @@ mod tests {
              optopt(~"notpresent")];
         let rs = getopts(args, opts);
         alt rs {
-          ok(m) {
+          ok(m) => {
             assert (m.free[0] == ~"prog");
             assert (m.free[1] == ~"free1");
             assert (opt_str(m, ~"s") == ~"20");
@@ -864,7 +864,7 @@ mod tests {
             assert (opt_strs(m, ~"n")[1] == ~"-60 70");
             assert (!opt_present(m, ~"notpresent"));
           }
-          _ { fail; }
+          _ => fail
         }
     }
 
@@ -873,8 +873,8 @@ mod tests {
         let args = ~[~"-e", ~"foo", ~"--encrypt", ~"foo"];
         let opts = ~[optopt(~"e"), optopt(~"encrypt")];
         let matches = alt getopts(args, opts) {
-          result::ok(m) { m }
-          result::err(f) { fail; }
+          result::ok(m) => m,
+          result::err(f) => fail
         };
         assert opts_present(matches, ~[~"e"]);
         assert opts_present(matches, ~[~"encrypt"]);
@@ -894,8 +894,8 @@ mod tests {
         let args = ~[~"-Lfoo"];
         let opts = ~[optmulti(~"L")];
         let matches = alt getopts(args, opts) {
-          result::ok(m) { m }
-          result::err(f) { fail; }
+          result::ok(m) => m,
+          result::err(f) => fail
         };
         assert opts_present(matches, ~[~"L"]);
         assert opts_str(matches, ~[~"L"]) == ~"foo";
diff --git a/src/libstd/json.rs b/src/libstd/json.rs
index 9faea572338..82a0f7d8084 100644
--- a/src/libstd/json.rs
+++ b/src/libstd/json.rs
@@ -46,14 +46,10 @@ type error = {
 /// Serializes a json value into a io::writer
 fn to_writer(wr: io::writer, j: json) {
     alt j {
-      num(n) { wr.write_str(float::to_str(n, 6u)); }
-      string(s) {
-        wr.write_str(escape_str(*s));
-      }
-      boolean(b) {
-        wr.write_str(if b { ~"true" } else { ~"false" });
-      }
-      list(v) {
+      num(n) => wr.write_str(float::to_str(n, 6u)),
+      string(s) => wr.write_str(escape_str(*s)),
+      boolean(b) => wr.write_str(if b { ~"true" } else { ~"false" }),
+      list(v) => {
         wr.write_char('[');
         let mut first = true;
         for (*v).each |item| {
@@ -65,7 +61,7 @@ fn to_writer(wr: io::writer, j: json) {
         };
         wr.write_char(']');
       }
-      dict(d) {
+      dict(d) => {
         if d.size() == 0u {
             wr.write_str(~"{}");
             return;
@@ -84,9 +80,7 @@ fn to_writer(wr: io::writer, j: json) {
         };
         wr.write_str(~" }");
       }
-      null {
-        wr.write_str(~"null");
-      }
+      null => wr.write_str(~"null")
     }
 }
 
@@ -94,14 +88,14 @@ fn escape_str(s: ~str) -> ~str {
     let mut escaped = ~"\"";
     do str::chars_iter(s) |c| {
         alt c {
-          '"' { escaped += ~"\\\""; }
-          '\\' { escaped += ~"\\\\"; }
-          '\x08' { escaped += ~"\\b"; }
-          '\x0c' { escaped += ~"\\f"; }
-          '\n' { escaped += ~"\\n"; }
-          '\r' { escaped += ~"\\r"; }
-          '\t' { escaped += ~"\\t"; }
-          _ { escaped += str::from_char(c); }
+          '"' => escaped += ~"\\\"",
+          '\\' => escaped += ~"\\\\",
+          '\x08' => escaped += ~"\\b",
+          '\x0c' => escaped += ~"\\f",
+          '\n' => escaped += ~"\\n",
+          '\r' => escaped += ~"\\r",
+          '\t' => escaped += ~"\\t",
+          _ => escaped += str::from_char(c)
         }
     };
 
@@ -151,7 +145,7 @@ impl parser for parser {
 
     fn parse() -> result<json, error> {
         alt self.parse_value() {
-          ok(value) {
+          ok(value) => {
             // Skip trailing whitespaces.
             self.parse_whitespace();
             // Make sure there is no trailing characters.
@@ -161,7 +155,7 @@ impl parser for parser {
                 self.error(~"trailing characters")
             }
           }
-          e { e }
+          e => e
         }
     }
 
@@ -171,19 +165,17 @@ impl parser for parser {
         if self.eof() { return self.error(~"EOF while parsing value"); }
 
         alt self.ch {
-          'n' { self.parse_ident(~"ull", null) }
-          't' { self.parse_ident(~"rue", boolean(true)) }
-          'f' { self.parse_ident(~"alse", boolean(false)) }
-          '0' to '9' | '-' { self.parse_number() }
-          '"' {
-              alt self.parse_str() {
-                ok(s) { ok(string(s)) }
-                err(e) { err(e) }
-              }
+          'n' => self.parse_ident(~"ull", null),
+          't' => self.parse_ident(~"rue", boolean(true)),
+          'f' => self.parse_ident(~"alse", boolean(false)),
+          '0' to '9' | '-' => self.parse_number(),
+          '"' => alt self.parse_str() {
+            ok(s) => ok(string(s)),
+            err(e) => err(e)
           }
-          '[' { self.parse_list() }
-          '{' { self.parse_object() }
-          _ { self.error(~"invalid syntax") }
+          '[' => self.parse_list(),
+          '{' => self.parse_object(),
+          _ => self.error(~"invalid syntax")
         }
     }
 
@@ -209,21 +201,21 @@ impl parser for parser {
         }
 
         let mut res = alt self.parse_integer() {
-          ok(res) { res }
-          err(e) { return err(e); }
+          ok(res) => res,
+          err(e) => return err(e)
         };
 
         if self.ch == '.' {
             alt self.parse_decimal(res) {
-              ok(r) { res = r; }
-              err(e) { return err(e); }
+              ok(r) => res = r,
+              err(e) => return err(e)
             }
         }
 
         if self.ch == 'e' || self.ch == 'E' {
             alt self.parse_exponent(res) {
-              ok(r) { res = r; }
-              err(e) { return err(e); }
+              ok(r) => res = r,
+              err(e) => return err(e)
             }
         }
 
@@ -234,29 +226,29 @@ impl parser for parser {
         let mut res = 0f;
 
         alt self.ch {
-          '0' {
+          '0' => {
             self.bump();
 
             // There can be only one leading '0'.
             alt self.ch {
-              '0' to '9' { return self.error(~"invalid number"); }
-              _ {}
+              '0' to '9' => return self.error(~"invalid number"),
+              _ => ()
             }
           }
-          '1' to '9' {
+          '1' to '9' => {
             while !self.eof() {
                 alt self.ch {
-                  '0' to '9' {
+                  '0' to '9' => {
                     res *= 10f;
                     res += ((self.ch as int) - ('0' as int)) as float;
 
                     self.bump();
                   }
-                  _ { break; }
+                  _ => break
                 }
             }
           }
-          _ { return self.error(~"invalid number"); }
+          _ => return self.error(~"invalid number")
         }
 
         ok(res)
@@ -267,21 +259,21 @@ impl parser for parser {
 
         // Make sure a digit follows the decimal place.
         alt self.ch {
-          '0' to '9' {}
-          _ { return self.error(~"invalid number"); }
+          '0' to '9' => (),
+          _ => return self.error(~"invalid number")
         }
 
         let mut res = res;
         let mut dec = 1f;
         while !self.eof() {
             alt self.ch {
-              '0' to '9' {
+              '0' to '9' => {
                 dec /= 10f;
                 res += (((self.ch as int) - ('0' as int)) as float) * dec;
 
                 self.bump();
               }
-              _ { break; }
+              _ => break
             }
         }
 
@@ -296,26 +288,26 @@ impl parser for parser {
         let mut neg_exp = false;
 
         alt self.ch {
-          '+' { self.bump(); }
-          '-' { self.bump(); neg_exp = true; }
-          _ {}
+          '+' => self.bump(),
+          '-' => { self.bump(); neg_exp = true; }
+          _ => ()
         }
 
         // Make sure a digit follows the exponent place.
         alt self.ch {
-          '0' to '9' {}
-          _ { return self.error(~"invalid number"); }
+          '0' to '9' => (),
+          _ => return self.error(~"invalid number")
         }
 
         while !self.eof() {
             alt self.ch {
-              '0' to '9' {
+              '0' to '9' => {
                 exp *= 10u;
                 exp += (self.ch as uint) - ('0' as uint);
 
                 self.bump();
               }
-              _ { break; }
+              _ => break
             }
         }
 
@@ -338,25 +330,25 @@ impl parser for parser {
 
             if (escape) {
                 alt self.ch {
-                  '"' { str::push_char(res, '"'); }
-                  '\\' { str::push_char(res, '\\'); }
-                  '/' { str::push_char(res, '/'); }
-                  'b' { str::push_char(res, '\x08'); }
-                  'f' { str::push_char(res, '\x0c'); }
-                  'n' { str::push_char(res, '\n'); }
-                  'r' { str::push_char(res, '\r'); }
-                  't' { str::push_char(res, '\t'); }
-                  'u' {
+                  '"' => str::push_char(res, '"'),
+                  '\\' => str::push_char(res, '\\'),
+                  '/' => str::push_char(res, '/'),
+                  'b' => str::push_char(res, '\x08'),
+                  'f' => str::push_char(res, '\x0c'),
+                  'n' => str::push_char(res, '\n'),
+                  'r' => str::push_char(res, '\r'),
+                  't' => str::push_char(res, '\t'),
+                  'u' => {
                       // Parse \u1234.
                       let mut i = 0u;
                       let mut n = 0u;
                       while i < 4u {
                           alt self.next_char() {
-                            '0' to '9' {
+                            '0' to '9' => {
                               n = n * 10u +
                                   (self.ch as uint) - ('0' as uint);
                             }
-                            _ { return self.error(~"invalid \\u escape"); }
+                            _ => return self.error(~"invalid \\u escape")
                           }
                           i += 1u;
                       }
@@ -368,7 +360,7 @@ impl parser for parser {
 
                       str::push_char(res, n as char);
                   }
-                  _ { return self.error(~"invalid escape"); }
+                  _ => return self.error(~"invalid escape")
                 }
                 escape = false;
             } else if self.ch == '\\' {
@@ -398,8 +390,8 @@ impl parser for parser {
 
         loop {
             alt self.parse_value() {
-              ok(v) { vec::push(values, v); }
-              e { return e; }
+              ok(v) => vec::push(values, v),
+              e => return e
             }
 
             self.parse_whitespace();
@@ -408,9 +400,9 @@ impl parser for parser {
             }
 
             alt self.ch {
-              ',' { self.bump(); }
-              ']' { self.bump(); return ok(list(@values)); }
-              _ { return self.error(~"expected `,` or `]`"); }
+              ',' => self.bump(),
+              ']' => { self.bump(); return ok(list(@values)); }
+              _ => return self.error(~"expected `,` or `]`")
             }
         };
     }
@@ -434,8 +426,8 @@ impl parser for parser {
             }
 
             let key = alt self.parse_str() {
-              ok(key) { key }
-              err(e) { return err(e); }
+              ok(key) => key,
+              err(e) => return err(e)
             };
 
             self.parse_whitespace();
@@ -447,15 +439,15 @@ impl parser for parser {
             self.bump();
 
             alt self.parse_value() {
-              ok(value) { values.insert(copy *key, value); }
-              e { return e; }
+              ok(value) => { values.insert(copy *key, value); }
+              e => return e
             }
             self.parse_whitespace();
 
             alt self.ch {
-              ',' { self.bump(); }
-              '}' { self.bump(); return ok(dict(values)); }
-              _ {
+              ',' => self.bump(),
+              '}' => { self.bump(); return ok(dict(values)); }
+              _ => {
                   if self.eof() { break; }
                   return self.error(~"expected `,` or `}`");
               }
@@ -486,18 +478,17 @@ fn from_str(s: ~str) -> result<json, error> {
 /// Test if two json values are equal
 fn eq(value0: json, value1: json) -> bool {
     alt (value0, value1) {
-      (num(f0), num(f1)) { f0 == f1 }
-      (string(s0), string(s1)) { s0 == s1 }
-      (boolean(b0), boolean(b1)) { b0 == b1 }
-      (list(l0), list(l1)) { vec::all2(*l0, *l1, eq) }
-      (dict(d0), dict(d1)) {
+      (num(f0), num(f1)) => f0 == f1,
+      (string(s0), string(s1)) => s0 == s1,
+      (boolean(b0), boolean(b1)) => b0 == b1,
+      (list(l0), list(l1)) => vec::all2(*l0, *l1, eq),
+      (dict(d0), dict(d1)) => {
           if d0.size() == d1.size() {
               let mut equal = true;
               for d0.each |k, v0| {
                   alt d1.find(k) {
-                    some(v1) {
-                        if !eq(v0, v1) { equal = false; } }
-                    none { equal = false; }
+                    some(v1) => if !eq(v0, v1) { equal = false },
+                    none => equal = false
                   }
               };
               equal
@@ -505,8 +496,8 @@ fn eq(value0: json, value1: json) -> bool {
               false
           }
       }
-      (null, null) { true }
-      _ { false }
+      (null, null) => true,
+      _ => false
     }
 }
 
@@ -626,8 +617,8 @@ impl <A: to_json copy> of to_json for hashmap<~str, A> {
 impl <A: to_json> of to_json for option<A> {
     fn to_json() -> json {
         alt self {
-          none { null }
-          some(value) { value.to_json() }
+          none => null,
+          some(value) => value.to_json()
         }
     }
 }
diff --git a/src/libstd/list.rs b/src/libstd/list.rs
index 019c9cce632..3538929e728 100644
--- a/src/libstd/list.rs
+++ b/src/libstd/list.rs
@@ -44,11 +44,11 @@ fn find<T: copy>(ls: @list<T>, f: fn(T) -> bool) -> option<T> {
     let mut ls = ls;
     loop {
         ls = alt *ls {
-          cons(hd, tl) {
+          cons(hd, tl) => {
             if f(hd) { return some(hd); }
             tl
           }
-          nil { return none; }
+          nil => return none
         }
     };
 }
@@ -64,8 +64,8 @@ fn has<T: copy>(ls: @list<T>, elt: T) -> bool {
 /// Returns true if the list is empty
 pure fn is_empty<T: copy>(ls: @list<T>) -> bool {
     alt *ls {
-        nil { true }
-        _ { false }
+        nil => true,
+        _ => false
     }
 }
 
@@ -84,21 +84,24 @@ fn len<T>(ls: @list<T>) -> uint {
 /// Returns all but the first element of a list
 pure fn tail<T: copy>(ls: @list<T>) -> @list<T> {
     alt *ls {
-        cons(_, tl) { return tl; }
-        nil { fail ~"list empty" }
+        cons(_, tl) => return tl,
+        nil => fail ~"list empty"
     }
 }
 
 /// Returns the first element of a list
 pure fn head<T: copy>(ls: @list<T>) -> T {
-    alt check *ls { cons(hd, _) { hd } }
+    alt check *ls { cons(hd, _) => hd }
 }
 
 /// Appends one list to another
 pure fn append<T: copy>(l: @list<T>, m: @list<T>) -> @list<T> {
     alt *l {
-      nil { return m; }
-      cons(x, xs) { let rest = append(xs, m); return @cons(x, rest); }
+      nil => return m,
+      cons(x, xs) => {
+        let rest = append(xs, m);
+        return @cons(x, rest);
+      }
     }
 }
 
@@ -112,11 +115,11 @@ fn iter<T>(l: @list<T>, f: fn(T)) {
     let mut cur = l;
     loop {
         cur = alt *cur {
-          cons(hd, tl) {
+          cons(hd, tl) => {
             f(hd);
             tl
           }
-          nil { break; }
+          nil => break
         }
     }
 }
@@ -126,11 +129,11 @@ fn each<T>(l: @list<T>, f: fn(T) -> bool) {
     let mut cur = l;
     loop {
         cur = alt *cur {
-          cons(hd, tl) {
+          cons(hd, tl) => {
             if !f(hd) { return; }
             tl
           }
-          nil { break; }
+          nil => break
         }
     }
 }
diff --git a/src/libstd/map.rs b/src/libstd/map.rs
index e4d1471017f..2b99c4cb8aa 100644
--- a/src/libstd/map.rs
+++ b/src/libstd/map.rs
@@ -134,12 +134,12 @@ mod chained {
             let mut comp = 1u;   // for logging
             loop {
                 alt copy e0.next {
-                  none {
+                  none => {
                     debug!{"search_tbl: absent, comp %u, hash %u, idx %u",
                            comp, h, idx};
                     return not_found;
                   }
-                  some(e1) {
+                  some(e1) => {
                     comp += 1u;
                     if e1.hash == h && self.eqer(&e1.key, k) {
                         debug!{"search_tbl: present, comp %u, \
@@ -157,12 +157,12 @@ mod chained {
         fn search_tbl(k: &K, h: uint) -> search_result<K,V> {
             let idx = h % vec::len(self.chains);
             alt copy self.chains[idx] {
-              none {
+              none => {
                 debug!{"search_tbl: none, comp %u, hash %u, idx %u",
                        0u, h, idx};
                 return not_found;
               }
-              some(e) {
+              some(e) => {
                 if e.hash == h && self.eqer(&e.key, k) {
                     debug!{"search_tbl: present, comp %u, hash %u, idx %u",
                            1u, h, idx};
@@ -194,8 +194,8 @@ mod chained {
                 let mut chain = self.chains[i];
                 loop {
                     chain = alt chain {
-                      none { break; }
-                      some(entry) {
+                      none => break,
+                      some(entry) => {
                         let next = entry.next;
                         if !blk(entry) { return; }
                         next
@@ -217,15 +217,15 @@ mod chained {
         fn contains_key_ref(k: &K) -> bool {
             let hash = self.hasher(k);
             alt self.search_tbl(k, hash) {
-              not_found {false}
-              found_first(*) | found_after(*) {true}
+              not_found => false,
+              found_first(*) | found_after(*) => true
             }
         }
 
         fn insert(+k: K, +v: V) -> bool {
             let hash = self.hasher(&k);
             alt self.search_tbl(&k, hash) {
-              not_found {
+              not_found => {
                 self.count += 1u;
                 let idx = hash % vec::len(self.chains);
                 let old_chain = self.chains[idx];
@@ -245,7 +245,7 @@ mod chained {
 
                 return true;
               }
-              found_first(idx, entry) {
+              found_first(idx, entry) => {
                 self.chains[idx] = some(@entry {
                     hash: hash,
                     key: k,
@@ -253,7 +253,7 @@ mod chained {
                     next: entry.next});
                 return false;
               }
-              found_after(prev, entry) {
+              found_after(prev, entry) => {
                 prev.next = some(@entry {
                     hash: hash,
                     key: k,
@@ -266,9 +266,9 @@ mod chained {
 
         fn find(+k: K) -> option<V> {
             alt self.search_tbl(&k, self.hasher(&k)) {
-              not_found {none}
-              found_first(_, entry) {some(entry.value)}
-              found_after(_, entry) {some(entry.value)}
+              not_found => none,
+              found_first(_, entry) => some(entry.value),
+              found_after(_, entry) => some(entry.value)
             }
         }
 
@@ -282,13 +282,13 @@ mod chained {
 
         fn remove(+k: K) -> option<V> {
             alt self.search_tbl(&k, self.hasher(&k)) {
-              not_found {none}
-              found_first(idx, entry) {
+              not_found => none,
+              found_first(idx, entry) => {
                 self.count -= 1u;
                 self.chains[idx] = entry.next;
                 some(entry.value)
               }
-              found_after(eprev, entry) {
+              found_after(eprev, entry) => {
                 self.count -= 1u;
                 eprev.next = entry.next;
                 some(entry.value)
@@ -639,8 +639,8 @@ mod tests {
         while i < num_to_insert {
             let v = hm.remove(i);
             alt v {
-              option::some(u) { assert (u == i * i); }
-              option::none { fail; }
+              option::some(u) => assert (u == i * i),
+              option::none => fail
             }
             i += 2u;
         }
diff --git a/src/libstd/net_ip.rs b/src/libstd/net_ip.rs
index cb77f72038a..1cc8dd3bed9 100644
--- a/src/libstd/net_ip.rs
+++ b/src/libstd/net_ip.rs
@@ -48,23 +48,19 @@ type parse_addr_err = {
  */
 fn format_addr(ip: ip_addr) -> ~str {
     alt ip {
-      ipv4(addr) {
-        unsafe {
-            let result = uv_ip4_name(&addr);
-            if result == ~"" {
-                fail ~"failed to convert inner sockaddr_in address to str"
-            }
-            result
+      ipv4(addr) =>  unsafe {
+        let result = uv_ip4_name(&addr);
+        if result == ~"" {
+            fail ~"failed to convert inner sockaddr_in address to str"
         }
+        result
       }
-      ipv6(addr) {
-        unsafe {
-            let result = uv_ip6_name(&addr);
-            if result == ~"" {
-                fail ~"failed to convert inner sockaddr_in address to str"
-            }
-            result
+      ipv6(addr) => unsafe {
+        let result = uv_ip6_name(&addr);
+        if result == ~"" {
+            fail ~"failed to convert inner sockaddr_in address to str"
         }
+        result
       }
     }
 }
@@ -108,10 +104,10 @@ fn get_addr(++node: ~str, iotask: iotask)
                     ptr::null(),
                     ptr::null());
                 alt result {
-                  0i32 {
+                  0i32 => {
                     set_data_for_req(handle_ptr, handle_data_ptr);
                   }
-                  _ {
+                  _ => {
                     output_ch.send(result::err(get_addr_unknown_error));
                   }
                 }
@@ -139,10 +135,8 @@ mod v4 {
      */
     fn parse_addr(ip: ~str) -> ip_addr {
         alt try_parse_addr(ip) {
-          result::ok(addr) { copy(addr) }
-          result::err(err_data) {
-            fail err_data.err_msg
-          }
+          result::ok(addr) => copy(addr),
+          result::err(err_data) => fail err_data.err_msg
         }
     }
     // the simple, old style numberic representation of
@@ -162,8 +156,8 @@ mod v4 {
     fn parse_to_ipv4_rep(ip: ~str) -> result::result<ipv4_rep, ~str> {
         let parts = vec::map(str::split_char(ip, '.'), |s| {
             alt uint::from_str(s) {
-              some(n) if n <= 255u { n }
-              _ { 256u }
+              some(n) if n <= 255u => n,
+              _ => 256u
             }
         });
         if vec::len(parts) != 4u {
@@ -227,10 +221,8 @@ mod v6 {
      */
     fn parse_addr(ip: ~str) -> ip_addr {
         alt try_parse_addr(ip) {
-          result::ok(addr) { copy(addr) }
-          result::err(err_data) {
-            fail err_data.err_msg
-          }
+          result::ok(addr) => copy(addr),
+          result::err(err_data) => fail err_data.err_msg
         }
     }
     fn try_parse_addr(ip: ~str) -> result::result<ip_addr,parse_addr_err> {
@@ -335,11 +327,11 @@ mod test {
     #[test]
     fn test_ip_ipv4_bad_parse() {
         alt v4::try_parse_addr(~"b4df00d") {
-          result::err(err_info) {
+          result::err(err_info) => {
             log(debug, fmt!{"got error as expected %?", err_info});
             assert true;
           }
-          result::ok(addr) {
+          result::ok(addr) => {
             fail fmt!{"Expected failure, but got addr %?", addr};
           }
         }
@@ -348,11 +340,11 @@ mod test {
     #[ignore(target_os="win32")]
     fn test_ip_ipv6_bad_parse() {
         alt v6::try_parse_addr(~"::,~2234k;") {
-          result::err(err_info) {
+          result::err(err_info) => {
             log(debug, fmt!{"got error as expected %?", err_info});
             assert true;
           }
-          result::ok(addr) {
+          result::ok(addr) => {
             fail fmt!{"Expected failure, but got addr %?", addr};
           }
         }
@@ -373,12 +365,8 @@ mod test {
                         localhost_name, vec::len(results)});
         for vec::each(results) |r| {
             let ipv_prefix = alt r {
-              ipv4(_) {
-                ~"IPv4"
-              }
-              ipv6(_) {
-                ~"IPv6"
-              }
+              ipv4(_) => ~"IPv4",
+              ipv6(_) => ~"IPv6"
             };
             log(debug, fmt!{"test_get_addr: result %s: '%s'",
                             ipv_prefix, format_addr(r)});
diff --git a/src/libstd/net_tcp.rs b/src/libstd/net_tcp.rs
index 2cacd9de475..2ce47a641c1 100644
--- a/src/libstd/net_tcp.rs
+++ b/src/libstd/net_tcp.rs
@@ -152,16 +152,16 @@ fn connect(-input_ip: ip::ip_addr, port: uint,
         log(debug, fmt!{"stream_handle_ptr in interact %?",
             stream_handle_ptr});
         alt uv::ll::tcp_init( loop_ptr, stream_handle_ptr) {
-          0i32 {
+          0i32 => {
             log(debug, ~"tcp_init successful");
             alt input_ip {
-              ipv4 {
+              ipv4 => {
                 log(debug, ~"dealing w/ ipv4 connection..");
                 let connect_req_ptr =
                     ptr::addr_of((*socket_data_ptr).connect_req);
                 let addr_str = ip::format_addr(input_ip);
                 let connect_result = alt input_ip {
-                  ip::ipv4(addr) {
+                  ip::ipv4(addr) => {
                     // have to "recreate" the sockaddr_in/6
                     // since the ip_addr discards the port
                     // info.. should probably add an additional
@@ -175,7 +175,7 @@ fn connect(-input_ip: ip::ip_addr, port: uint,
                         ptr::addr_of(in_addr),
                         tcp_connect_on_connect_cb)
                   }
-                  ip::ipv6(addr) {
+                  ip::ipv6(addr) => {
                     log(debug, fmt!{"addr: %?", addr});
                     let in_addr = uv::ll::ip6_addr(addr_str, port as int);
                     uv::ll::tcp_connect6(
@@ -186,7 +186,7 @@ fn connect(-input_ip: ip::ip_addr, port: uint,
                   }
                 };
                 alt connect_result {
-                  0i32 {
+                  0i32 => {
                     log(debug, ~"tcp_connect successful");
                     // reusable data that we'll have for the
                     // duration..
@@ -201,7 +201,7 @@ fn connect(-input_ip: ip::ip_addr, port: uint,
                     // let tcp_connect_on_connect_cb send on
                     // the result_ch, now..
                   }
-                  _ {
+                  _ => {
                     // immediate connect failure.. probably a garbage
                     // ip or somesuch
                     let err_data = uv::ll::get_last_err_data(loop_ptr);
@@ -215,7 +215,7 @@ fn connect(-input_ip: ip::ip_addr, port: uint,
               }
             }
         }
-          _ {
+          _ => {
             // failure to create a tcp handle
             let err_data = uv::ll::get_last_err_data(loop_ptr);
             comm::send((*conn_data_ptr).result_ch,
@@ -224,19 +224,19 @@ fn connect(-input_ip: ip::ip_addr, port: uint,
         }
     };
     alt comm::recv(result_po) {
-      conn_success {
+      conn_success => {
         log(debug, ~"tcp::connect - received success on result_po");
         result::ok(tcp_socket(socket_data))
       }
-      conn_failure(err_data) {
+      conn_failure(err_data) => {
         comm::recv(closed_signal_po);
         log(debug, ~"tcp::connect - received failure on result_po");
         // still have to free the malloc'd stream handle..
         rustrt::rust_uv_current_kernel_free(stream_handle_ptr
                                            as *libc::c_void);
         let tcp_conn_err = alt err_data.err_name {
-          ~"ECONNREFUSED" { connection_refused }
-          _ { generic_connect_err(err_data.err_name, err_data.err_msg) }
+          ~"ECONNREFUSED" => connection_refused,
+          _ => generic_connect_err(err_data.err_name, err_data.err_msg)
         };
         result::err(tcp_conn_err)
       }
@@ -470,7 +470,7 @@ fn accept(new_conn: tcp_new_connection)
     -> result::result<tcp_socket, tcp_err_data> unsafe {
 
     alt new_conn{
-      new_tcp_conn(server_handle_ptr) {
+      new_tcp_conn(server_handle_ptr) => {
         let server_data_ptr = uv::ll::get_data_for_uv_handle(
             server_handle_ptr) as *tcp_listen_fc_data;
         let reader_po = comm::port::<result::result<~[u8], tcp_err_data>>();
@@ -502,26 +502,26 @@ fn accept(new_conn: tcp_new_connection)
         let loop_ptr = uv::ll::get_loop_for_uv_handle(
             server_handle_ptr);
         alt uv::ll::tcp_init(loop_ptr, client_stream_handle_ptr) {
-          0i32 {
+          0i32 => {
             log(debug, ~"uv_tcp_init successful for client stream");
             alt uv::ll::accept(
                 server_handle_ptr as *libc::c_void,
                 client_stream_handle_ptr as *libc::c_void) {
-              0i32 {
+              0i32 => {
                 log(debug, ~"successfully accepted client connection");
                 uv::ll::set_data_for_uv_handle(client_stream_handle_ptr,
                                                client_socket_data_ptr
                                                    as *libc::c_void);
                 comm::send(result_ch, none);
               }
-              _ {
+              _ => {
                 log(debug, ~"failed to accept client conn");
                 comm::send(result_ch, some(
                     uv::ll::get_last_err_data(loop_ptr).to_tcp_err()));
               }
             }
           }
-          _ {
+          _ => {
             log(debug, ~"failed to init client stream");
             comm::send(result_ch, some(
                 uv::ll::get_last_err_data(loop_ptr).to_tcp_err()));
@@ -529,12 +529,8 @@ fn accept(new_conn: tcp_new_connection)
         }
         // UNSAFE LIBUV INTERACTION END
         alt comm::recv(result_po) {
-          some(err_data) {
-            result::err(err_data)
-          }
-          none {
-            result::ok(tcp_socket(client_socket_data))
-          }
+          some(err_data) => result::err(err_data),
+          none => result::ok(tcp_socket(client_socket_data))
         }
       }
     }
@@ -615,19 +611,19 @@ fn listen_common(-host_ip: ip::ip_addr, port: uint, backlog: uint,
         let loc_ip = copy(host_ip);
         do iotask::interact(iotask) |loop_ptr| {
             alt uv::ll::tcp_init(loop_ptr, server_stream_ptr) {
-              0i32 {
+              0i32 => {
                 uv::ll::set_data_for_uv_handle(
                     server_stream_ptr,
                     server_data_ptr);
                 let addr_str = ip::format_addr(loc_ip);
                 let bind_result = alt loc_ip {
-                  ip::ipv4(addr) {
+                  ip::ipv4(addr) => {
                     log(debug, fmt!{"addr: %?", addr});
                     let in_addr = uv::ll::ip4_addr(addr_str, port as int);
                     uv::ll::tcp_bind(server_stream_ptr,
                                      ptr::addr_of(in_addr))
                   }
-                  ip::ipv6(addr) {
+                  ip::ipv6(addr) => {
                     log(debug, fmt!{"addr: %?", addr});
                     let in_addr = uv::ll::ip6_addr(addr_str, port as int);
                     uv::ll::tcp_bind6(server_stream_ptr,
@@ -635,28 +631,26 @@ fn listen_common(-host_ip: ip::ip_addr, port: uint, backlog: uint,
                   }
                 };
                 alt bind_result {
-                  0i32 {
+                  0i32 => {
                     alt uv::ll::listen(server_stream_ptr,
                                        backlog as libc::c_int,
                                        tcp_lfc_on_connection_cb) {
-                      0i32 {
-                        comm::send(setup_ch, none);
-                      }
-                      _ {
+                      0i32 => comm::send(setup_ch, none),
+                      _ => {
                         log(debug, ~"failure to uv_listen()");
                         let err_data = uv::ll::get_last_err_data(loop_ptr);
                         comm::send(setup_ch, some(err_data));
                       }
                     }
                   }
-                  _ {
+                  _ => {
                     log(debug, ~"failure to uv_tcp_bind");
                     let err_data = uv::ll::get_last_err_data(loop_ptr);
                     comm::send(setup_ch, some(err_data));
                   }
                 }
               }
-              _ {
+              _ => {
                 log(debug, ~"failure to uv_tcp_init");
                 let err_data = uv::ll::get_last_err_data(loop_ptr);
                 comm::send(setup_ch, some(err_data));
@@ -666,7 +660,7 @@ fn listen_common(-host_ip: ip::ip_addr, port: uint, backlog: uint,
         setup_ch.recv()
     };
     alt setup_result {
-      some(err_data) {
+      some(err_data) => {
         do iotask::interact(iotask) |loop_ptr| {
             log(debug, fmt!{"tcp::listen post-kill recv hl interact %?",
                             loop_ptr});
@@ -675,15 +669,15 @@ fn listen_common(-host_ip: ip::ip_addr, port: uint, backlog: uint,
         };
         stream_closed_po.recv();
         alt err_data.err_name {
-          ~"EACCES" {
+          ~"EACCES" => {
             log(debug, ~"Got EACCES error");
             result::err(access_denied)
           }
-          ~"EADDRINUSE" {
+          ~"EADDRINUSE" => {
             log(debug, ~"Got EADDRINUSE error");
             result::err(address_in_use)
           }
-          _ {
+          _ => {
             log(debug, fmt!{"Got '%s' '%s' libuv error",
                             err_data.err_name, err_data.err_msg});
             result::err(
@@ -691,7 +685,7 @@ fn listen_common(-host_ip: ip::ip_addr, port: uint, backlog: uint,
           }
         }
       }
-      none {
+      none => {
         on_establish_cb(kill_ch);
         let kill_result = comm::recv(kill_po);
         do iotask::interact(iotask) |loop_ptr| {
@@ -703,14 +697,10 @@ fn listen_common(-host_ip: ip::ip_addr, port: uint, backlog: uint,
         stream_closed_po.recv();
         alt kill_result {
           // some failure post bind/listen
-          some(err_data) {
-            result::err(generic_listen_err(err_data.err_name,
-                                            err_data.err_msg))
-          }
+          some(err_data) => result::err(generic_listen_err(err_data.err_name,
+                                                           err_data.err_msg)),
           // clean exit
-          none {
-            result::ok(())
-          }
+          none => result::ok(())
         }
       }
     }
@@ -889,7 +879,7 @@ fn read_common_impl(socket_data: *tcp_socket_data, timeout_msecs: uint)
         };
         log(debug, ~"tcp::read after recv_timeout");
         alt read_result {
-          none {
+          none => {
             log(debug, ~"tcp::read: timed out..");
             let err_data = {
                 err_name: ~"TIMEOUT",
@@ -898,7 +888,7 @@ fn read_common_impl(socket_data: *tcp_socket_data, timeout_msecs: uint)
             read_stop_common_impl(socket_data);
             result::err(err_data)
           }
-          some(data_result) {
+          some(data_result) => {
             log(debug, ~"tcp::read got data");
             read_stop_common_impl(socket_data);
             data_result
@@ -916,11 +906,11 @@ fn read_stop_common_impl(socket_data: *tcp_socket_data) ->
     do iotask::interact((*socket_data).iotask) |loop_ptr| {
         log(debug, ~"in interact cb for tcp::read_stop");
         alt uv::ll::read_stop(stream_handle_ptr as *uv::ll::uv_stream_t) {
-          0i32 {
+          0i32 => {
             log(debug, ~"successfully called uv_read_stop");
             comm::send(stop_ch, none);
           }
-          _ {
+          _ => {
             log(debug, ~"failure in calling uv_read_stop");
             let err_data = uv::ll::get_last_err_data(loop_ptr);
             comm::send(stop_ch, some(err_data.to_tcp_err()));
@@ -928,12 +918,8 @@ fn read_stop_common_impl(socket_data: *tcp_socket_data) ->
         }
     };
     alt comm::recv(stop_po) {
-      some(err_data) {
-        result::err(err_data.to_tcp_err())
-      }
-      none {
-        result::ok(())
-      }
+      some(err_data) => result::err(err_data.to_tcp_err()),
+      none => result::ok(())
     }
 }
 
@@ -950,11 +936,11 @@ fn read_start_common_impl(socket_data: *tcp_socket_data)
         alt uv::ll::read_start(stream_handle_ptr as *uv::ll::uv_stream_t,
                                on_alloc_cb,
                                on_tcp_read_cb) {
-          0i32 {
+          0i32 => {
             log(debug, ~"success doing uv_read_start");
             comm::send(start_ch, none);
           }
-          _ {
+          _ => {
             log(debug, ~"error attempting uv_read_start");
             let err_data = uv::ll::get_last_err_data(loop_ptr);
             comm::send(start_ch, some(err_data));
@@ -962,12 +948,8 @@ fn read_start_common_impl(socket_data: *tcp_socket_data)
         }
     };
     alt comm::recv(start_po) {
-      some(err_data) {
-        result::err(err_data.to_tcp_err())
-      }
-      none {
-        result::ok((*socket_data).reader_po)
-      }
+      some(err_data) => result::err(err_data.to_tcp_err()),
+      none => result::ok((*socket_data).reader_po)
     }
 }
 
@@ -995,11 +977,11 @@ fn write_common_impl(socket_data_ptr: *tcp_socket_data,
                           stream_handle_ptr,
                           write_buf_vec_ptr,
                           tcp_write_complete_cb) {
-          0i32 {
+          0i32 => {
             log(debug, ~"uv_write() invoked successfully");
             uv::ll::set_data_for_req(write_req_ptr, write_data_ptr);
           }
-          _ {
+          _ => {
             log(debug, ~"error invoking uv_write()");
             let err_data = uv::ll::get_last_err_data(loop_ptr);
             comm::send((*write_data_ptr).result_ch,
@@ -1012,8 +994,8 @@ fn write_common_impl(socket_data_ptr: *tcp_socket_data,
     // ownership of everything to the I/O task and let it deal with the
     // aftermath, so we don't have to sit here blocking.
     alt comm::recv(result_po) {
-      tcp_write_success { result::ok(()) }
-      tcp_write_error(err_data) { result::err(err_data.to_tcp_err()) }
+      tcp_write_success => result::ok(()),
+      tcp_write_error(err_data) => result::err(err_data.to_tcp_err())
     }
 }
 
@@ -1043,10 +1025,8 @@ extern fn tcp_lfc_on_connection_cb(handle: *uv::ll::uv_tcp_t,
     let kill_ch = (*server_data_ptr).kill_ch;
     if (*server_data_ptr).active {
         alt status {
-          0i32 {
-            (*server_data_ptr).on_connect_cb(handle);
-          }
-          _ {
+          0i32 => (*server_data_ptr).on_connect_cb(handle),
+          _ => {
             let loop_ptr = uv::ll::get_loop_for_uv_handle(handle);
             comm::send(kill_ch,
                        some(uv::ll::get_last_err_data(loop_ptr)
@@ -1103,7 +1083,7 @@ extern fn on_tcp_read_cb(stream: *uv::ll::uv_stream_t,
         as *tcp_socket_data;
     alt nread as int {
       // incoming err.. probably eof
-      -1 {
+      -1 => {
         let err_data = uv::ll::get_last_err_data(loop_ptr).to_tcp_err();
         log(debug, fmt!{"on_tcp_read_cb: incoming err.. name %? msg %?",
                         err_data.err_name, err_data.err_msg});
@@ -1111,9 +1091,9 @@ extern fn on_tcp_read_cb(stream: *uv::ll::uv_stream_t,
         comm::send(reader_ch, result::err(err_data));
       }
       // do nothing .. unneeded buf
-      0 {}
+      0 => (),
       // have data
-      _ {
+      _ => {
         // we have data
         log(debug, fmt!{"tcp on_read_cb nread: %d", nread as int});
         let reader_ch = (*socket_data_ptr).reader_ch;
@@ -1196,11 +1176,11 @@ extern fn tcp_connect_on_connect_cb(connect_req_ptr: *uv::ll::uv_connect_t,
     let tcp_stream_ptr =
         uv::ll::get_stream_handle_from_connect_req(connect_req_ptr);
     alt status {
-      0i32 {
+      0i32 => {
         log(debug, ~"successful tcp connection!");
         comm::send(result_ch, conn_success);
       }
-      _ {
+      _ => {
         log(debug, ~"error in tcp_connect_on_connect_cb");
         let loop_ptr = uv::ll::get_loop_for_uv_handle(tcp_stream_ptr);
         let err_data = uv::ll::get_last_err_data(loop_ptr);
@@ -1357,11 +1337,8 @@ mod test {
                 hl_loop)
         };
         alt actual_resp_result.get_err() {
-          connection_refused {
-          }
-          _ {
-            fail ~"unknown error.. expected connection_refused"
-          }
+          connection_refused => (),
+          _ => fail ~"unknown error.. expected connection_refused"
         }
     }
     fn impl_gl_tcp_ipv4_server_address_in_use() {
@@ -1406,12 +1383,12 @@ mod test {
                 hl_loop)
         };
         alt listen_err {
-          address_in_use {
+          address_in_use => {
             assert true;
           }
-          _ {
+          _ => {
             fail ~"expected address_in_use listen error,"+
-                      ~"but got a different error varient. check logs.";
+                ~"but got a different error varient. check logs.";
           }
         }
     }
@@ -1425,10 +1402,10 @@ mod test {
                             server_port,
                             hl_loop);
         alt listen_err {
-          access_denied {
+          access_denied => {
             assert true;
           }
-          _ {
+          _ => {
             fail ~"expected address_in_use listen error,"+
                       ~"but got a different error varient. check logs.";
           }
@@ -1539,7 +1516,7 @@ mod test {
                             ~"connection!");
                         let received_req_bytes = read(sock, 0u);
                         alt received_req_bytes {
-                          result::ok(data) {
+                          result::ok(data) => {
                             log(debug, ~"SERVER: got REQ str::from_bytes..");
                             log(debug, fmt!{"SERVER: REQ data len: %?",
                                             vec::len(data)});
@@ -1550,7 +1527,7 @@ mod test {
                             log(debug, ~"SERVER: after write.. die");
                             comm::send(kill_ch, none);
                           }
-                          result::err(err_data) {
+                          result::err(err_data) => {
                             log(debug, fmt!{"SERVER: error recvd: %s %s",
                                 err_data.err_name, err_data.err_msg});
                             comm::send(kill_ch, some(err_data));
@@ -1568,14 +1545,14 @@ mod test {
         // err check on listen_result
         if result::is_err(listen_result) {
             alt result::get_err(listen_result) {
-              generic_listen_err(name, msg) {
+              generic_listen_err(name, msg) => {
                 fail fmt!{"SERVER: exited abnormally name %s msg %s",
                                 name, msg};
               }
-              access_denied {
+              access_denied => {
                 fail ~"SERVER: exited abnormally, got access denied..";
               }
-              address_in_use {
+              address_in_use => {
                 fail ~"SERVER: exited abnormally, got address in use...";
               }
             }
diff --git a/src/libstd/net_url.rs b/src/libstd/net_url.rs
index dd97c1fdeb2..d43a8add1cc 100644
--- a/src/libstd/net_url.rs
+++ b/src/libstd/net_url.rs
@@ -52,22 +52,22 @@ fn encode_inner(s: ~str, full_url: bool) -> ~str {
               'A' to 'Z' |
               'a' to 'z' |
               '0' to '9' |
-              '-' | '.' | '_' | '~' {
+              '-' | '.' | '_' | '~' => {
                 str::push_char(out, ch);
               }
-              _ {
-                if full_url {
+              _ => {
+                  if full_url {
                     match ch {
                       // gen-delims:
                       ':' | '/' | '?' | '#' | '[' | ']' | '@' |
 
                       // sub-delims:
                       '!' | '$' | '&' | '"' | '(' | ')' | '*' |
-                      '+' | ',' | ';' | '=' {
+                      '+' | ',' | ';' | '=' => {
                         str::push_char(out, ch);
                       }
 
-                      _ { out += #fmt("%%%X", ch as uint); }
+                      _ => out += #fmt("%%%X", ch as uint)
                     }
                 } else {
                     out += #fmt("%%%X", ch as uint);
@@ -106,7 +106,7 @@ fn decode_inner(s: ~str, full_url: bool) -> ~str {
 
         while !rdr.eof() {
             match rdr.read_char() {
-              '%' {
+              '%' => {
                 let bytes = rdr.read_bytes(2u);
                 let ch = uint::parse_buf(bytes, 16u).get() as char;
 
@@ -118,19 +118,19 @@ fn decode_inner(s: ~str, full_url: bool) -> ~str {
 
                       // sub-delims:
                       '!' | '$' | '&' | '"' | '(' | ')' | '*' |
-                      '+' | ',' | ';' | '=' {
+                      '+' | ',' | ';' | '=' => {
                         str::push_char(out, '%');
                         str::push_char(out, bytes[0u] as char);
                         str::push_char(out, bytes[1u] as char);
                       }
 
-                      ch { str::push_char(out, ch); }
+                      ch => str::push_char(out, ch)
                     }
                 } else {
                       str::push_char(out, ch);
                 }
               }
-              ch { str::push_char(out, ch); }
+              ch => str::push_char(out, ch)
             }
         }
 
@@ -161,11 +161,11 @@ fn encode_plus(s: ~str) -> ~str {
         while !rdr.eof() {
             let ch = rdr.read_byte() as char;
             match ch {
-              'A' to 'Z' | 'a' to 'z' | '0' to '9' | '_' | '.' | '-' {
+              'A' to 'Z' | 'a' to 'z' | '0' to '9' | '_' | '.' | '-' => {
                 str::push_char(out, ch);
               }
-              ' ' { str::push_char(out, '+'); }
-              _ { out += #fmt("%%%X", ch as uint); }
+              ' ' => str::push_char(out, '+'),
+              _ => out += #fmt("%%%X", ch as uint)
             }
         }
 
@@ -212,11 +212,11 @@ fn decode_form_urlencoded(s: ~[u8]) ->
 
         while !rdr.eof() {
             match rdr.read_char() {
-              '&' | ';' {
+              '&' | ';' => {
                 if key != ~"" && value != ~"" {
                     let values = match m.find(key) {
-                      some(values) { values }
-                      none {
+                      some(values) => values,
+                      none => {
                         let values = @dvec();
                         m.insert(key, values);
                         values
@@ -229,14 +229,14 @@ fn decode_form_urlencoded(s: ~[u8]) ->
                 key = ~"";
                 value = ~"";
               }
-              '=' { parsing_key = false; }
-              ch {
+              '=' => parsing_key = false,
+              ch => {
                 let ch = match ch {
-                  '%' {
+                  '%' => {
                     uint::parse_buf(rdr.read_bytes(2u), 16u).get() as char
                   }
-                  '+' { ' ' }
-                  ch { ch }
+                  '+' => ' ',
+                  ch => ch
                 };
 
                 if parsing_key {
@@ -250,8 +250,8 @@ fn decode_form_urlencoded(s: ~[u8]) ->
 
         if key != ~"" && value != ~"" {
             let values = match m.find(key) {
-              some(values) { values }
-              none {
+              some(values) => values,
+              none => {
                 let values = @dvec();
                 m.insert(key, values);
                 values
@@ -333,14 +333,14 @@ fn query_to_str(query: query) -> ~str {
 fn get_scheme(rawurl: ~str) -> result::result<(~str, ~str), @~str> {
     for str::each_chari(rawurl) |i,c| {
         match c {
-          'A' to 'Z' | 'a' to 'z' { again; }
-          '0' to '9' | '+' | '-' | '.' {
+          'A' to 'Z' | 'a' to 'z' => again,
+          '0' to '9' | '+' | '-' | '.' => {
             if i == 0 {
                 return result::err(@~"url: Scheme must begin with a letter.");
             }
             again;
           }
-          ':' {
+          ':' => {
             if i == 0 {
                 return result::err(@~"url: Scheme cannot be empty.");
             } else {
@@ -348,7 +348,7 @@ fn get_scheme(rawurl: ~str) -> result::result<(~str, ~str), @~str> {
                                 rawurl.slice(i+1,str::len(rawurl))));
             }
           }
-          _  {
+          _ => {
             return result::err(@~"url: Invalid character in scheme.");
           }
         }
@@ -393,34 +393,34 @@ fn get_authority(rawurl: ~str) ->
 
         // deal with input class first
         match c {
-          '0' to '9' { }
-          'A' to 'F' | 'a' to 'f' {
+          '0' to '9' => (),
+          'A' to 'F' | 'a' to 'f' => {
             if in == digit {
                 in = hex;
             }
           }
           'G' to 'Z' | 'g' to 'z' | '-' | '.' | '_' | '~' | '%' |
-          '&' |'\'' | '(' | ')' | '+' | '!' | '*' | ',' | ';' | '=' {
+          '&' |'\'' | '(' | ')' | '+' | '!' | '*' | ',' | ';' | '=' => {
             in = unreserved;
           }
-          ':' | '@' | '?' | '#' | '/' {
+          ':' | '@' | '?' | '#' | '/' => {
             // separators, don't change anything
           }
-          _ {
+          _ => {
             return result::err(@~"Illegal character in authority");
           }
         }
 
         // now process states
         match c {
-          ':' {
+          ':' => {
             colon_count += 1;
             match st {
-              start {
+              start => {
                 pos = i;
                 st = pass_host_port;
               }
-              pass_host_port {
+              pass_host_port => {
                 // multiple colons means ipv6 address.
                 if in == unreserved {
                     return result::err(
@@ -428,7 +428,7 @@ fn get_authority(rawurl: ~str) ->
                 }
                 st = ip6_host;
               }
-              in_host {
+              in_host => {
                 pos = i;
                 // can't be sure whether this is an ipv6 address or a port
                 if in == unreserved {
@@ -436,55 +436,55 @@ fn get_authority(rawurl: ~str) ->
                 }
                 st = ip6_port;
               }
-              ip6_port {
+              ip6_port => {
                 if in == unreserved {
                     return result::err(@~"Illegal characters in authority.");
                 }
                 st = ip6_host;
               }
-              ip6_host {
+              ip6_host => {
                 if colon_count > 7 {
                     host = str::slice(rawurl, begin, i);
                     pos = i;
                     st = in_port;
                 }
               }
-              _ {
+              _ => {
                 return result::err(@~"Invalid ':' in authority.");
               }
             }
             in = digit; // reset input class
           }
 
-          '@' {
+          '@' => {
             in = digit; // reset input class
             colon_count = 0; // reset count
             match st {
-              start {
+              start => {
                 let user = str::slice(rawurl, begin, i);
                 userinfo = option::some({user : user,
                                          pass: option::none});
                 st = in_host;
               }
-              pass_host_port {
+              pass_host_port => {
                 let user = str::slice(rawurl, begin, pos);
                 let pass = str::slice(rawurl, pos+1, i);
                 userinfo = option::some({user: user,
                                          pass: option::some(pass)});
                 st = in_host;
               }
-              _ {
+              _ => {
                 return result::err(@~"Invalid '@' in authority.");
               }
             }
             begin = i+1;
           }
 
-          '?' | '#' | '/' {
+          '?' | '#' | '/' => {
             end = i;
             break;
           }
-          _ { }
+          _ => ()
         }
         end = i;
     }
@@ -498,24 +498,24 @@ fn get_authority(rawurl: ~str) ->
 
     // finish up
     match st {
-      start {
+      start => {
         if host_is_end_plus_one() {
             host = str::slice(rawurl, begin, end+1);
         } else {
             host = str::slice(rawurl, begin, end);
         }
       }
-      pass_host_port | ip6_port {
+      pass_host_port | ip6_port => {
         if in != digit {
             return result::err(@~"Non-digit characters in port.");
         }
         host = str::slice(rawurl, begin, pos);
         port = option::some(str::slice(rawurl, pos+1, end));
       }
-      ip6_host | in_host {
+      ip6_host | in_host => {
         host = str::slice(rawurl, begin, end);
       }
-      in_port {
+      in_port => {
         if in != digit {
             return result::err(@~"Non-digit characters in port.");
         }
@@ -537,14 +537,14 @@ fn get_path(rawurl: ~str, authority : bool) ->
     for str::each_chari(rawurl) |i,c| {
         match c {
           'A' to 'Z' | 'a' to 'z' | '0' to '9' | '&' |'\'' | '(' | ')' | '.'
-          | '@' | ':' | '%' | '/' | '+' | '!' | '*' | ',' | ';' | '=' {
+          | '@' | ':' | '%' | '/' | '+' | '!' | '*' | ',' | ';' | '=' => {
             again;
           }
-          '?' | '#' {
+          '?' | '#' => {
             end = i;
             break;
           }
-          _ { return result::err(@~"Invalid character in path.") }
+          _ => return result::err(@~"Invalid character in path.")
         }
     }
 
diff --git a/src/libstd/rope.rs b/src/libstd/rope.rs
index 8debc45a0e9..5c779e37507 100644
--- a/src/libstd/rope.rs
+++ b/src/libstd/rope.rs
@@ -134,13 +134,13 @@ fn prepend_str(rope: rope, str: @~str) -> rope {
 /// Concatenate two ropes
 fn append_rope(left: rope, right: rope) -> rope {
    alt(left) {
-     node::empty { return right; }
-     node::content(left_content) {
+     node::empty => return right,
+     node::content(left_content) => {
        alt(right) {
-         node::empty { return left; }
-     node::content(right_content) {
+         node::empty => return left,
+         node::content(right_content) => {
            return node::content(node::concat2(left_content, right_content));
-     }
+         }
        }
      }
    }
@@ -198,12 +198,10 @@ Section: Keeping ropes healthy
  */
 fn bal(rope:rope) -> rope {
     alt(rope) {
-      node::empty { return rope }
-      node::content(x) {
-        alt(node::bal(x)) {
-          option::none   { rope }
-          option::some(y) { node::content(y) }
-        }
+      node::empty => return rope,
+      node::content(x) => alt(node::bal(x)) {
+        option::none    => rope,
+        option::some(y) => node::content(y)
       }
     }
 }
@@ -229,12 +227,11 @@ Section: Transforming ropes
 fn sub_chars(rope: rope, char_offset: uint, char_len: uint) -> rope {
     if char_len == 0u { return node::empty; }
     alt(rope) {
-      node::empty { fail }
-      node::content(node) {
-        if char_len > node::char_len(node) { fail }
-        else {
-            return node::content(node::sub_chars(node, char_offset, char_len))
-        }
+      node::empty => fail,
+      node::content(node) => if char_len > node::char_len(node) {
+        fail
+      } else {
+        return node::content(node::sub_chars(node, char_offset, char_len))
       }
     }
 }
@@ -255,12 +252,11 @@ fn sub_chars(rope: rope, char_offset: uint, char_len: uint) -> rope {
 fn sub_bytes(rope: rope, byte_offset: uint, byte_len: uint) -> rope {
     if byte_len == 0u { return node::empty; }
     alt(rope) {
-      node::empty { fail }
-      node::content(node) {
-        if byte_len > node::byte_len(node) { fail }
-        else {
-            return node::content(node::sub_bytes(node, byte_offset, byte_len))
-        }
+      node::empty => fail,
+      node::content(node) =>if byte_len > node::byte_len(node) {
+        fail
+      } else {
+        return node::content(node::sub_bytes(node, byte_offset, byte_len))
       }
     }
 }
@@ -281,10 +277,10 @@ Section: Comparing ropes
  */
 fn cmp(left: rope, right: rope) -> int {
     alt((left, right)) {
-      (node::empty, node::empty) { return 0; }
-      (node::empty, _)     { return -1;}
-      (_, node::empty)     { return  1;}
-      (node::content(a), node::content(b)) {
+      (node::empty, node::empty) => return 0,
+      (node::empty, _)     => return -1,
+      (_, node::empty)     => return  1,
+      (node::content(a), node::content(b)) => {
         return node::cmp(a, b);
       }
     }
@@ -384,8 +380,8 @@ Section: Iterating
  */
 fn loop_chars(rope: rope, it: fn(char) -> bool) -> bool {
    alt(rope) {
-      node::empty { return true }
-      node::content(x) { return node::loop_chars(x, it) }
+      node::empty => return true,
+      node::content(x) => return node::loop_chars(x, it)
    }
 }
 
@@ -427,8 +423,8 @@ fn iter_chars(rope: rope, it: fn(char)) {
  */
 fn loop_leaves(rope: rope, it: fn(node::leaf) -> bool) -> bool{
    alt(rope) {
-      node::empty { return true }
-      node::content(x) {return node::loop_leaves(x, it)}
+      node::empty => return true,
+      node::content(x) => return node::loop_leaves(x, it)
    }
 }
 
@@ -436,8 +432,8 @@ mod iterator {
     mod leaf {
         fn start(rope: rope) -> node::leaf_iterator::t {
             alt(rope) {
-              node::empty     { return node::leaf_iterator::empty() }
-              node::content(x) { return node::leaf_iterator::start(x) }
+              node::empty      => return node::leaf_iterator::empty(),
+              node::content(x) => return node::leaf_iterator::start(x)
             }
         }
         fn next(it: node::leaf_iterator::t) -> option<node::leaf> {
@@ -447,8 +443,8 @@ mod iterator {
     mod char {
         fn start(rope: rope) -> node::char_iterator::t {
             alt(rope) {
-              node::empty   { return node::char_iterator::empty() }
-              node::content(x) { return node::char_iterator::start(x) }
+              node::empty      => return node::char_iterator::empty(),
+              node::content(x) => return node::char_iterator::start(x)
             }
         }
         fn next(it: node::char_iterator::t) -> option<char> {
@@ -474,8 +470,8 @@ mod iterator {
  */
 fn height(rope: rope) -> uint {
    alt(rope) {
-      node::empty    { return 0u; }
-      node::content(x) { return node::height(x); }
+      node::empty      => return 0u,
+      node::content(x) => return node::height(x)
    }
 }
 
@@ -490,8 +486,8 @@ fn height(rope: rope) -> uint {
  */
 pure fn char_len(rope: rope) -> uint {
    alt(rope) {
-     node::empty           { return 0u; }
-     node::content(x)       { return node::char_len(x) }
+     node::empty            => return 0u,
+     node::content(x)       => return node::char_len(x)
    }
 }
 
@@ -504,8 +500,8 @@ pure fn char_len(rope: rope) -> uint {
  */
 pure fn byte_len(rope: rope) -> uint {
    alt(rope) {
-     node::empty           { return 0u; }
-     node::content(x)       { return node::byte_len(x) }
+     node::empty            => return 0u,
+     node::content(x)       => return node::byte_len(x)
    }
 }
 
@@ -527,8 +523,8 @@ pure fn byte_len(rope: rope) -> uint {
  */
 fn char_at(rope: rope, pos: uint) -> char {
    alt(rope) {
-      node::empty { fail }
-      node::content(x) { return node::char_at(x, pos) }
+      node::empty => fail,
+      node::content(x) => return node::char_at(x, pos)
    }
 }
 
@@ -735,15 +731,15 @@ mod node {
     pure fn byte_len(node: @node) -> uint {
         //FIXME (#2744): Could we do this without the pattern-matching?
         alt(*node) {
-          leaf(y)  { return y.byte_len; }
-          concat(y){ return y.byte_len; }
+          leaf(y)   => return y.byte_len,
+          concat(y) => return y.byte_len
         }
     }
 
     pure fn char_len(node: @node) -> uint {
         alt(*node) {
-          leaf(y)   { return y.char_len; }
-          concat(y) { return y.char_len; }
+          leaf(y)   => return y.char_len,
+          concat(y) => return y.char_len
         }
     }
 
@@ -805,8 +801,8 @@ mod node {
         let it = leaf_iterator::start(node);
         loop {
             alt(leaf_iterator::next(it)) {
-              option::none { break; }
-              option::some(x) {
+              option::none => break,
+              option::some(x) => {
                 //FIXME (#2744): Replace with memcpy or something similar
                 let mut local_buf: ~[u8] =
                     unsafe::reinterpret_cast(*x.content);
@@ -832,8 +828,8 @@ mod node {
      */
     fn flatten(node: @node) -> @node unsafe {
         alt(*node) {
-          leaf(_) { return node }
-          concat(x) {
+          leaf(_) => return node,
+          concat(x) => {
             return @leaf({
                 byte_offset: 0u,
                 byte_len:    x.byte_len,
@@ -866,8 +862,8 @@ mod node {
         let it = leaf_iterator::start(node);
         loop {
             alt (leaf_iterator::next(it)) {
-              option::none   { break; }
-              option::some(x) { vec::push(forest, @leaf(x)); }
+              option::none    => break,
+              option::some(x) => vec::push(forest, @leaf(x))
             }
         }
         //2. Rebuild tree from forest
@@ -903,7 +899,7 @@ mod node {
                 return node;
             }
             alt(*node) {
-              node::leaf(x) {
+              node::leaf(x) => {
                 let char_len =
                     str::count_chars(*x.content, byte_offset, byte_len);
                 return @leaf({byte_offset: byte_offset,
@@ -911,7 +907,7 @@ mod node {
                                 char_len:    char_len,
                                 content:     x.content});
               }
-              node::concat(x) {
+              node::concat(x) => {
                 let left_len: uint = node::byte_len(x.left);
                 if byte_offset <= left_len {
                     if byte_offset + byte_len <= left_len {
@@ -961,7 +957,7 @@ mod node {
         let mut char_offset = char_offset;
         loop {
             alt(*node) {
-              node::leaf(x) {
+              node::leaf(x) => {
                 if char_offset == 0u && char_len == x.char_len {
                     return node;
                 }
@@ -974,7 +970,7 @@ mod node {
                            char_len:    char_len,
                            content:     x.content});
               }
-              node::concat(x) {
+              node::concat(x) => {
                 if char_offset == 0u && char_len == x.char_len {return node;}
                 let left_len : uint = node::char_len(x.left);
                 if char_offset <= left_len {
@@ -1012,8 +1008,8 @@ mod node {
 
     fn height(node: @node) -> uint {
         alt(*node) {
-          leaf(_)   { return 0u; }
-          concat(x) { return x.height; }
+          leaf(_)   => return 0u,
+          concat(x) => return x.height
         }
     }
 
@@ -1023,16 +1019,14 @@ mod node {
         let mut result = 0;
         while result == 0 {
             alt((char_iterator::next(ita), char_iterator::next(itb))) {
-              (option::none, option::none) {
-                break;
-              }
-              (option::some(chara), option::some(charb)) {
+              (option::none, option::none) => break,
+              (option::some(chara), option::some(charb)) => {
                 result = char::cmp(chara, charb);
               }
-              (option::some(_), _)         {
+              (option::some(_), _) => {
                 result = 1;
               }
-              (_, option::some(_))         {
+              (_, option::some(_)) => {
                 result = -1;
               }
             }
@@ -1066,15 +1060,11 @@ mod node {
         let mut current = node;
         loop {
             alt(*current) {
-              leaf(x) {
-                return it(x);
-              }
-              concat(x) {
-                if loop_leaves(x.left, it) { //non tail call
-                    current = x.right;       //tail call
-                } else {
-                    return false;
-                }
+              leaf(x) => return it(x),
+              concat(x) => if loop_leaves(x.left, it) { //non tail call
+                current = x.right;       //tail call
+              } else {
+                return false;
               }
             }
         };
@@ -1102,10 +1092,8 @@ mod node {
         let mut pos     = pos;
         loop {
             alt *node {
-              leaf(x) {
-                return str::char_at(*x.content, pos);
-              }
-              concat({left, right, _}) {
+              leaf(x) => return str::char_at(*x.content, pos),
+              concat({left, right, _}) => {
                 let left_len = char_len(left);
                 node = if left_len > pos { left }
                        else { pos -= left_len; right };
@@ -1139,15 +1127,13 @@ mod node {
                 let current = it.stack[it.stackpos];
                 it.stackpos -= 1;
                 alt(*current) {
-                  concat(x) {
+                  concat(x) => {
                     it.stackpos += 1;
                     it.stack[it.stackpos] = x.right;
                     it.stackpos += 1;
                     it.stack[it.stackpos] = x.left;
                   }
-                  leaf(x) {
-                    return option::some(x);
-                  }
+                  leaf(x) => return option::some(x)
                 }
             };
         }
@@ -1179,16 +1165,12 @@ mod node {
         fn next(it: t) -> option<char> {
             loop {
                 alt(get_current_or_next_leaf(it)) {
-                  option::none { return option::none; }
-                  option::some(_) {
+                  option::none => return option::none,
+                  option::some(_) => {
                     let next_char = get_next_char_in_leaf(it);
                     alt(next_char) {
-                      option::none {
-                        again;
-                      }
-                      option::some(_) {
-                        return next_char;
-                      }
+                      option::none => again,
+                      option::some(_) => return next_char
                     }
                   }
                 }
@@ -1197,12 +1179,12 @@ mod node {
 
         fn get_current_or_next_leaf(it: t) -> option<leaf> {
             alt(it.leaf) {
-              option::some(_) { return it.leaf }
-              option::none {
+              option::some(_) => return it.leaf,
+              option::none => {
                 let next = leaf_iterator::next(it.leaf_iterator);
                 alt(next) {
-                  option::none { return option::none }
-                  option::some(_) {
+                  option::none => return option::none,
+                  option::some(_) => {
                     it.leaf          = next;
                     it.leaf_byte_pos = 0u;
                     return next;
@@ -1214,8 +1196,8 @@ mod node {
 
         fn get_next_char_in_leaf(it: t) -> option<char> {
             alt copy it.leaf {
-              option::none { return option::none }
-              option::some(aleaf) {
+              option::none => return option::none,
+              option::some(aleaf) => {
                 if it.leaf_byte_pos >= aleaf.byte_len {
                     //We are actually past the end of the leaf
                     it.leaf = option::none;
@@ -1239,17 +1221,17 @@ mod tests {
     //Utility function, used for sanity check
     fn rope_to_string(r: rope) -> ~str {
         alt(r) {
-          node::empty { return ~"" }
-          node::content(x) {
+          node::empty => return ~"",
+          node::content(x) => {
             let str = @mut ~"";
             fn aux(str: @mut ~str, node: @node::node) unsafe {
                 alt(*node) {
-                  node::leaf(x) {
+                  node::leaf(x) => {
                     *str += str::slice(
                         *x.content, x.byte_offset,
                         x.byte_offset + x.byte_len);
                   }
-                  node::concat(x) {
+                  node::concat(x) => {
                     aux(str, x.left);
                     aux(str, x.right);
                   }
@@ -1293,11 +1275,11 @@ mod tests {
         let mut equal   = true;
         while equal {
             alt(node::char_iterator::next(rope_iter)) {
-              option::none {
+              option::none => {
                 if string_iter < string_len {
                     equal = false;
                 } break; }
-              option::some(c) {
+              option::some(c) => {
                 let {ch, next} = str::char_range_at(*sample, string_iter);
                 string_iter = next;
                 if ch != c { equal = false; break; }
@@ -1320,8 +1302,8 @@ mod tests {
         let it  = iterator::char::start(r);
         loop {
             alt(node::char_iterator::next(it)) {
-              option::none { break; }
-              option::some(_) { len += 1u; }
+              option::none => break,
+              option::some(_) => len += 1u
             }
         }
 
diff --git a/src/libstd/serialization.rs b/src/libstd/serialization.rs
index 5be0ac26d23..622d31c00b9 100644
--- a/src/libstd/serialization.rs
+++ b/src/libstd/serialization.rs
@@ -244,16 +244,12 @@ fn deserialize_bool<D: deserializer>(d: D) -> bool {
 fn serialize_option<S: serializer,T>(s: S, v: option<T>, st: fn(T)) {
     do s.emit_enum(~"option") {
         alt v {
-          none {
-            do s.emit_enum_variant(~"none", 0u, 0u) {
-            }
+          none => do s.emit_enum_variant(~"none", 0u, 0u) {
           }
 
-          some(v) {
-            do s.emit_enum_variant(~"some", 1u, 1u) {
-                do s.emit_enum_variant_arg(0u) {
-                    st(v)
-                }
+          some(v) => do s.emit_enum_variant(~"some", 1u, 1u) {
+            do s.emit_enum_variant_arg(0u) {
+                st(v)
             }
           }
         }
@@ -265,14 +261,8 @@ fn deserialize_option<D: deserializer,T: copy>(d: D, st: fn() -> T)
     do d.read_enum(~"option") {
         do d.read_enum_variant |i| {
             alt check i {
-              0u { // none
-                none
-              }
-              1u { // some(v)
-                some(d.read_enum_variant_arg(0u, || {
-                    st()
-                }))
-              }
+              0u => none,
+              1u => some(d.read_enum_variant_arg(0u, || st() ))
             }
         }
     }
diff --git a/src/libstd/smallintmap.rs b/src/libstd/smallintmap.rs
index b8bdf581218..2fe09f75d56 100644
--- a/src/libstd/smallintmap.rs
+++ b/src/libstd/smallintmap.rs
@@ -49,8 +49,11 @@ pure fn find<T: copy>(self: smallintmap<T>, key: uint) -> option<T> {
  */
 pure fn get<T: copy>(self: smallintmap<T>, key: uint) -> T {
     alt find(self, key) {
-      none { error!{"smallintmap::get(): key not present"}; fail; }
-      some(v) { return v; }
+      none => {
+        error!{"smallintmap::get(): key not present"};
+        fail;
+      }
+      some(v) => return v
     }
 }
 
@@ -64,7 +67,10 @@ impl <V: copy> of map::map<uint, V> for smallintmap<V> {
     fn size() -> uint {
         let mut sz = 0u;
         for self.v.each |item| {
-            alt item { some(_) { sz += 1u; } _ {} }
+            alt item {
+              some(_) => sz += 1u,
+              _ => ()
+            }
         }
         sz
     }
@@ -98,10 +104,8 @@ impl <V: copy> of map::map<uint, V> for smallintmap<V> {
         let mut idx = 0u, l = self.v.len();
         while idx < l {
             alt self.v.get_elt(idx) {
-              some(elt) {
-                if !it(idx, elt) { break; }
-              }
-              none { }
+              some(elt) => if !it(idx, elt) { break }
+              none => ()
             }
             idx += 1u;
         }
@@ -116,10 +120,8 @@ impl <V: copy> of map::map<uint, V> for smallintmap<V> {
         let mut idx = 0u, l = self.v.len();
         while idx < l {
             alt self.v.get_elt(idx) {
-              some(elt) {
-                if !it(&idx, &elt) { break; }
-              }
-              none { }
+              some(elt) => if !it(&idx, &elt) { break }
+              none => ()
             }
             idx += 1u;
         }
diff --git a/src/libstd/tempfile.rs b/src/libstd/tempfile.rs
index 80a075dbe53..a67164ee107 100644
--- a/src/libstd/tempfile.rs
+++ b/src/libstd/tempfile.rs
@@ -22,10 +22,10 @@ fn mkdtemp(prefix: ~str, suffix: ~str) -> option<~str> {
 fn test_mkdtemp() {
     let r = mkdtemp(~"./", ~"foobar");
     alt r {
-        some(p) {
+        some(p) => {
             os::remove_dir(p);
             assert(str::ends_with(p, ~"foobar"));
         }
-        _ { assert(false); }
+        _ => assert(false)
     }
 }
diff --git a/src/libstd/term.rs b/src/libstd/term.rs
index 20fb9622e3d..1d2ae7bca5d 100644
--- a/src/libstd/term.rs
+++ b/src/libstd/term.rs
@@ -36,13 +36,13 @@ fn color_supported() -> bool {
     let supported_terms = ~[~"xterm-color", ~"xterm",
                            ~"screen-bce", ~"xterm-256color"];
     return alt os::getenv(~"TERM") {
-          option::some(env) {
+          option::some(env) => {
             for vec::each(supported_terms) |term| {
                 if term == env { return true; }
             }
             false
           }
-          option::none { false }
+          option::none => false
         };
 }
 
diff --git a/src/libstd/test.rs b/src/libstd/test.rs
index 8d2673df5c6..890bddb3519 100644
--- a/src/libstd/test.rs
+++ b/src/libstd/test.rs
@@ -53,8 +53,8 @@ type test_desc = {
 fn test_main(args: ~[~str], tests: ~[test_desc]) {
     let opts =
         alt parse_opts(args) {
-          either::left(o) { o }
-          either::right(m) { fail m }
+          either::left(o) => o,
+          either::right(m) => fail m
         };
     if !run_tests_console(opts, tests) { fail ~"Some tests failed"; }
 }
@@ -70,8 +70,8 @@ fn parse_opts(args: ~[~str]) -> opt_res {
     let opts = ~[getopts::optflag(~"ignored"), getopts::optopt(~"logfile")];
     let matches =
         alt getopts::getopts(args_, opts) {
-          ok(m) { m }
-          err(f) { return either::right(getopts::fail_str(f)) }
+          ok(m) => m,
+          err(f) => return either::right(getopts::fail_str(f))
         };
 
     let filter =
@@ -106,32 +106,30 @@ fn run_tests_console(opts: test_opts,
 
     fn callback(event: testevent, st: console_test_state) {
         alt event {
-          te_filtered(filtered_tests) {
+          te_filtered(filtered_tests) => {
             st.total = vec::len(filtered_tests);
             let noun = if st.total != 1u { ~"tests" } else { ~"test" };
             st.out.write_line(fmt!{"\nrunning %u %s", st.total, noun});
           }
-          te_wait(test) { st.out.write_str(fmt!{"test %s ... ", test.name}); }
-          te_result(test, result) {
+          te_wait(test) => st.out.write_str(fmt!{"test %s ... ", test.name}),
+          te_result(test, result) => {
             alt st.log_out {
-                some(f) {
-                    write_log(f, result, test);
-                }
-                none {}
+                some(f) => write_log(f, result, test),
+                none => ()
             }
             alt result {
-              tr_ok {
+              tr_ok => {
                 st.passed += 1u;
                 write_ok(st.out, st.use_color);
                 st.out.write_line(~"");
               }
-              tr_failed {
+              tr_failed => {
                 st.failed += 1u;
                 write_failed(st.out, st.use_color);
                 st.out.write_line(~"");
                 vec::push(st.failures, copy test);
               }
-              tr_ignored {
+              tr_ignored => {
                 st.ignored += 1u;
                 write_ignored(st.out, st.use_color);
                 st.out.write_line(~"");
@@ -142,15 +140,13 @@ fn run_tests_console(opts: test_opts,
     }
 
     let log_out = alt opts.logfile {
-        some(path) {
-            alt io::file_writer(path, ~[io::create, io::truncate]) {
-                result::ok(w) { some(w) }
-                result::err(s) {
-                    fail(fmt!{"can't open output file: %s", s})
-                }
-            }
+        some(path) => alt io::file_writer(path, ~[io::create, io::truncate]) {
+          result::ok(w) => some(w),
+          result::err(s) => {
+              fail(fmt!{"can't open output file: %s", s})
+          }
         }
-        none { none }
+        none => none
     };
 
     let st =
@@ -185,9 +181,9 @@ fn run_tests_console(opts: test_opts,
     fn write_log(out: io::writer, result: test_result, test: test_desc) {
         out.write_line(fmt!{"%s %s",
                     alt result {
-                        tr_ok { ~"ok" }
-                        tr_failed { ~"failed" }
-                        tr_ignored { ~"ignored" }
+                        tr_ok => ~"ok",
+                        tr_failed => ~"failed",
+                        tr_ignored => ~"ignored"
                     }, test.name});
     }
 
@@ -339,8 +335,8 @@ fn filter_tests(opts: test_opts,
     } else {
         let filter_str =
             alt opts.filter {
-          option::some(f) { f }
-          option::none { ~"" }
+          option::some(f) => f,
+          option::none => ~""
         };
 
         fn filter_fn(test: test_desc, filter_str: ~str) ->
@@ -483,16 +479,20 @@ mod tests {
     #[test]
     fn first_free_arg_should_be_a_filter() {
         let args = ~[~"progname", ~"filter"];
-        let opts = alt parse_opts(args) { either::left(o) { o }
-          _ { fail ~"Malformed arg in first_free_arg_should_be_a_filter"; } };
+        let opts = alt parse_opts(args) {
+          either::left(o) => o,
+          _ => fail ~"Malformed arg in first_free_arg_should_be_a_filter"
+        };
         assert ~"filter" == option::get(opts.filter);
     }
 
     #[test]
     fn parse_ignored_flag() {
         let args = ~[~"progname", ~"filter", ~"--ignored"];
-        let opts = alt parse_opts(args) { either::left(o) { o }
-          _ { fail ~"Malformed arg in parse_ignored_flag"; } };
+        let opts = alt parse_opts(args) {
+          either::left(o) => o,
+          _ => fail ~"Malformed arg in parse_ignored_flag"
+        };
         assert (opts.run_ignored);
     }
 
diff --git a/src/libstd/time.rs b/src/libstd/time.rs
index 3ec2975db18..23b6bf22276 100644
--- a/src/libstd/time.rs
+++ b/src/libstd/time.rs
@@ -182,11 +182,11 @@ fn strptime(s: ~str, format: ~str) -> result<tm, ~str> {
             pos = next;
 
             alt ch {
-              '0' to '9' {
+              '0' to '9' => {
                 value = value * 10_i32 + (ch as i32 - '0' as i32);
               }
-              ' ' if ws { }
-              _ { return none; }
+              ' ' if ws => (),
+              _ => return none
             }
             i += 1u;
         }
@@ -209,83 +209,73 @@ fn strptime(s: ~str, format: ~str) -> result<tm, ~str> {
     fn parse_type(s: ~str, pos: uint, ch: char, tm: tm_mut)
       -> result<uint, ~str> {
         alt ch {
-          'A' {
-            alt match_strs(s, pos, ~[
-                (~"Sunday", 0_i32),
-                (~"Monday", 1_i32),
-                (~"Tuesday", 2_i32),
-                (~"Wednesday", 3_i32),
-                (~"Thursday", 4_i32),
-                (~"Friday", 5_i32),
-                (~"Saturday", 6_i32)
-            ]) {
-              some(item) { let (v, pos) = item; tm.tm_wday = v; ok(pos) }
-              none { err(~"Invalid day") }
-            }
+          'A' => alt match_strs(s, pos, ~[
+              (~"Sunday", 0_i32),
+              (~"Monday", 1_i32),
+              (~"Tuesday", 2_i32),
+              (~"Wednesday", 3_i32),
+              (~"Thursday", 4_i32),
+              (~"Friday", 5_i32),
+              (~"Saturday", 6_i32)
+          ]) {
+            some(item) => { let (v, pos) = item; tm.tm_wday = v; ok(pos) }
+            none => err(~"Invalid day")
           }
-          'a' {
-            alt match_strs(s, pos, ~[
-                (~"Sun", 0_i32),
-                (~"Mon", 1_i32),
-                (~"Tue", 2_i32),
-                (~"Wed", 3_i32),
-                (~"Thu", 4_i32),
-                (~"Fri", 5_i32),
-                (~"Sat", 6_i32)
-            ]) {
-              some(item) { let (v, pos) = item; tm.tm_wday = v; ok(pos) }
-              none { err(~"Invalid day") }
-            }
+          'a' => alt match_strs(s, pos, ~[
+              (~"Sun", 0_i32),
+              (~"Mon", 1_i32),
+              (~"Tue", 2_i32),
+              (~"Wed", 3_i32),
+              (~"Thu", 4_i32),
+              (~"Fri", 5_i32),
+              (~"Sat", 6_i32)
+          ]) {
+            some(item) => { let (v, pos) = item; tm.tm_wday = v; ok(pos) }
+            none => err(~"Invalid day")
           }
-          'B' {
-            alt match_strs(s, pos, ~[
-                (~"January", 0_i32),
-                (~"February", 1_i32),
-                (~"March", 2_i32),
-                (~"April", 3_i32),
-                (~"May", 4_i32),
-                (~"June", 5_i32),
-                (~"July", 6_i32),
-                (~"August", 7_i32),
-                (~"September", 8_i32),
-                (~"October", 9_i32),
-                (~"November", 10_i32),
-                (~"December", 11_i32)
-            ]) {
-              some(item) { let (v, pos) = item; tm.tm_mon = v; ok(pos) }
-              none { err(~"Invalid month") }
-            }
+          'B' => alt match_strs(s, pos, ~[
+              (~"January", 0_i32),
+              (~"February", 1_i32),
+              (~"March", 2_i32),
+              (~"April", 3_i32),
+              (~"May", 4_i32),
+              (~"June", 5_i32),
+              (~"July", 6_i32),
+              (~"August", 7_i32),
+              (~"September", 8_i32),
+              (~"October", 9_i32),
+              (~"November", 10_i32),
+              (~"December", 11_i32)
+          ]) {
+            some(item) => { let (v, pos) = item; tm.tm_mon = v; ok(pos) }
+            none => err(~"Invalid month")
           }
-          'b' | 'h' {
-            alt match_strs(s, pos, ~[
-                (~"Jan", 0_i32),
-                (~"Feb", 1_i32),
-                (~"Mar", 2_i32),
-                (~"Apr", 3_i32),
-                (~"May", 4_i32),
-                (~"Jun", 5_i32),
-                (~"Jul", 6_i32),
-                (~"Aug", 7_i32),
-                (~"Sep", 8_i32),
-                (~"Oct", 9_i32),
-                (~"Nov", 10_i32),
-                (~"Dec", 11_i32)
-            ]) {
-              some(item) { let (v, pos) = item; tm.tm_mon = v; ok(pos) }
-              none { err(~"Invalid month") }
-            }
+          'b' | 'h' => alt match_strs(s, pos, ~[
+              (~"Jan", 0_i32),
+              (~"Feb", 1_i32),
+              (~"Mar", 2_i32),
+              (~"Apr", 3_i32),
+              (~"May", 4_i32),
+              (~"Jun", 5_i32),
+              (~"Jul", 6_i32),
+              (~"Aug", 7_i32),
+              (~"Sep", 8_i32),
+              (~"Oct", 9_i32),
+              (~"Nov", 10_i32),
+              (~"Dec", 11_i32)
+          ]) {
+            some(item) => { let (v, pos) = item; tm.tm_mon = v; ok(pos) }
+            none => err(~"Invalid month")
           }
-          'C' {
-            alt match_digits(s, pos, 2u, false) {
-              some(item) {
+          'C' => alt match_digits(s, pos, 2u, false) {
+            some(item) => {
                 let (v, pos) = item;
-                tm.tm_year += (v * 100_i32) - 1900_i32;
-                ok(pos)
+                  tm.tm_year += (v * 100_i32) - 1900_i32;
+                  ok(pos)
               }
-              none { err(~"Invalid year") }
-            }
+            none => err(~"Invalid year")
           }
-          'c' {
+          'c' => {
             parse_type(s, pos, 'a', tm)
                 .chain(|pos| parse_char(s, pos, ' '))
                 .chain(|pos| parse_type(s, pos, 'b', tm))
@@ -296,116 +286,108 @@ fn strptime(s: ~str, format: ~str) -> result<tm, ~str> {
                 .chain(|pos| parse_char(s, pos, ' '))
                 .chain(|pos| parse_type(s, pos, 'Y', tm))
           }
-          'D' | 'x' {
+          'D' | 'x' => {
             parse_type(s, pos, 'm', tm)
                 .chain(|pos| parse_char(s, pos, '/'))
                 .chain(|pos| parse_type(s, pos, 'd', tm))
                 .chain(|pos| parse_char(s, pos, '/'))
                 .chain(|pos| parse_type(s, pos, 'y', tm))
           }
-          'd' {
-            alt match_digits(s, pos, 2u, false) {
-              some(item) { let (v, pos) = item; tm.tm_mday = v; ok(pos) }
-              none { err(~"Invalid day of the month") }
-            }
+          'd' => alt match_digits(s, pos, 2u, false) {
+            some(item) => { let (v, pos) = item; tm.tm_mday = v; ok(pos) }
+            none => err(~"Invalid day of the month")
           }
-          'e' {
-            alt match_digits(s, pos, 2u, true) {
-              some(item) { let (v, pos) = item; tm.tm_mday = v; ok(pos) }
-              none { err(~"Invalid day of the month") }
-            }
+          'e' => alt match_digits(s, pos, 2u, true) {
+            some(item) => { let (v, pos) = item; tm.tm_mday = v; ok(pos) }
+            none => err(~"Invalid day of the month")
           }
-          'F' {
+          'F' => {
             parse_type(s, pos, 'Y', tm)
                 .chain(|pos| parse_char(s, pos, '-'))
                 .chain(|pos| parse_type(s, pos, 'm', tm))
                 .chain(|pos| parse_char(s, pos, '-'))
                 .chain(|pos| parse_type(s, pos, 'd', tm))
           }
-          'H' {
+          'H' => {
             // FIXME (#2350): range check.
             alt match_digits(s, pos, 2u, false) {
-              some(item) { let (v, pos) = item; tm.tm_hour = v; ok(pos) }
-              none { err(~"Invalid hour") }
+              some(item) => { let (v, pos) = item; tm.tm_hour = v; ok(pos) }
+              none => err(~"Invalid hour")
             }
           }
-          'I' {
+          'I' => {
             // FIXME (#2350): range check.
             alt match_digits(s, pos, 2u, false) {
-              some(item) {
+              some(item) => {
                   let (v, pos) = item;
                   tm.tm_hour = if v == 12_i32 { 0_i32 } else { v };
                   ok(pos)
               }
-              none { err(~"Invalid hour") }
+              none => err(~"Invalid hour")
             }
           }
-          'j' {
+          'j' => {
             // FIXME (#2350): range check.
             alt match_digits(s, pos, 3u, false) {
-              some(item) {
+              some(item) => {
                 let (v, pos) = item;
                 tm.tm_yday = v - 1_i32;
                 ok(pos)
               }
-              none { err(~"Invalid year") }
+              none => err(~"Invalid year")
             }
           }
-          'k' {
+          'k' => {
             // FIXME (#2350): range check.
             alt match_digits(s, pos, 2u, true) {
-              some(item) { let (v, pos) = item; tm.tm_hour = v; ok(pos) }
-              none { err(~"Invalid hour") }
+              some(item) => { let (v, pos) = item; tm.tm_hour = v; ok(pos) }
+              none => err(~"Invalid hour")
             }
           }
-          'l' {
+          'l' => {
             // FIXME (#2350): range check.
             alt match_digits(s, pos, 2u, true) {
-              some(item) {
+              some(item) => {
                   let (v, pos) = item;
                   tm.tm_hour = if v == 12_i32 { 0_i32 } else { v };
                   ok(pos)
               }
-              none { err(~"Invalid hour") }
+              none => err(~"Invalid hour")
             }
           }
-          'M' {
+          'M' => {
             // FIXME (#2350): range check.
             alt match_digits(s, pos, 2u, false) {
-              some(item) { let (v, pos) = item; tm.tm_min = v; ok(pos) }
-              none { err(~"Invalid minute") }
+              some(item) => { let (v, pos) = item; tm.tm_min = v; ok(pos) }
+              none => err(~"Invalid minute")
             }
           }
-          'm' {
+          'm' => {
             // FIXME (#2350): range check.
             alt match_digits(s, pos, 2u, false) {
-              some(item) {
+              some(item) => {
                 let (v, pos) = item;
                 tm.tm_mon = v - 1_i32;
                 ok(pos)
               }
-              none { err(~"Invalid month") }
+              none => err(~"Invalid month")
             }
           }
-          'n' { parse_char(s, pos, '\n') }
-          'P' {
-            alt match_strs(s, pos, ~[(~"am", 0_i32), (~"pm", 12_i32)]) {
-              some(item) { let (v, pos) = item; tm.tm_hour += v; ok(pos) }
-              none { err(~"Invalid hour") }
-            }
+          'n' => parse_char(s, pos, '\n'),
+          'P' => alt match_strs(s, pos, ~[(~"am", 0_i32), (~"pm", 12_i32)]) {
+            some(item) => { let (v, pos) = item; tm.tm_hour += v; ok(pos) }
+            none => err(~"Invalid hour")
           }
-          'p' {
-            alt match_strs(s, pos, ~[(~"AM", 0_i32), (~"PM", 12_i32)]) {
-              some(item) { let (v, pos) = item; tm.tm_hour += v; ok(pos) }
-              none { err(~"Invalid hour") }
-            }
+          'p' => alt match_strs(s, pos, ~[(~"AM", 0_i32), (~"PM", 12_i32)]) {
+            some(item) => { let (v, pos) = item; tm.tm_hour += v; ok(pos) }
+            none => err(~"Invalid hour")
           }
-          'R' {
+          'R' => {
             parse_type(s, pos, 'H', tm)
                 .chain(|pos| parse_char(s, pos, ':'))
                 .chain(|pos| parse_type(s, pos, 'M', tm))
           }
-          'r' {
+          'r' => {
             parse_type(s, pos, 'I', tm)
                 .chain(|pos| parse_char(s, pos, ':'))
                 .chain(|pos| parse_type(s, pos, 'M', tm))
@@ -414,38 +396,38 @@ fn strptime(s: ~str, format: ~str) -> result<tm, ~str> {
                 .chain(|pos| parse_char(s, pos, ' '))
                 .chain(|pos| parse_type(s, pos, 'p', tm))
           }
-          'S' {
+          'S' => {
             // FIXME (#2350): range check.
             alt match_digits(s, pos, 2u, false) {
-              some(item) {
+              some(item) => {
                 let (v, pos) = item;
                 tm.tm_sec = v;
                 ok(pos)
               }
-              none { err(~"Invalid second") }
+              none => err(~"Invalid second")
             }
           }
           //'s' {}
-          'T' | 'X' {
+          'T' | 'X' => {
             parse_type(s, pos, 'H', tm)
                 .chain(|pos| parse_char(s, pos, ':'))
                 .chain(|pos| parse_type(s, pos, 'M', tm))
                 .chain(|pos| parse_char(s, pos, ':'))
                 .chain(|pos| parse_type(s, pos, 'S', tm))
           }
-          't' { parse_char(s, pos, '\t') }
-          'u' {
+          't' => parse_char(s, pos, '\t'),
+          'u' => {
             // FIXME (#2350): range check.
             alt match_digits(s, pos, 1u, false) {
-              some(item) {
+              some(item) => {
                 let (v, pos) = item;
                 tm.tm_wday = v;
                 ok(pos)
               }
-              none { err(~"Invalid weekday") }
+              none => err(~"Invalid weekday")
             }
           }
-          'v' {
+          'v' => {
             parse_type(s, pos, 'e', tm)
                 .chain(|pos| parse_char(s, pos, '-'))
                 .chain(|pos| parse_type(s, pos, 'b', tm))
@@ -453,38 +435,38 @@ fn strptime(s: ~str, format: ~str) -> result<tm, ~str> {
                 .chain(|pos| parse_type(s, pos, 'Y', tm))
           }
           //'W' {}
-          'w' {
+          'w' => {
             // FIXME (#2350): range check.
             alt match_digits(s, pos, 1u, false) {
-              some(item) { let (v, pos) = item; tm.tm_wday = v; ok(pos) }
-              none { err(~"Invalid weekday") }
+              some(item) => { let (v, pos) = item; tm.tm_wday = v; ok(pos) }
+              none => err(~"Invalid weekday")
             }
           }
           //'X' {}
           //'x' {}
-          'Y' {
+          'Y' => {
             // FIXME (#2350): range check.
             alt match_digits(s, pos, 4u, false) {
-              some(item) {
+              some(item) => {
                 let (v, pos) = item;
                 tm.tm_year = v - 1900_i32;
                 ok(pos)
               }
-              none { err(~"Invalid weekday") }
+              none => err(~"Invalid weekday")
             }
           }
-          'y' {
+          'y' => {
             // FIXME (#2350): range check.
             alt match_digits(s, pos, 2u, false) {
-              some(item) {
+              some(item) => {
                 let (v, pos) = item;
                 tm.tm_year = v - 1900_i32;
                 ok(pos)
               }
-              none { err(~"Invalid weekday") }
+              none => err(~"Invalid weekday")
             }
           }
-          'Z' {
+          'Z' => {
             if match_str(s, pos, ~"UTC") || match_str(s, pos, ~"GMT") {
                 tm.tm_gmtoff = 0_i32;
                 tm.tm_zone = ~"UTC";
@@ -503,12 +485,12 @@ fn strptime(s: ~str, format: ~str) -> result<tm, ~str> {
                 ok(pos)
             }
           }
-          'z' {
+          'z' => {
             let {ch, next} = str::char_range_at(s, pos);
 
             if ch == '+' || ch == '-' {
                 alt match_digits(s, next, 4u, false) {
-                  some(item) {
+                  some(item) => {
                     let (v, pos) = item;
                     if v == 0_i32 {
                         tm.tm_gmtoff = 0_i32;
@@ -517,14 +499,14 @@ fn strptime(s: ~str, format: ~str) -> result<tm, ~str> {
 
                     ok(pos)
                   }
-                  none { err(~"Invalid zone offset") }
+                  none => err(~"Invalid zone offset")
                 }
             } else {
                 err(~"Invalid zone offset")
             }
           }
-          '%' { parse_char(s, pos, '%') }
-          ch {
+          '%' => parse_char(s, pos, '%'),
+          ch => {
             err(fmt!{"unknown formatting type: %?", str::from_char(ch)})
           }
         }
@@ -553,13 +535,11 @@ fn strptime(s: ~str, format: ~str) -> result<tm, ~str> {
             let {ch, next} = str::char_range_at(s, pos);
 
             alt rdr.read_char() {
-              '%' {
-                alt parse_type(s, pos, rdr.read_char(), tm) {
-                  ok(next) { pos = next; }
-                  err(e) { result = err(e); break; }
-                }
+              '%' => alt parse_type(s, pos, rdr.read_char(), tm) {
+                ok(next) => pos = next,
+                  err(e) => { result = err(e); break; }
               }
-              c {
+              c => {
                 if c != ch { break }
                 pos = next;
               }
@@ -589,62 +569,54 @@ fn strftime(format: ~str, tm: tm) -> ~str {
     fn parse_type(ch: char, tm: tm) -> ~str {
         //FIXME (#2350): Implement missing types.
         alt check ch {
-          'A' {
-            alt check tm.tm_wday as int {
-              0 { ~"Sunday" }
-              1 { ~"Monday" }
-              2 { ~"Tuesday" }
-              3 { ~"Wednesday" }
-              4 { ~"Thursday" }
-              5 { ~"Friday" }
-              6 { ~"Saturday" }
-            }
+          'A' => alt check tm.tm_wday as int {
+            0 => ~"Sunday",
+            1 => ~"Monday",
+            2 => ~"Tuesday",
+            3 => ~"Wednesday",
+            4 => ~"Thursday",
+            5 => ~"Friday",
+            6 => ~"Saturday"
           }
-          'a' {
-            alt check tm.tm_wday as int {
-              0 { ~"Sun" }
-              1 { ~"Mon" }
-              2 { ~"Tue" }
-              3 { ~"Wed" }
-              4 { ~"Thu" }
-              5 { ~"Fri" }
-              6 { ~"Sat" }
-            }
+          'a' => alt check tm.tm_wday as int {
+            0 => ~"Sun",
+            1 => ~"Mon",
+            2 => ~"Tue",
+            3 => ~"Wed",
+            4 => ~"Thu",
+            5 => ~"Fri",
+            6 => ~"Sat"
           }
-          'B' {
-            alt check tm.tm_mon as int {
-              0 { ~"January" }
-              1 { ~"February" }
-              2 { ~"March" }
-              3 { ~"April" }
-              4 { ~"May" }
-              5 { ~"June" }
-              6 { ~"July" }
-              7 { ~"August" }
-              8 { ~"September" }
-              9 { ~"October" }
-              10 { ~"November" }
-              11 { ~"December" }
-            }
+          'B' => alt check tm.tm_mon as int {
+            0 => ~"January",
+            1 => ~"February",
+            2 => ~"March",
+            3 => ~"April",
+            4 => ~"May",
+            5 => ~"June",
+            6 => ~"July",
+            7 => ~"August",
+            8 => ~"September",
+            9 => ~"October",
+            10 => ~"November",
+            11 => ~"December"
           }
-          'b' | 'h' {
-            alt check tm.tm_mon as int {
-              0 { ~"Jan" }
-              1 { ~"Feb" }
-              2 { ~"Mar" }
-              3 { ~"Apr" }
-              4 { ~"May" }
-              5 { ~"Jun" }
-              6 { ~"Jul" }
-              7 { ~"Aug" }
-              8 { ~"Sep" }
-              9 { ~"Oct" }
-              10 { ~"Nov" }
-              11 { ~"Dec" }
-            }
+          'b' | 'h' => alt check tm.tm_mon as int {
+            0 => ~"Jan",
+            1 => ~"Feb",
+            2 => ~"Mar",
+            3 => ~"Apr",
+            4 => ~"May",
+            5 => ~"Jun",
+            6 => ~"Jul",
+            7 => ~"Aug",
+            8 => ~"Sep",
+            9 => ~"Oct",
+            10 => ~"Nov",
+            11 => ~"Dec",
           }
-          'C' { fmt!{"%02d", (tm.tm_year as int + 1900) / 100} }
-          'c' {
+          'C' => fmt!{"%02d", (tm.tm_year as int + 1900) / 100},
+          'c' => {
             fmt!{"%s %s %s %s %s",
                 parse_type('a', tm),
                 parse_type('b', tm),
@@ -652,15 +624,15 @@ fn strftime(format: ~str, tm: tm) -> ~str {
                 parse_type('T', tm),
                 parse_type('Y', tm)}
           }
-          'D' | 'x' {
+          'D' | 'x' => {
             fmt!{"%s/%s/%s",
                 parse_type('m', tm),
                 parse_type('d', tm),
                 parse_type('y', tm)}
           }
-          'd' { fmt!{"%02d", tm.tm_mday as int} }
-          'e' { fmt!{"%2d", tm.tm_mday as int} }
-          'F' {
+          'd' => fmt!{"%02d", tm.tm_mday as int},
+          'e' => fmt!{"%2d", tm.tm_mday as int},
+          'F' => {
             fmt!{"%s-%s-%s",
                 parse_type('Y', tm),
                 parse_type('m', tm),
@@ -668,67 +640,67 @@ fn strftime(format: ~str, tm: tm) -> ~str {
           }
           //'G' {}
           //'g' {}
-          'H' { fmt!{"%02d", tm.tm_hour as int} }
-          'I' {
+          'H' => fmt!{"%02d", tm.tm_hour as int},
+          'I' => {
             let mut h = tm.tm_hour as int;
             if h == 0 { h = 12 }
             if h > 12 { h -= 12 }
             fmt!{"%02d", h}
           }
-          'j' { fmt!{"%03d", tm.tm_yday as int + 1} }
-          'k' { fmt!{"%2d", tm.tm_hour as int} }
-          'l' {
+          'j' => fmt!{"%03d", tm.tm_yday as int + 1},
+          'k' => fmt!{"%2d", tm.tm_hour as int},
+          'l' => {
             let mut h = tm.tm_hour as int;
             if h == 0 { h = 12 }
             if h > 12 { h -= 12 }
             fmt!{"%2d", h}
           }
-          'M' { fmt!{"%02d", tm.tm_min as int} }
-          'm' { fmt!{"%02d", tm.tm_mon as int + 1} }
-          'n' { ~"\n" }
-          'P' { if tm.tm_hour as int < 12 { ~"am" } else { ~"pm" } }
-          'p' { if tm.tm_hour as int < 12 { ~"AM" } else { ~"PM" } }
-          'R' {
+          'M' => fmt!{"%02d", tm.tm_min as int},
+          'm' => fmt!{"%02d", tm.tm_mon as int + 1},
+          'n' => ~"\n",
+          'P' => if tm.tm_hour as int < 12 { ~"am" } else { ~"pm" }
+          'p' => if tm.tm_hour as int < 12 { ~"AM" } else { ~"PM" }
+          'R' => {
             fmt!{"%s:%s",
                 parse_type('H', tm),
                 parse_type('M', tm)}
           }
-          'r' {
+          'r' => {
             fmt!{"%s:%s:%s %s",
                 parse_type('I', tm),
                 parse_type('M', tm),
                 parse_type('S', tm),
                 parse_type('p', tm)}
           }
-          'S' { fmt!{"%02d", tm.tm_sec as int} }
-          's' { fmt!{"%d", tm.to_timespec().sec as int} }
-          'T' | 'X' {
+          'S' => fmt!{"%02d", tm.tm_sec as int},
+          's' => fmt!{"%d", tm.to_timespec().sec as int},
+          'T' | 'X' => {
             fmt!{"%s:%s:%s",
                 parse_type('H', tm),
                 parse_type('M', tm),
                 parse_type('S', tm)}
           }
-          't' { ~"\t" }
+          't' => ~"\t",
           //'U' {}
-          'u' {
+          'u' => {
             let i = tm.tm_wday as int;
             int::str(if i == 0 { 7 } else { i })
           }
           //'V' {}
-          'v' {
+          'v' => {
             fmt!{"%s-%s-%s",
                 parse_type('e', tm),
                 parse_type('b', tm),
                 parse_type('Y', tm)}
           }
           //'W' {}
-          'w' { int::str(tm.tm_wday as int) }
+          'w' => int::str(tm.tm_wday as int),
           //'X' {}
           //'x' {}
-          'Y' { int::str(tm.tm_year as int + 1900) }
-          'y' { fmt!{"%02d", (tm.tm_year as int + 1900) % 100} }
-          'Z' { tm.tm_zone }
-          'z' {
+          'Y' => int::str(tm.tm_year as int + 1900),
+          'y' => fmt!{"%02d", (tm.tm_year as int + 1900) % 100},
+          'Z' => tm.tm_zone,
+          'z' => {
             let sign = if tm.tm_gmtoff > 0_i32 { '+' } else { '-' };
             let mut m = i32::abs(tm.tm_gmtoff) / 60_i32;
             let h = m / 60_i32;
@@ -736,7 +708,7 @@ fn strftime(format: ~str, tm: tm) -> ~str {
             fmt!{"%c%02d%02d", sign, h as int, m as int}
           }
           //'+' {}
-          '%' { ~"%" }
+          '%' => ~"%"
         }
     }
 
@@ -745,8 +717,8 @@ fn strftime(format: ~str, tm: tm) -> ~str {
     do io::with_str_reader(format) |rdr| {
         while !rdr.eof() {
             alt rdr.read_char() {
-                '%' { buf += parse_type(rdr.read_char(), tm); }
-                ch { str::push_char(buf, ch); }
+                '%' => buf += parse_type(rdr.read_char(), tm),
+                ch => str::push_char(buf, ch)
             }
         }
     }
@@ -961,7 +933,7 @@ mod tests {
         tzset();
 
         alt strptime(~"", ~"") {
-          ok(tm) {
+          ok(tm) => {
             assert tm.tm_sec == 0_i32;
             assert tm.tm_min == 0_i32;
             assert tm.tm_hour == 0_i32;
@@ -974,7 +946,7 @@ mod tests {
             assert tm.tm_zone == ~"";
             assert tm.tm_nsec == 0_i32;
           }
-          err(_) {}
+          err(_) => ()
         }
 
         let format = ~"%a %b %e %T %Y";
@@ -983,8 +955,8 @@ mod tests {
             == err(~"Invalid time");
 
         alt strptime(~"Fri Feb 13 15:31:30 2009", format) {
-          err(e) { fail e }
-          ok(tm) {
+          err(e) => fail e,
+          ok(tm) => {
             assert tm.tm_sec == 30_i32;
             assert tm.tm_min == 31_i32;
             assert tm.tm_hour == 15_i32;
@@ -1002,8 +974,8 @@ mod tests {
 
         fn test(s: ~str, format: ~str) -> bool {
             alt strptime(s, format) {
-              ok(tm) { tm.strftime(format) == s }
-              err(e) { fail e }
+              ok(tm) => tm.strftime(format) == s,
+              err(e) => fail e
             }
         }
 
diff --git a/src/libstd/timer.rs b/src/libstd/timer.rs
index 6b0b4eb2f17..de629d98d63 100644
--- a/src/libstd/timer.rs
+++ b/src/libstd/timer.rs
@@ -216,8 +216,11 @@ mod test {
             };
 
             alt recv_timeout(hl_loop, 10u, test_po) {
-              some(val) { assert val == expected; successes += 1; }
-              _ { failures += 1; }
+              some(val) => {
+                assert val == expected;
+                successes += 1;
+              }
+              _ => failures += 1
             };
         }
 
@@ -241,8 +244,8 @@ mod test {
             };
 
             alt recv_timeout(hl_loop, 1u, test_po) {
-              none { successes += 1; }
-              _ { failures += 1; }
+              none => successes += 1,
+              _ => failures += 1
             };
         }
 
diff --git a/src/libstd/treemap.rs b/src/libstd/treemap.rs
index b6dc2bfa579..ab7330fb1ee 100644
--- a/src/libstd/treemap.rs
+++ b/src/libstd/treemap.rs
@@ -31,14 +31,14 @@ fn treemap<K, V>() -> treemap<K, V> { @mut none }
 /// Insert a value into the map
 fn insert<K: copy, V: copy>(m: &mut tree_edge<K, V>, k: K, v: V) {
     alt copy *m {
-      none {
+      none => {
         *m = some(@tree_node({key: k,
                               mut value: v,
                               mut left: none,
                               mut right: none}));
         return;
       }
-      some(node) {
+      some(node) => {
         if k == node.key {
             node.value = v;
         } else if k < node.key {
@@ -53,10 +53,10 @@ fn insert<K: copy, V: copy>(m: &mut tree_edge<K, V>, k: K, v: V) {
 /// Find a value based on the key
 fn find<K: copy, V: copy>(m: &const tree_edge<K, V>, k: K) -> option<V> {
     alt copy *m {
-      none { none }
+      none => none,
 
       // FIXME (#2808): was that an optimization?
-      some(node) {
+      some(node) => {
         if k == node.key {
             some(node.value)
         } else if k < node.key {
@@ -71,8 +71,8 @@ fn find<K: copy, V: copy>(m: &const tree_edge<K, V>, k: K) -> option<V> {
 /// Visit all pairs in the map in order.
 fn traverse<K, V: copy>(m: &const tree_edge<K, V>, f: fn(K, V)) {
     alt copy *m {
-      none { }
-      some(node) {
+      none => (),
+      some(node) => {
         traverse(&const node.left, f);
         // copy of value is req'd as f() requires an immutable ptr
         f(node.key, copy node.value);
diff --git a/src/libstd/uv_global_loop.rs b/src/libstd/uv_global_loop.rs
index 2b5beda2e37..52e4879c0b2 100644
--- a/src/libstd/uv_global_loop.rs
+++ b/src/libstd/uv_global_loop.rs
@@ -57,14 +57,14 @@ fn get_monitor_task_gl() -> iotask unsafe {
             loop {
                 debug!{"in outer_loop..."};
                 alt select2(weak_exit_po, msg_po) {
-                  left(weak_exit) {
+                  left(weak_exit) => {
                     // all normal tasks have ended, tell the
                     // libuv loop to tear_down, then exit
                     debug!{"weak_exit_po recv'd msg: %?", weak_exit};
                     iotask::exit(hl_loop);
                     break;
                   }
-                  right(fetch_ch) {
+                  right(fetch_ch) => {
                     debug!{"hl_loop req recv'd: %?", fetch_ch};
                     fetch_ch.send(hl_loop);
                   }
diff --git a/src/libstd/uv_iotask.rs b/src/libstd/uv_iotask.rs
index d7de26228ca..5b9d3b1f2f2 100644
--- a/src/libstd/uv_iotask.rs
+++ b/src/libstd/uv_iotask.rs
@@ -145,12 +145,8 @@ extern fn wake_up_cb(async_handle: *ll::uv_async_t,
 
     while msg_po.peek() {
         alt msg_po.recv() {
-          interaction(cb) {
-            cb(loop_ptr);
-          }
-          teardown_loop {
-            begin_teardown(data);
-          }
+          interaction(cb) => cb(loop_ptr),
+          teardown_loop => begin_teardown(data)
         }
     }
 }
diff --git a/src/libstd/uv_ll.rs b/src/libstd/uv_ll.rs
index 108abace1c9..9d120cce742 100644
--- a/src/libstd/uv_ll.rs
+++ b/src/libstd/uv_ll.rs
@@ -849,12 +849,8 @@ unsafe fn ip6_name(src: &sockaddr_in6) -> ~str {
         let result = rustrt::rust_uv_ip6_name(src_unsafe_ptr,
                                               dst_buf, size as libc::size_t);
         alt result {
-          0i32 {
-            str::unsafe::from_buf(dst_buf)
-          }
-          _ {
-            ~""
-          }
+          0i32 => str::unsafe::from_buf(dst_buf),
+          _ => ~""
         }
     }
 }