From 04a2887f8791bb080b4e76a55949a7c1954dbb97 Mon Sep 17 00:00:00 2001 From: Tim Chevalier Date: Wed, 18 Jan 2012 22:37:22 -0800 Subject: Remove '.' after nullary tags in patterns Does what it says on the tin. The next commit will remove support for this syntax. --- src/libstd/c_vec.rs | 2 +- src/libstd/ebml.rs | 2 +- src/libstd/extfmt.rs | 36 ++++++++++++------------- src/libstd/fs.rs | 2 +- src/libstd/fun_treemap.rs | 6 ++--- src/libstd/getopts.rs | 10 +++---- src/libstd/io.rs | 22 +++++++-------- src/libstd/list.rs | 18 ++++++------- src/libstd/map.rs | 14 +++++----- src/libstd/rope.rs | 68 +++++++++++++++++++++++------------------------ src/libstd/smallintmap.rs | 6 ++--- src/libstd/term.rs | 2 +- src/libstd/test.rs | 12 ++++----- src/libstd/treemap.rs | 6 ++--- src/libstd/ufind.rs | 2 +- 15 files changed, 104 insertions(+), 104 deletions(-) (limited to 'src/libstd') 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 { resource dtor_res(dtor: option::t) { 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 { 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 { 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(m: treemap, k: K, v: V) -> treemap { @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(m: treemap, k: K) -> option { 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(m: treemap, 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::(i_arg) { ret err(unexpected_argument(name_str(nm))); } vals[optid] += [given]; } - maybe. { + maybe { if !option::is_none::(i_arg) { vals[optid] += [val(option::get(i_arg))]; } else if name_pos < vec::len::(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::(i_arg) { vals[optid] += [val(option::get::(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(arg: arg) { 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(ls: list, f: block(T) -> option::t) 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(ls: list, 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(ls: list) -> bool { alt ls { - nil. { true } + nil { true } _ { false } } } @@ -131,7 +131,7 @@ Returns all but the first element of a list pure fn tail(ls: list) : is_not_empty(ls) -> list { 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(ls: list) : 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(l: list, m: list) -> list { 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(l: list, 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: K, h: uint) -> search_result { 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(tbl: t, 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(tbl: t, k: K) -> core::option::t { alt search_tbl(tbl, k, tbl.hasher(k)) { - not_found. { + not_found { ret core::option::none; } @@ -223,7 +223,7 @@ mod chained { fn remove(tbl: t, k: K) -> core::option::t { 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 { 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 { 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 { 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(m: smallintmap, 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(m: smallintmap, key: uint) -> option::t { if key < vec::len::>(m.v) { ret m.v[key]; } @@ -56,7 +56,7 @@ If the key does not exist in the map */ fn get(m: smallintmap, 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 of map::map for smallintmap { 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_(opts: test_opts, tests: [test_desc], 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(opts: test_opts, let filter_str = alt opts.filter { option::some(f) { f } - option::none. { "" } + option::none { "" } }; fn filter_fn(test: test_desc, filter_str: str) -> @@ -315,11 +315,11 @@ fn run_test(test: test_desc, 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(m: treemap, 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(m: treemap, k: K) -> option { 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(m: treemap, 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_); } } } -- cgit 1.4.1-3-g733a5