Convert ret to return

src/test/bench/core-std.rs

@@ -33,7 +33,7 @@ fn maybe_run_test(argv: &[~str], name: ~str, test: fn()) {
         run_test = argv.contains(~"all") || argv.contains(name)
     }
 
-    if !run_test { ret }
+    if !run_test { return }
 
     let start = precise_time_s();
     test();

src/test/bench/core-vec-append.rs

@@ -9,7 +9,7 @@ fn collect_raw(num: uint) -> ~[uint] {
     for uint::range(0u, num) |i| {
         vec::push(result, i);
     }
-    ret result;
+    return result;
 }
 
 fn collect_dvec(num: uint) -> ~[mut uint] {
@@ -17,7 +17,7 @@ fn collect_dvec(num: uint) -> ~[mut uint] {
     for uint::range(0u, num) |i| {
         result.push(i);
     }
-    ret dvec::unwrap(result);
+    return dvec::unwrap(result);
 }
 
 fn main(args: ~[~str]) {

src/test/bench/graph500-bfs.rs

@@ -320,7 +320,7 @@ fn validate(edges: ~[(node_id, node_id)],
         }
     };
     
-    if !status { ret status }
+    if !status { return status }
 
     // 2. Each tree edge connects vertices whose BFS levels differ by
     //    exactly one.
@@ -336,7 +336,7 @@ fn validate(edges: ~[(node_id, node_id)],
         }
     };
 
-    if !status { ret status }
+    if !status { return status }
 
     // 3. Every edge in the input list has vertices with levels that
     //    differ by at most one or that both are not in the BFS tree.
@@ -349,7 +349,7 @@ fn validate(edges: ~[(node_id, node_id)],
         abs(level[u] - level[v]) <= 1
     };
 
-    if !status { ret status }    
+    if !status { return status }    
 
     // 4. The BFS tree spans an entire connected component's vertices.
 
@@ -370,7 +370,7 @@ fn validate(edges: ~[(node_id, node_id)],
         }
     };
 
-    if !status { ret status }    
+    if !status { return status }    
 
     // If we get through here, all the tests passed!
     true

src/test/bench/shootout-ackermann.rs

@@ -2,12 +2,12 @@ use std;
 
 fn ack(m: int, n: int) -> int {
     if m == 0 {
-        ret n + 1
+        return n + 1
     } else {
         if n == 0 {
-            ret ack(m - 1, 1);
+            return ack(m - 1, 1);
         } else {
-            ret ack(m - 1, ack(m, n - 1));
+            return ack(m - 1, ack(m, n - 1));
         }
     }
 }

src/test/bench/shootout-binarytrees.rs

