Remove res idents from stdlib

src/lib/bitv.rs

@@ -154,11 +154,11 @@ fn to_vec(&t v) -> vec[uint] {
 }
 
 fn to_str(&t v) -> str {
-    auto res = "";
+    auto rs = "";
     for (uint i in bitv::to_vec(v)) {
-        if (i == 1u) { res += "1"; } else { res += "0"; }
+        if (i == 1u) { rs += "1"; } else { rs += "0"; }
     }
-    ret res;
+    ret rs;
 }
 
 

src/lib/extfmt.rs

@@ -95,9 +95,9 @@ fn flush_buf(str buf, &mutable vec[piece] pieces) -> str {
                     i += 1u;
                 } else {
                     buf = flush_buf(buf, pieces);
-                    auto res = parse_conversion(s, i, lim, error);
-                    pieces += [res._0];
-                    i = res._1;
+                    auto rs = parse_conversion(s, i, lim, error);
+                    pieces += [rs._0];
+                    i = rs._1;
                 }
             } else { buf += curr; i += 1u; }
         }
@@ -273,7 +273,7 @@ fn conv_int(&conv cv, int i) -> str {
     }
     fn conv_uint(&conv cv, uint u) -> str {
         auto prec = get_int_precision(cv);
-        auto res =
+        auto rs =
             alt (cv.ty) {
                 case (ty_default) { uint_to_str_prec(u, 10u, prec) }
                 case (ty_hex_lower) { uint_to_str_prec(u, 16u, prec) }
@@ -283,7 +283,7 @@ fn conv_uint(&conv cv, uint u) -> str {
                 case (ty_bits) { uint_to_str_prec(u, 2u, prec) }
                 case (ty_octal) { uint_to_str_prec(u, 8u, prec) }
             };
-        ret pad(cv, res, pad_unsigned);
+        ret pad(cv, rs, pad_unsigned);
     }
     fn conv_bool(&conv cv, bool b) -> str {
         auto s = if (b) { "true" } else { "false" };

src/lib/list.rs

@@ -37,7 +37,7 @@ fn find[T, U](&list[T] ls_, fn(&T) -> option::t[U]  f) -> option::t[U] {
             case (cons(?hd, ?tl)) {
                 alt (f(hd)) {
                     case (none) { ls = *tl; }
-                    case (some(?res)) { ret some(res); }
+                    case (some(?rs)) { ret some(rs); }
                 }
             }
             case (nil) { break; }

src/lib/sha1.rs

@@ -162,15 +162,15 @@ fn circular_shift(u32 bits, u32 word) -> u32 {
     }
     fn mk_result(&sha1state st) -> vec[u8] {
         if (!st.computed) { pad_msg(st); st.computed = true; }
-        let vec[u8] res = [];
+        let vec[u8] rs = [];
         for (u32 hpart in st.h) {
             auto a = hpart >> 24u32 & 0xFFu32 as u8;
             auto b = hpart >> 16u32 & 0xFFu32 as u8;
             auto c = hpart >> 8u32 & 0xFFu32 as u8;
             auto d = hpart & 0xFFu32 as u8;
-            res += [a, b, c, d];
+            rs += [a, b, c, d];
         }
-        ret res;
+        ret rs;
     }
     /*
      * According to the standard, the message must be padded to an even

src/lib/sort.rs

@@ -10,20 +10,20 @@
 
 fn merge_sort[T](lteq[T] le, vec[T] v) -> vec[T] {
     fn merge[T](lteq[T] le, vec[T] a, vec[T] b) -> vec[T] {
-        let vec[T] res = [];
+        let vec[T] rs = [];
         let uint a_len = len[T](a);
         let uint a_ix = 0u;
         let uint b_len = len[T](b);
         let uint b_ix = 0u;
         while (a_ix < a_len && b_ix < b_len) {
             if (le(a.(a_ix), b.(b_ix))) {
-                res += [a.(a_ix)];
+                rs += [a.(a_ix)];
                 a_ix += 1u;
-            } else { res += [b.(b_ix)]; b_ix += 1u; }
+            } else { rs += [b.(b_ix)]; b_ix += 1u; }
         }
-        res += slice[T](a, a_ix, a_len);
-        res += slice[T](b, b_ix, b_len);
-        ret res;
+        rs += slice[T](a, a_ix, a_len);
+        rs += slice[T](b, b_ix, b_len);
+        ret rs;
     }
     let uint v_len = len[T](v);
     if (v_len <= 1u) { ret v; }

src/lib/str.rs

@@ -410,10 +410,10 @@ fn push_byte(&mutable str s, u8 b) {
 }
 
 fn unshift_byte(&mutable str s, u8 b) {
-    auto res = alloc(byte_len(s) + 1u);
-    res += unsafe_from_byte(b);
-    res += s;
-    s = res;
+    auto rs = alloc(byte_len(s) + 1u);
+    rs += unsafe_from_byte(b);
+    rs += s;
+    s = rs;
 }
 
 fn split(str s, u8 sep) -> vec[str] {

src/lib/vec.rs

@@ -172,10 +172,10 @@ fn top[T](&array[T] v) -> T {
 fn push[T](&mutable array[T] v, &T t) { v += [t]; }
 
 fn unshift[T](&mutable array[T] v, &T t) {
-    auto res = alloc[T](len[T](v) + 1u);
-    res += [t];
-    res += v;
-    v = res;
+    auto rs = alloc[T](len[T](v) + 1u);
+    rs += [t];
+    rs += v;
+    v = rs;
 }
 
 fn grow[T](&mutable array[T] v, uint n, &T initval) {
@@ -201,17 +201,17 @@ fn grow_init_fn_set[T](&array[T] v, uint index, fn() -> T  init_fn, &T val) {
 }
 
 fn map[T, U](&fn(&T) -> U  f, &vec[T] v) -> vec[U] {
-    let vec[U] res = alloc[U](len[T](v));
-    for (T ve in v) { res += [f(ve)]; }
-    ret res;
+    let vec[U] rs = alloc[U](len[T](v));
+    for (T ve in v) { rs += [f(ve)]; }
+    ret rs;
 }
 
 fn filter_map[T, U](&fn(&T) -> option::t[U]  f, &vec[T] v) -> vec[U] {
-    let vec[U] res = [];
+    let vec[U] rs = [];
     for (T ve in v) {
-        alt (f(ve)) { case (some(?elt)) { res += [elt]; } case (none) { } }
+        alt (f(ve)) { case (some(?elt)) { rs += [elt]; } case (none) { } }
     }
-    ret res;
+    ret rs;
 }
 
 fn map2[T, U, V](&operator2[T, U, V] f, &vec[T] v0, &vec[U] v1) -> vec[V] {
@@ -288,11 +288,11 @@ fn plus_option[T](&mutable vec[T] v, &option::t[T] o) {
 }
 
 fn cat_options[T](&vec[option::t[T]] v) -> vec[T] {
-    let vec[T] res = [];
+    let vec[T] rs = [];
     for (option::t[T] o in v) {
-        alt (o) { case (none) { } case (some(?t)) { res += [t]; } }
+        alt (o) { case (none) { } case (some(?t)) { rs += [t]; } }
     }
-    ret res;
+    ret rs;
 }
 
 
@@ -322,12 +322,12 @@ fn reverse[T](&vec[mutable T] v) {
 
 // Functional vector reversal. Returns a reversed copy of v.
 fn reversed[T](vec[T] v) -> vec[T] {
-    let vec[T] res = [];
+    let vec[T] rs = [];
     auto i = len[T](v);
-    if (i == 0u) { ret res; } else { i -= 1u; }
-    while (i != 0u) { push[T](res, v.(i)); i -= 1u; }
-    push[T](res, v.(0));
-    ret res;
+    if (i == 0u) { ret rs; } else { i -= 1u; }
+    while (i != 0u) { push[T](rs, v.(i)); i -= 1u; }
+    push[T](rs, v.(0));
+    ret rs;
 }