Remove '.' after nullary tags in patterns

Does what it says on the tin.

The next commit will remove support for this syntax.

15 files changed, 104 insertions, 104 deletions

diff --git a/src/libstd/c_vec.rs b/src/libstd/c_vec.rs
index 58ed593a6c7..5bab771ab7d 100644
--- a/src/libstd/c_vec.rs
+++ b/src/libstd/c_vec.rs
@@ -48,7 +48,7 @@ tag t<T> {
 
 resource dtor_res(dtor: option::t<fn@()>) {
     alt dtor {
-      option::none. { }
+      option::none { }
       option::some(f) { f(); }
     }
 }
diff --git a/src/libstd/ebml.rs b/src/libstd/ebml.rs
index 88de3ebb725..fafec189414 100644
--- a/src/libstd/ebml.rs
+++ b/src/libstd/ebml.rs
@@ -66,7 +66,7 @@ fn maybe_get_doc(d: doc, tg: uint) -> option::t<doc> {
 fn get_doc(d: doc, tg: uint) -> doc {
     alt maybe_get_doc(d, tg) {
       some(d) { ret d; }
-      none. {
+      none {
         #error("failed to find block with tag %u", tg);
         fail;
       }
diff --git a/src/libstd/extfmt.rs b/src/libstd/extfmt.rs
index 74826310066..a729fba905f 100644
--- a/src/libstd/extfmt.rs
+++ b/src/libstd/extfmt.rs
@@ -119,7 +119,7 @@ mod ct {
         if !('0' as u8 <= c && c <= '9' as u8) { ret option::none; }
         let n = c - ('0' as u8) as uint;
         ret alt peek_num(s, i + 1u, lim) {
-              none. { some({num: n, next: i + 1u}) }
+              none { some({num: n, next: i + 1u}) }
               some(next) {
                 let m = next.num;
                 let j = next.next;
@@ -147,7 +147,7 @@ mod ct {
         if i >= lim { ret {param: none, next: i}; }
         let num = peek_num(s, i, lim);
         ret alt num {
-              none. { {param: none, next: i} }
+              none { {param: none, next: i} }
               some(t) {
                 let n = t.num;
                 let j = t.next;
@@ -193,13 +193,13 @@ mod ct {
                 let param = parse_parameter(s, i + 1u, lim);
                 let j = param.next;
                 alt param.param {
-                  none. { {count: count_is_next_param, next: j} }
+                  none { {count: count_is_next_param, next: j} }
                   some(n) { {count: count_is_param(n), next: j} }
                 }
             } else {
                 let num = peek_num(s, i, lim);
                 alt num {
-                  none. { {count: count_implied, next: i} }
+                  none { {count: count_implied, next: i} }
                   some(num) {
                     {count: count_is(num.num as int), next: num.next}
                   }
@@ -217,7 +217,7 @@ mod ct {
                 // If there were no digits specified, i.e. the precision
                 // was ".", then the precision is 0
                 alt count.count {
-                  count_implied. { {count: count_is(0), next: count.next} }
+                  count_implied { {count: count_is(0), next: count.next} }
                   _ { count }
                 }
             } else { {count: count_implied, next: i} };
@@ -297,11 +297,11 @@ mod rt {
         let prec = get_int_precision(cv);
         let rs =
             alt cv.ty {
-              ty_default. { uint_to_str_prec(u, 10u, prec) }
-              ty_hex_lower. { uint_to_str_prec(u, 16u, prec) }
-              ty_hex_upper. { str::to_upper(uint_to_str_prec(u, 16u, prec)) }
-              ty_bits. { uint_to_str_prec(u, 2u, prec) }
-              ty_octal. { uint_to_str_prec(u, 8u, prec) }
+              ty_default { uint_to_str_prec(u, 10u, prec) }
+              ty_hex_lower { uint_to_str_prec(u, 16u, prec) }
+              ty_hex_upper { str::to_upper(uint_to_str_prec(u, 16u, prec)) }
+              ty_bits { uint_to_str_prec(u, 2u, prec) }
+              ty_octal { uint_to_str_prec(u, 8u, prec) }
             };
         ret pad(cv, rs, pad_unsigned);
     }
@@ -322,7 +322,7 @@ mod rt {
         // FIXME: substr works on bytes, not chars!
         let unpadded =
             alt cv.precision {
-              count_implied. { s }
+              count_implied { s }
               count_is(max) {
                 if max as uint < str::char_len(s) {
                     str::substr(s, 0u, max as uint)
@@ -334,7 +334,7 @@ mod rt {
     fn conv_float(cv: conv, f: float) -> str {
         let (to_str, digits) = alt cv.precision {
               count_is(c) { (float::to_str_exact, c as uint) }
-              count_implied. { (float::to_str, 6u) }
+              count_implied { (float::to_str, 6u) }
         };
         let s = to_str(f, digits);
         if 0.0 <= f {
@@ -374,7 +374,7 @@ mod rt {
     fn get_int_precision(cv: conv) -> uint {
         ret alt cv.precision {
               count_is(c) { c as uint }
-              count_implied. { 1u }
+              count_implied { 1u }
             };
     }
 
@@ -388,7 +388,7 @@ mod rt {
     fn pad(cv: conv, s: str, mode: pad_mode) -> str {
         let uwidth;
         alt cv.width {
-          count_implied. { ret s; }
+          count_implied { ret s; }
           count_is(width) {
             // FIXME: Maybe width should be uint
 
@@ -406,15 +406,15 @@ mod rt {
         let might_zero_pad = false;
         let signed = false;
         alt mode {
-          pad_nozero. {
+          pad_nozero {
             // fallthrough
 
           }
-          pad_signed. { might_zero_pad = true; signed = true; }
-          pad_unsigned. { might_zero_pad = true; }
+          pad_signed { might_zero_pad = true; signed = true; }
+          pad_unsigned { might_zero_pad = true; }
         }
         fn have_precision(cv: conv) -> bool {
-            ret alt cv.precision { count_implied. { false } _ { true } };
+            ret alt cv.precision { count_implied { false } _ { true } };
         }
         let zero_padding = false;
         if might_zero_pad && have_flag(cv.flags, flag_left_zero_pad) &&
diff --git a/src/libstd/fs.rs b/src/libstd/fs.rs
index ec848eed58a..cbfca163c18 100644
--- a/src/libstd/fs.rs
+++ b/src/libstd/fs.rs
@@ -433,7 +433,7 @@ fn homedir() -> option<path> {
                 secondary()
             }
         }
-        none. {
+        none {
             secondary()
         }
     };
diff --git a/src/libstd/fun_treemap.rs b/src/libstd/fun_treemap.rs
index 046f565577a..34a393b6a8e 100644
--- a/src/libstd/fun_treemap.rs
+++ b/src/libstd/fun_treemap.rs
@@ -52,7 +52,7 @@ 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) }
+       @empty { node(@k, @v, @empty, @empty) }
        @node(@kk, vv, left, right) {
          if k < kk {
              node(@kk, vv, insert(left, k, v), right)
@@ -70,7 +70,7 @@ Find a value based on the key
 */
 fn find<K, V: copy>(m: treemap<K, V>, k: K) -> option<V> {
     alt *m {
-      empty. { none }
+      empty { none }
       node(@kk, @v, left, right) {
         if k == kk {
             some(v)
@@ -86,7 +86,7 @@ Visit all pairs in the map in order.
 */
 fn traverse<K, V: copy>(m: treemap<K, V>, f: block(K, V)) {
     alt *m {
-      empty. { }
+      empty { }
       node(@k, @v, _, _) {
         // copy v to make aliases work out
         let v1 = v;
diff --git a/src/libstd/getopts.rs b/src/libstd/getopts.rs
index 697ce4035cd..39b6de0e34f 100644
--- a/src/libstd/getopts.rs
+++ b/src/libstd/getopts.rs
@@ -255,16 +255,16 @@ fn getopts(args: [str], opts: [opt]) -> result {
                 let optid;
                 alt find_opt(opts, nm) {
                   some(id) { optid = id; }
-                  none. { ret err(unrecognized_option(name_str(nm))); }
+                  none { ret err(unrecognized_option(name_str(nm))); }
                 }
                 alt opts[optid].hasarg {
-                  no. {
+                  no {
                     if !option::is_none::<str>(i_arg) {
                         ret err(unexpected_argument(name_str(nm)));
                     }
                     vals[optid] += [given];
                   }
-                  maybe. {
+                  maybe {
                     if !option::is_none::<str>(i_arg) {
                         vals[optid] += [val(option::get(i_arg))];
                     } else if name_pos < vec::len::<name>(names) ||
@@ -272,7 +272,7 @@ fn getopts(args: [str], opts: [opt]) -> result {
                         vals[optid] += [given];
                     } else { i += 1u; vals[optid] += [val(args[i])]; }
                   }
-                  yes. {
+                  yes {
                     if !option::is_none::<str>(i_arg) {
                         vals[optid] += [val(option::get::<str>(i_arg))];
                     } else if i + 1u == l {
@@ -306,7 +306,7 @@ fn getopts(args: [str], opts: [opt]) -> result {
 fn opt_vals(m: match, nm: str) -> [optval] {
     ret alt find_opt(m.opts, mkname(nm)) {
           some(id) { m.vals[id] }
-          none. { #error("No option '%s' defined", nm); fail }
+          none { #error("No option '%s' defined", nm); fail }
         };
 }
 
diff --git a/src/libstd/io.rs b/src/libstd/io.rs
index 304e7d9e357..9a0cb10c858 100644
--- a/src/libstd/io.rs
+++ b/src/libstd/io.rs
@@ -160,9 +160,9 @@ impl reader_util for reader {
 
 fn convert_whence(whence: seek_style) -> i32 {
     ret alt whence {
-      seek_set. { 0i32 }
-      seek_cur. { 1i32 }
-      seek_end. { 2i32 }
+      seek_set { 0i32 }
+      seek_cur { 1i32 }
+      seek_end { 2i32 }
     };
 }
 
@@ -347,10 +347,10 @@ fn mk_file_writer(path: str, flags: [fileflag])
         os::libc_constants::O_WRONLY | os::libc_constants::O_BINARY;
     for f: fileflag in flags {
         alt f {
-          append. { fflags |= os::libc_constants::O_APPEND; }
-          create. { fflags |= os::libc_constants::O_CREAT; }
-          truncate. { fflags |= os::libc_constants::O_TRUNC; }
-          none. { }
+          append { fflags |= os::libc_constants::O_APPEND; }
+          create { fflags |= os::libc_constants::O_CREAT; }
+          truncate { fflags |= os::libc_constants::O_TRUNC; }
+          none { }
         }
     }
     let fd = str::as_buf(path, {|pathbuf|
@@ -469,9 +469,9 @@ fn seek_in_buf(offset: int, pos: uint, len: uint, whence: seek_style) ->
     let bpos = pos as int;
     let blen = len as int;
     alt whence {
-      seek_set. { bpos = offset; }
-      seek_cur. { bpos += offset; }
-      seek_end. { bpos = blen + offset; }
+      seek_set { bpos = offset; }
+      seek_cur { bpos += offset; }
+      seek_end { bpos = blen + offset; }
     }
     if bpos < 0 { bpos = 0; } else if bpos > blen { bpos = blen; }
     ret bpos as uint;
@@ -512,7 +512,7 @@ mod fsync {
     // Resource of artifacts that need to fsync on destruction
     resource res<t>(arg: arg<t>) {
         alt arg.opt_level {
-          option::none. { }
+          option::none { }
           option::some(level) {
             // fail hard if not succesful
             assert(arg.fsync_fn(arg.val, level) != -1);
diff --git a/src/libstd/list.rs b/src/libstd/list.rs
index 9e8c8e98674..03aef97857f 100644
--- a/src/libstd/list.rs
+++ b/src/libstd/list.rs
@@ -67,9 +67,9 @@ fn find<T: copy, U: copy>(ls: list<T>, f: block(T) -> option::t<U>)
     while true {
         alt ls {
           cons(hd, tl) {
-            alt f(hd) { none. { ls = *tl; } some(rs) { ret some(rs); } }
+            alt f(hd) { none { ls = *tl; } some(rs) { ret some(rs); } }
           }
-          nil. { break; }
+          nil { break; }
         }
     }
     ret none;
@@ -85,7 +85,7 @@ fn has<T: copy>(ls: list<T>, elt: T) -> bool {
     while true {
         alt ls {
           cons(hd, tl) { if elt == hd { ret true; } else { ls = *tl; } }
-          nil. { break; }
+          nil { break; }
         }
     }
     ret false;
@@ -98,7 +98,7 @@ Returns true if the list is empty.
 */
 pure fn is_empty<T: copy>(ls: list<T>) -> bool {
     alt ls {
-        nil. { true }
+        nil { true }
         _ { false }
     }
 }
@@ -131,7 +131,7 @@ Returns all but the first element of a list
 pure fn tail<T: copy>(ls: list<T>) : is_not_empty(ls) -> list<T> {
     alt ls {
         cons(_, tl) { ret *tl; }
-        nil. { fail "list empty" }
+        nil { fail "list empty" }
     }
 }
 
@@ -143,7 +143,7 @@ Returns the first element of a list
 pure fn head<T: copy>(ls: list<T>) : is_not_empty(ls) -> T {
     alt ls {
         cons(hd, _) { ret hd; }
-        nil. { fail "list empty" }
+        nil { fail "list empty" }
     }
 }
 
@@ -154,7 +154,7 @@ Appends one list to another
 */
 pure fn append<T: copy>(l: list<T>, m: list<T>) -> list<T> {
     alt l {
-      nil. { ret m; }
+      nil { ret m; }
       cons(x, xs) { let rest = append(*xs, m); ret cons(x, @rest); }
     }
 }
@@ -175,11 +175,11 @@ fn iter<T>(l: list<T>, f: block(T)) {
                 f(hd);
                 cur = tl;
               }
-              nil. { break; }
+              nil { break; }
             }
         }
       }
-      nil. {}
+      nil {}
     }
 }
 
diff --git a/src/libstd/map.rs b/src/libstd/map.rs
index f9cc5c66572..9496f2febed 100644
--- a/src/libstd/map.rs
+++ b/src/libstd/map.rs
@@ -137,7 +137,7 @@ mod chained {
         let comp = 1u;   // for logging
         while true {
             alt e0.next {
-              absent. {
+              absent {
                 #debug("search_tbl: absent, comp %u, hash %u, idx %u",
                        comp, h, idx);
                 ret not_found;
@@ -162,7 +162,7 @@ mod chained {
         tbl: t<K,V>, k: K, h: uint) -> search_result<K,V> {
         let idx = h % vec::len(tbl.chains);
         alt tbl.chains[idx] {
-          absent. {
+          absent {
             #debug("search_tbl: absent, comp %u, hash %u, idx %u",
                    0u, h, idx);
             ret not_found;
@@ -183,7 +183,7 @@ mod chained {
     fn insert<K: copy, V: copy>(tbl: t<K,V>, k: K, v: V) -> bool {
         let hash = tbl.hasher(k);
         alt search_tbl(tbl, k, hash) {
-          not_found. {
+          not_found {
             tbl.size += 1u;
             let idx = hash % vec::len(tbl.chains);
             let old_chain = tbl.chains[idx];
@@ -207,7 +207,7 @@ mod chained {
 
     fn get<K: copy, V: copy>(tbl: t<K,V>, k: K) -> core::option::t<V> {
         alt search_tbl(tbl, k, tbl.hasher(k)) {
-          not_found. {
+          not_found {
             ret core::option::none;
           }
 
@@ -223,7 +223,7 @@ mod chained {
 
     fn remove<K: copy, V: copy>(tbl: t<K,V>, k: K) -> core::option::t<V> {
         alt search_tbl(tbl, k, tbl.hasher(k)) {
-          not_found. {
+          not_found {
             ret core::option::none;
           }
 
@@ -250,7 +250,7 @@ mod chained {
         let chain = chain0;
         while true {
             alt chain {
-              absent. { ret; }
+              absent { ret; }
               present(entry) {
                 let next = entry.next;
                 blk(entry); // may modify entry.next!
@@ -569,7 +569,7 @@ mod tests {
             let v = hm.remove(i);
             alt v {
               option::some(u) { assert (u == i * i); }
-              option::none. { fail; }
+              option::none { fail; }
             }
             i += 2u;
         }
diff --git a/src/libstd/rope.rs b/src/libstd/rope.rs
index d18038eed61..013e903f7e0 100644
--- a/src/libstd/rope.rs
+++ b/src/libstd/rope.rs
@@ -156,10 +156,10 @@ Concatenate two ropes
  */
 fn append_rope(left: rope, right: rope) -> rope {
    alt(left) {
-     node::empty. { ret right; }
+     node::empty { ret right; }
      node::content(left_content) {
        alt(right) {
-         node::empty. { ret left; }
+         node::empty { ret left; }
      node::content(right_content) {
            ret node::content(node::concat2(left_content, right_content));
      }
@@ -224,10 +224,10 @@ to rebalance your rope at some point, before using it for other purposes.
  */
 fn bal(rope:rope) -> rope {
     alt(rope) {
-      node::empty. { ret rope }
+      node::empty { ret rope }
       node::content(x) {
         alt(node::bal(x)) {
-          option::none.   { rope }
+          option::none   { rope }
           option::some(y) { node::content(y) }
         }
       }
@@ -255,7 +255,7 @@ valid positions in rope
 fn sub_chars(rope: rope, char_offset: uint, char_len: uint) -> rope {
     if char_len == 0u { ret node::empty; }
     alt(rope) {
-      node::empty. { fail }
+      node::empty { fail }
       node::content(node) {
         if char_len > node::char_len(node) { fail }
         else {
@@ -281,7 +281,7 @@ valid positions in rope
 fn sub_bytes(rope: rope, byte_offset: uint, byte_len: uint) -> rope {
     if byte_len == 0u { ret node::empty; }
     alt(rope) {
-      node::empty. { fail }
+      node::empty { fail }
       node::content(node) {
         if byte_len > node::byte_len(node) { fail }
         else {
@@ -309,9 +309,9 @@ value if `left > right`
 */
 fn cmp(left: rope, right: rope) -> int {
     alt((left, right)) {
-      (node::empty., node::empty.) { ret 0; }
-      (node::empty., _)     { ret -1;}
-      (_, node::empty.)     { ret  1;}
+      (node::empty, node::empty) { ret 0; }
+      (node::empty, _)     { ret -1;}
+      (_, node::empty)     { ret  1;}
       (node::content(a), node::content(b)) {
         ret node::cmp(a, b);
       }
@@ -421,7 +421,7 @@ that is if `it` returned `false` at any point.
  */
 fn loop_chars(rope: rope, it: block(char) -> bool) -> bool {
    alt(rope) {
-      node::empty. { ret true }
+      node::empty { ret true }
       node::content(x) { ret node::loop_chars(x, it) }
    }
 }
@@ -432,7 +432,7 @@ Function: iter_chars
 Loop through a rope, char by char, until the end.
 
 Parameters:
-rope - A rope to traverse. It may be empty.
+rope - A rope to traverse. It may be empty
 it - A block to execute with each consecutive character of the rope.
  */
 fn iter_chars(rope: rope, it: block(char)) {
@@ -457,9 +457,9 @@ use `traverse`.
 
 Parameters:
 
-rope - A rope to traverse. It may be empty.
+rope - A rope to traverse. It may be empty
 it - A block to execute with each consecutive string component of the rope.
-Return `true` to continue, `false` to stop.
+Return `true` to continue, `false` to stop
 
 Returns:
 
@@ -468,7 +468,7 @@ that is if `it` returned `false` at any point.
  */
 fn loop_leaves(rope: rope, it: block(node::leaf) -> bool) -> bool{
    alt(rope) {
-      node::empty. { ret true }
+      node::empty { ret true }
       node::content(x) {ret node::loop_leaves(x, it)}
    }
 }
@@ -477,7 +477,7 @@ mod iterator {
     mod leaf {
         fn start(rope: rope) -> node::leaf_iterator::t {
             alt(rope) {
-              node::empty.     { ret node::leaf_iterator::empty() }
+              node::empty     { ret node::leaf_iterator::empty() }
               node::content(x) { ret node::leaf_iterator::start(x) }
             }
         }
@@ -488,7 +488,7 @@ mod iterator {
     mod char {
         fn start(rope: rope) -> node::char_iterator::t {
             alt(rope) {
-              node::empty.   { ret node::char_iterator::empty() }
+              node::empty   { ret node::char_iterator::empty() }
               node::content(x) { ret node::char_iterator::start(x) }
             }
         }
@@ -513,7 +513,7 @@ finding the leaf in which a character is contained.
 */
 fn height(rope: rope) -> uint {
    alt(rope) {
-      node::empty.    { ret 0u; }
+      node::empty    { ret 0u; }
       node::content(x) { ret node::height(x); }
    }
 }
@@ -529,7 +529,7 @@ fn height(rope: rope) -> uint {
  */
 pure fn char_len(rope: rope) -> uint {
    alt(rope) {
-     node::empty.           { ret 0u; }
+     node::empty           { ret 0u; }
      node::content(x)       { ret node::char_len(x) }
    }
 }
@@ -543,7 +543,7 @@ pure fn char_len(rope: rope) -> uint {
  */
 pure fn byte_len(rope: rope) -> uint {
    alt(rope) {
-     node::empty.           { ret 0u; }
+     node::empty           { ret 0u; }
      node::content(x)       { ret node::byte_len(x) }
    }
 }
@@ -565,7 +565,7 @@ pure fn byte_len(rope: rope) -> uint {
  */
 fn char_at(rope: rope, pos: uint) -> char {
    alt(rope) {
-      node::empty. { fail }
+      node::empty { fail }
       node::content(x) { ret node::char_at(x, pos) }
    }
 }
@@ -730,7 +730,7 @@ mod node {
 
     If the slice is longer than `max_leaf_char_len`, it is logically split
     between as many leaves as necessary. Regardless, the string itself
-    is not copied.
+    is not copied
 
     Parameters:
     byte_start - The byte offset where the slice of `str` starts.
@@ -752,7 +752,7 @@ mod node {
 
     If the slice is longer than `max_leaf_char_len`, it is logically split
     between as many leaves as necessary. Regardless, the string itself
-    is not copied.
+    is not copied
 
     byte_start - The byte offset where the slice of `str` starts.
     byte_len   - The number of bytes from `str` to use.
@@ -897,7 +897,7 @@ mod node {
         let it = leaf_iterator::start(node);
         while true {
             alt(leaf_iterator::next(it)) {
-              option::none. { break; }
+              option::none { break; }
               option::some(x) {
                 //TODO: Replace with memcpy or something similar
                 let local_buf: [u8] = unsafe::reinterpret_cast(*x.content);
@@ -959,7 +959,7 @@ mod node {
         let it = leaf_iterator::start(node);
         while true {
             alt (leaf_iterator::next(it)) {
-              option::none.   { break; }
+              option::none   { break; }
               option::some(x) { forest += [mutable @leaf(x)]; }
             }
         }
@@ -1117,7 +1117,7 @@ mod node {
         let pos = 0u;
         while result == 0 {
             alt((char_iterator::next(ita), char_iterator::next(itb))) {
-              (option::none., option::none.) {
+              (option::none, option::none) {
                 break;
               }
               (option::some(chara), option::some(charb)) {
@@ -1152,7 +1152,7 @@ mod node {
 
     rope - A node to traverse.
     it - A block to execute with each consecutive leaf of the node.
-    Return `true` to continue, `false` to stop.
+    Return `true` to continue, `false` to stop
 
     Returns:
 
@@ -1277,11 +1277,11 @@ mod node {
         fn next(it: t) -> option::t<char> {
             while true {
                 alt(get_current_or_next_leaf(it)) {
-                  option::none. { ret option::none; }
+                  option::none { ret option::none; }
                   option::some(_) {
                     let next_char = get_next_char_in_leaf(it);
                     alt(next_char) {
-                      option::none. {
+                      option::none {
                         cont;
                       }
                       option::some(_) {
@@ -1297,10 +1297,10 @@ mod node {
         fn get_current_or_next_leaf(it: t) -> option::t<leaf> {
             alt(it.leaf) {
               option::some(_) { ret it.leaf }
-              option::none. {
+              option::none {
                 let next = leaf_iterator::next(it.leaf_iterator);
                 alt(next) {
-                  option::none. { ret option::none }
+                  option::none { ret option::none }
                   option::some(_) {
                     it.leaf          = next;
                     it.leaf_byte_pos = 0u;
@@ -1313,7 +1313,7 @@ mod node {
 
         fn get_next_char_in_leaf(it: t) -> option::t<char> {
             alt(it.leaf) {
-              option::none. { ret option::none }
+              option::none { ret option::none }
               option::some(aleaf) {
                 if it.leaf_byte_pos >= aleaf.byte_len {
                     //We are actually past the end of the leaf
@@ -1338,7 +1338,7 @@ mod tests {
     //Utility function, used for sanity check
     fn rope_to_string(r: rope) -> str {
         alt(r) {
-          node::empty. { ret "" }
+          node::empty { ret "" }
           node::content(x) {
             let str = @mutable "";
             fn aux(str: @mutable str, node: @node::node) {
@@ -1392,7 +1392,7 @@ mod tests {
         let pos         = 0u;
         while equal {
             alt(node::char_iterator::next(rope_iter)) {
-              option::none. {
+              option::none {
                 if string_iter < string_len {
                     equal = false;
                 } break; }
@@ -1420,7 +1420,7 @@ mod tests {
         let it  = iterator::char::start(r);
         while true {
             alt(node::char_iterator::next(it)) {
-              option::none. { break; }
+              option::none { break; }
               option::some(_) { len += 1u; }
             }
         }
diff --git a/src/libstd/smallintmap.rs b/src/libstd/smallintmap.rs
index ca618baa554..36c9e1281c2 100644
--- a/src/libstd/smallintmap.rs
+++ b/src/libstd/smallintmap.rs
@@ -38,7 +38,7 @@ fn insert<T: copy>(m: smallintmap<T>, key: uint, val: T) {
 Function: find
 
 Get the value for the specified key. If the key does not exist
-in the map then returns none.
+in the map then returns none
 */
 fn find<T: copy>(m: smallintmap<T>, key: uint) -> option::t<T> {
     if key < vec::len::<option::t<T>>(m.v) { ret m.v[key]; }
@@ -56,7 +56,7 @@ If the key does not exist in the map
 */
 fn get<T: copy>(m: smallintmap<T>, key: uint) -> T {
     alt find(m, key) {
-      none. { #error("smallintmap::get(): key not present"); fail; }
+      none { #error("smallintmap::get(): key not present"); fail; }
       some(v) { ret v; }
     }
 }
@@ -117,7 +117,7 @@ impl <V: copy> of map::map<uint, V> for smallintmap<V> {
               some(elt) {
                 it(idx, elt);
               }
-              none. { }
+              none { }
             }
             idx += 1u;
         }
diff --git a/src/libstd/term.rs b/src/libstd/term.rs
index c1076978cf9..eb9b977455d 100644
--- a/src/libstd/term.rs
+++ b/src/libstd/term.rs
@@ -72,7 +72,7 @@ fn color_supported() -> bool {
             }
             false
           }
-          option::none. { false }
+          option::none { false }
         };
 }
 
diff --git a/src/libstd/test.rs b/src/libstd/test.rs
index 3d58a71f950..fbb87d93e85 100644
--- a/src/libstd/test.rs
+++ b/src/libstd/test.rs
@@ -131,18 +131,18 @@ fn run_tests_console_<T: copy>(opts: test_opts, tests: [test_desc<T>],
           te_wait(test) { st.out.write_str(#fmt["test %s ... ", test.name]); }
           te_result(test, result) {
             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("");
                 st.failures += [test];
               }
-              tr_ignored. {
+              tr_ignored {
                 st.ignored += 1u;
                 write_ignored(st.out, st.use_color);
                 st.out.write_line("");
@@ -260,7 +260,7 @@ fn filter_tests<T: copy>(opts: test_opts,
         let filter_str =
             alt opts.filter {
           option::some(f) { f }
-          option::none. { "" }
+          option::none { "" }
         };
 
         fn filter_fn<T: copy>(test: test_desc<T>, filter_str: str) ->
@@ -315,11 +315,11 @@ fn run_test<T: copy>(test: test_desc<T>,
     ret {test: test,
          wait: fn@() -> test_result {
              alt task::join(test_task) {
-               task::tr_success. {
+               task::tr_success {
                  if test.should_fail { tr_failed }
                  else { tr_ok }
                }
-               task::tr_failure. {
+               task::tr_failure {
                  if test.should_fail { tr_ok }
                  else { tr_failed }
                }
diff --git a/src/libstd/treemap.rs b/src/libstd/treemap.rs
index 2dc539216e0..14e9c30a83c 100644
--- a/src/libstd/treemap.rs
+++ b/src/libstd/treemap.rs
@@ -46,7 +46,7 @@ Insert a value into the map
 */
 fn insert<K: copy, V: copy>(m: treemap<K, V>, k: K, v: V) {
     alt m {
-      @empty. { *m = node(@k, @v, @mutable empty, @mutable empty); }
+      @empty { *m = node(@k, @v, @mutable empty, @mutable empty); }
       @node(@kk, _, _, _) {
 
         // We have to name left and right individually, because
@@ -65,7 +65,7 @@ Find a value based on the key
 */
 fn find<K: copy, V: copy>(m: treemap<K, V>, k: K) -> option<V> {
     alt *m {
-      empty. { none }
+      empty { none }
       node(@kk, @v, _, _) {
         if k == kk {
             some(v)
@@ -85,7 +85,7 @@ Visit all pairs in the map in order.
 */
 fn traverse<K, V>(m: treemap<K, V>, f: block(K, V)) {
     alt *m {
-      empty. { }
+      empty { }
       node(k, v, _, _) {
         let k1 = k, v1 = v;
         alt *m { node(_, _, left, _) { traverse(left, f); } }
diff --git a/src/libstd/ufind.rs b/src/libstd/ufind.rs
index 4f993cbc559..322e3bf40c2 100644
--- a/src/libstd/ufind.rs
+++ b/src/libstd/ufind.rs
@@ -27,7 +27,7 @@ fn grow(ufnd: ufind, n: uint) {
 
 fn find(ufnd: ufind, n: uint) -> uint {
     alt ufnd.nodes[n] {
-      none. { ret n; }
+      none { ret n; }
       some(m) { let m_ = m; be find(ufnd, m_); }
     }
 }