@@ -6,20 +6,20 @@ enum tree/& { nil, node(&tree, &tree, int), }
 
 fn item_check(t: &tree) -> int {
     alt *t {
-      nil { ret 0; }
+      nil { return 0; }
       node(left, right, item) {
-        ret item + item_check(left) - item_check(right);
+        return item + item_check(left) - item_check(right);
       }
     }
 }
 
 fn bottom_up_tree(arena: &arena::arena, item: int, depth: int) -> &tree {
     if depth > 0 {
-        ret new(*arena) node(bottom_up_tree(arena, 2 * item - 1, depth - 1),
+        return new(*arena) node(bottom_up_tree(arena, 2 * item - 1, depth - 1),
                              bottom_up_tree(arena, 2 * item, depth - 1),
                              item);
     }
-    ret new(*arena) nil;
+    return new(*arena) nil;
 }
 
 fn main(args: ~[~str]) {

src/test/bench/shootout-chameneos-redux.rs

@@ -35,7 +35,7 @@ fn show_color_list(set: ~[color]) -> ~str {
         out += ~" ";
         out += show_color(col);
     }
-    ret out;
+    return out;
 }
 
 fn show_digit(nn: uint) -> ~str {
@@ -67,7 +67,7 @@ fn show_number(nn: uint) -> ~str {
         out = show_digit(dig) + ~" " + out;
     }
 
-    ret out;
+    return out;
 }
 
 fn transform(aa: color, bb: color) -> color {
@@ -137,7 +137,7 @@ fn rendezvous(nn: uint, set: ~[color]) {
             fn@(ii: uint, col: color) -> comm::chan<option<creature_info>> {
                 // create each creature as a listener with a port, and
                 // give us a channel to talk to each
-                ret do task::spawn_listener |from_rendezvous| {
+                return do task::spawn_listener |from_rendezvous| {
                     creature(ii, col, from_rendezvous, to_rendezvous,
                              to_rendezvous_log);
                 };

src/test/bench/shootout-fannkuchredux.rs

@@ -4,7 +4,7 @@ import int;
 import vec;
 
 fn fannkuch(n: int) -> int {
-    fn perm1init(i: uint) -> int { ret i as int; }
+    fn perm1init(i: uint) -> int { return i as int; }
 
     let perm = vec::to_mut(vec::from_elem(n as uint, 0));
     let perm1 = vec::to_mut(vec::from_fn(n as uint, perm1init));
@@ -44,7 +44,7 @@ fn fannkuch(n: int) -> int {
         while go {
             if r == n {
                 io::println(fmt!{"%d", checksum});
-                ret flips;
+                return flips;
             }
             let p0 = perm1[0];
             i = 0;
@@ -55,7 +55,7 @@ fn fannkuch(n: int) -> int {
         }
         nperm += 1;
     }
-    ret flips;
+    return flips;
 }
 
 fn main(args: ~[~str]) {

src/test/bench/shootout-fasta.rs

@@ -12,7 +12,7 @@ import int;
 import str;
 import io::writer_util;
 
-fn LINE_LENGTH() -> uint { ret 60u; }
+fn LINE_LENGTH() -> uint { return 60u; }
 
 type myrandom = @{mut last: u32};
 
@@ -27,20 +27,20 @@ fn make_cumulative(aa: ~[aminoacids]) -> ~[aminoacids] {
     let mut cp: u32 = 0u32;
     let mut ans: ~[aminoacids] = ~[];
     for aa.each |a| { cp += a.prob; ans += ~[{ch: a.ch, prob: cp}]; }
-    ret ans;
+    return ans;
 }
 
 fn select_random(r: u32, genelist: ~[aminoacids]) -> char {
-    if r < genelist[0].prob { ret genelist[0].ch; }
+    if r < genelist[0].prob { return genelist[0].ch; }
     fn bisect(v: ~[aminoacids], lo: uint, hi: uint, target: u32) -> char {
         if hi > lo + 1u {
             let mid: uint = lo + (hi - lo) / 2u;
             if target < v[mid].prob {
-                ret bisect(v, lo, mid, target);
-            } else { ret bisect(v, mid, hi, target); }
-        } else { ret v[hi].ch; }
+                return bisect(v, lo, mid, target);
+            } else { return bisect(v, mid, hi, target); }
+        } else { return v[hi].ch; }
     }
-    ret bisect(genelist, 0u, vec::len::<aminoacids>(genelist) - 1u, r);
+    return bisect(genelist, 0u, vec::len::<aminoacids>(genelist) - 1u, r);
 }
 
 fn make_random_fasta(wr: io::writer, id: ~str, desc: ~str, genelist: ~[aminoacids], n: int) {
@@ -72,7 +72,7 @@ fn make_repeat_fasta(wr: io::writer, id: ~str, desc: ~str, s: ~str, n: int) unsa
     if str::len(op) > 0u { wr.write_line(op); }
 }
 
-fn acid(ch: char, prob: u32) -> aminoacids { ret {ch: ch, prob: prob}; }
+fn acid(ch: char, prob: u32) -> aminoacids { return {ch: ch, prob: prob}; }
 
 fn main(args: ~[~str]) {
     let args = if os::getenv(~"RUST_BENCH").is_some() {

src/test/bench/shootout-fibo.rs

@@ -2,9 +2,9 @@ use std;
 
 fn fib(n: int) -> int {
     if n < 2 {
-        ret 1;
+        return 1;
     } else {
-        ret fib(n - 1) + fib(n - 2);
+        return fib(n - 1) + fib(n - 2);
     }
 }
 

src/test/bench/shootout-k-nucleotide-pipes.rs

@@ -14,24 +14,24 @@ import pipes::{stream, port, chan};
 // given a map, print a sorted version of it
 fn sort_and_fmt(mm: hashmap<~[u8], uint>, total: uint) -> ~str { 
    fn pct(xx: uint, yy: uint) -> float {
-      ret (xx as float) * 100f / (yy as float);
+      return (xx as float) * 100f / (yy as float);
    }
 
    fn le_by_val<TT: copy, UU: copy>(kv0: (TT,UU), kv1: (TT,UU)) -> bool {
       let (_, v0) = kv0;
       let (_, v1) = kv1;
-      ret v0 >= v1;
+      return v0 >= v1;
    }
 
    fn le_by_key<TT: copy, UU: copy>(kv0: (TT,UU), kv1: (TT,UU)) -> bool {
       let (k0, _) = kv0;
       let (k1, _) = kv1;
-      ret k0 <= k1;
+      return k0 <= k1;
    }
 
    // sort by key, then by value
    fn sortKV<TT: copy, UU: copy>(orig: ~[(TT,UU)]) -> ~[(TT,UU)] {
-      ret sort::merge_sort(le_by_val, sort::merge_sort(le_by_key, orig));
+      return sort::merge_sort(le_by_val, sort::merge_sort(le_by_key, orig));
    }
 
    let mut pairs = ~[];
@@ -39,7 +39,7 @@ fn sort_and_fmt(mm: hashmap<~[u8], uint>, total: uint) -> ~str {
    // map -> [(k,%)]
    mm.each(fn&(key: ~[u8], val: uint) -> bool {
       vec::push(pairs, (key, pct(val, total)));
-      ret true;
+      return true;
    });
 
    let pairs_sorted = sortKV(pairs);
@@ -49,17 +49,17 @@ fn sort_and_fmt(mm: hashmap<~[u8], uint>, total: uint) -> ~str {
    pairs_sorted.each(fn&(kv: (~[u8], float)) -> bool unsafe {
       let (k,v) = kv;
       buffer += (fmt!{"%s %0.3f\n", str::to_upper(str::unsafe::from_bytes(k)), v});
-      ret true;
+      return true;
    });
 
-   ret buffer;
+   return buffer;
 }
 
 // given a map, search for the frequency of a pattern
 fn find(mm: hashmap<~[u8], uint>, key: ~str) -> uint {
    alt mm.find(str::bytes(str::to_lower(key))) {
-      option::none      { ret 0u; }
-      option::some(num) { ret num; }
+      option::none      { return 0u; }
+      option::some(num) { return num; }
    }
 }
 
@@ -85,7 +85,7 @@ fn windows_with_carry(bb: &[u8], nn: uint,
       ii += 1u;
    }
 
-   ret vec::slice(bb, len - (nn - 1u), len); 
+   return vec::slice(bb, len - (nn - 1u), len); 
 }
 
 fn make_sequence_processor(sz: uint, from_parent: pipes::port<~[u8]>,

src/test/bench/shootout-k-nucleotide.rs

@@ -12,24 +12,24 @@ import std::sort;
 // given a map, print a sorted version of it
 fn sort_and_fmt(mm: hashmap<~[u8], uint>, total: uint) -> ~str { 
    fn pct(xx: uint, yy: uint) -> float {
-      ret (xx as float) * 100f / (yy as float);
+      return (xx as float) * 100f / (yy as float);
    }
 
    fn le_by_val<TT: copy, UU: copy>(kv0: (TT,UU), kv1: (TT,UU)) -> bool {
       let (_, v0) = kv0;
       let (_, v1) = kv1;
-      ret v0 >= v1;
+      return v0 >= v1;
    }
 
    fn le_by_key<TT: copy, UU: copy>(kv0: (TT,UU), kv1: (TT,UU)) -> bool {
       let (k0, _) = kv0;
       let (k1, _) = kv1;
-      ret k0 <= k1;
+      return k0 <= k1;
    }
 
    // sort by key, then by value
    fn sortKV<TT: copy, UU: copy>(orig: ~[(TT,UU)]) -> ~[(TT,UU)] {
-      ret sort::merge_sort(le_by_val, sort::merge_sort(le_by_key, orig));
+      return sort::merge_sort(le_by_val, sort::merge_sort(le_by_key, orig));
    }
 
    let mut pairs = ~[];
@@ -37,7 +37,7 @@ fn sort_and_fmt(mm: hashmap<~[u8], uint>, total: uint) -> ~str {
    // map -> [(k,%)]
    mm.each(fn&(key: ~[u8], val: uint) -> bool {
       vec::push(pairs, (key, pct(val, total)));
-      ret true;
+      return true;
    });
 
    let pairs_sorted = sortKV(pairs);
@@ -47,17 +47,17 @@ fn sort_and_fmt(mm: hashmap<~[u8], uint>, total: uint) -> ~str {
    pairs_sorted.each(fn&(kv: (~[u8], float)) -> bool unsafe {
       let (k,v) = kv;
       buffer += (fmt!{"%s %0.3f\n", str::to_upper(str::unsafe::from_bytes(k)), v});
-      ret true;
+      return true;
    });
 
-   ret buffer;
+   return buffer;
 }
 
 // given a map, search for the frequency of a pattern
 fn find(mm: hashmap<~[u8], uint>, key: ~str) -> uint {
    alt mm.find(str::bytes(str::to_lower(key))) {
-      option::none      { ret 0u; }
-      option::some(num) { ret num; }
+      option::none      { return 0u; }
+      option::some(num) { return num; }
    }
 }
 
@@ -83,7 +83,7 @@ fn windows_with_carry(bb: &[u8], nn: uint,
       ii += 1u;
    }
 
-   ret vec::slice(bb, len - (nn - 1u), len); 
+   return vec::slice(bb, len - (nn - 1u), len); 
 }
 
 fn make_sequence_processor(sz: uint, from_parent: comm::port<~[u8]>,
@@ -142,7 +142,7 @@ fn main(args: ~[~str]) {
    let from_child = vec::map (sizes, |_sz| comm::port() );
    let to_parent  = vec::mapi(sizes, |ii, _sz| comm::chan(from_child[ii]) );
    let to_child   = vec::mapi(sizes, fn@(ii: uint, sz: uint) -> comm::chan<~[u8]> {
-       ret do task::spawn_listener |from_parent| {
+       return do task::spawn_listener |from_parent| {
          make_sequence_processor(sz, from_parent, to_parent[ii]);
       };
    });

src/test/bench/shootout-nbody.rs

@@ -52,7 +52,7 @@ mod NBodySystem {
         // side-effecting
         Body::offset_momentum(bodies[0], px, py, pz);
 
-        ret bodies;
+        return bodies;
     }
 
     fn advance(bodies: ~[Body::props], dt: float) {
@@ -122,7 +122,7 @@ mod NBodySystem {
 
             i += 1;
         }
-        ret e;
+        return e;
 
     }
 }
@@ -144,7 +144,7 @@ mod Body {
          mass: float};
 
     fn jupiter() -> Body::props {
-        ret {mut x: 4.84143144246472090e+00,
+        return {mut x: 4.84143144246472090e+00,
              mut y: -1.16032004402742839e+00,
              mut z: -1.03622044471123109e-01,
              mut vx: 1.66007664274403694e-03 * DAYS_PER_YEAR,
@@ -154,7 +154,7 @@ mod Body {
     }
 
     fn saturn() -> Body::props {
-        ret {mut x: 8.34336671824457987e+00,
+        return {mut x: 8.34336671824457987e+00,
              mut y: 4.12479856412430479e+00,
              mut z: -4.03523417114321381e-01,
              mut vx: -2.76742510726862411e-03 * DAYS_PER_YEAR,
@@ -164,7 +164,7 @@ mod Body {
     }
 
     fn uranus() -> Body::props {
-        ret {mut x: 1.28943695621391310e+01,
+        return {mut x: 1.28943695621391310e+01,
              mut y: -1.51111514016986312e+01,
              mut z: -2.23307578892655734e-01,
              mut vx: 2.96460137564761618e-03 * DAYS_PER_YEAR,
@@ -174,7 +174,7 @@ mod Body {
     }
 
     fn neptune() -> Body::props {
-        ret {mut x: 1.53796971148509165e+01,
+        return {mut x: 1.53796971148509165e+01,
              mut y: -2.59193146099879641e+01,
              mut z: 1.79258772950371181e-01,
              mut vx: 2.68067772490389322e-03 * DAYS_PER_YEAR,
@@ -184,7 +184,7 @@ mod Body {
     }
 
     fn sun() -> Body::props {
-        ret {mut x: 0.0,
+        return {mut x: 0.0,
              mut y: 0.0,
              mut z: 0.0,
              mut vx: 0.0,

src/test/bench/shootout-pfib.rs

@@ -41,7 +41,7 @@ fn fib(n: int) -> int {
     let p = port();
     let ch = chan(p);
     let t = task::spawn(|| pfib(ch, n) );
-    ret recv(p);
+    return recv(p);
 }
 
 type config = {stress: bool};
@@ -53,7 +53,7 @@ fn parse_opts(argv: ~[~str]) -> config {
 
 
     alt getopts::getopts(opt_args, opts) {
-      ok(m) { ret {stress: getopts::opt_present(m, ~"stress")} }
+      ok(m) { return {stress: getopts::opt_present(m, ~"stress")} }
       err(_) { fail; }
     }
 }

src/test/bench/shootout-threadring.rs

@@ -24,13 +24,13 @@ fn roundtrip(id: int, p: comm::port<int>, ch: comm::chan<int>) {
         alt comm::recv(p) {
           1 {
             io::println(fmt!{"%d\n", id});
-            ret;
+            return;
           }
           token {
             debug!{"%d %d", id, token};
             comm::send(ch, token - 1);
             if token <= n_threads {
-                ret;
+                return;
             }
           }
         }

src/test/bench/sudoku.rs

@@ -42,7 +42,7 @@ fn read_grid(f: io::reader) -> grid_t {
             g[row][col] = option::get(uint::from_str(comps[2])) as u8;
         }
     }
-    ret grid_ctor(g);
+    return grid_ctor(g);
 }
 
 // solve sudoku grid
@@ -62,12 +62,12 @@ fn solve_grid(g: grid_t) {
             for uint::range(1u, 10u) |i| {
                 if avail.get(i) {
                     g[row][col] = i as u8;
-                    ret true;
+                    return true;
                 }
             };
         }
         g[row][col] = 0u8;
-        ret false;
+        return false;
     }
 
     // find colors available in neighbourhood of (row, col)

src/test/bench/task-perf-word-count-generic.rs

@@ -167,7 +167,7 @@ mod map_reduce {
             vec::push(tasks, spawn_joinable(|| map_task(map, ctrl, i) ));
             vec::push(ctrls, ctrl_server);
         }
-        ret tasks;
+        return tasks;
     }
 
     fn map_task<K1: copy send, K2: const copy send hash_key, V: copy send>(
@@ -226,7 +226,7 @@ mod map_reduce {
                 alt recv(p) {
                   emit_val(v) {
                     // error!{"received %d", v};
-                    ret some(v);
+                    return some(v);
                   }
                   done {
                     // error!{"all done"};
@@ -236,7 +236,7 @@ mod map_reduce {
                   release { ref_count -= 1; }
                 }
             }
-            ret none;
+            return none;
         }
 
         reduce(key, || get(p, ref_count, is_done) );
@@ -303,7 +303,7 @@ fn main(argv: ~[~str]) {
 
         out.write_line(fmt!{"Usage: %s <filename> ...", argv[0]});
 
-        ret;
+        return;
     }
 
     let readers: ~[fn~() -> word_reader]  = if argv.len() >= 2 {
@@ -339,9 +339,9 @@ fn read_word(r: io::reader) -> option<~str> {
 
         if is_word_char(c) {
             w += str::from_char(c);
-        } else { if w != ~"" { ret some(w); } }
+        } else { if w != ~"" { return some(w); } }
     }
-    ret none;
+    return none;
 }
 
 fn is_word_char(c: char) -> bool {

src/test/bench/task-perf-word-count.rs

@@ -68,7 +68,7 @@ mod map_reduce {
                 map_task(ctrl, i); // Task body
             }
         }
-        ret results;
+        return results;
     }
 
     fn map_task(ctrl: chan<ctrl_proto>, input: ~str) {
@@ -114,7 +114,7 @@ mod map_reduce {
                 alt recv(p) {
                   emit_val(v) {
                     // error!{"received %d", v};
-                    ret some(v);
+                    return some(v);
                   }
                   done {
                     // error!{"all done"};
@@ -124,7 +124,7 @@ mod map_reduce {
                   release { state.ref_count -= 1; }
                 }
             }
-            ret none;
+            return none;
         }
 
         reduce(key, || get(p, state) );
@@ -210,9 +210,9 @@ fn read_word(r: io::reader) -> option<~str> {
 
         if is_word_char(c) {
             w += str::from_char(c);
-        } else { if w != ~"" { ret some(w); } }
+        } else { if w != ~"" { return some(w); } }
     }
-    ret none;
+    return none;
 }
 
 fn is_digit(c: char) -> bool {