mirror of https://github.com/rust-lang/rust.git
Remove res idents from stdlib
This commit is contained in:
parent
3d7fdb509a
commit
d507d5fe91
|
@ -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;
|
||||
}
|
||||
|
||||
|
||||
|
|
|
@ -95,9 +95,9 @@ mod ct {
|
|||
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 @@ mod rt {
|
|||
}
|
||||
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 @@ mod rt {
|
|||
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" };
|
||||
|
|
|
@ -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; }
|
||||
|
|
|
@ -162,15 +162,15 @@ fn mk_sha1() -> sha1 {
|
|||
}
|
||||
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
|
||||
|
|
|
@ -10,20 +10,20 @@ type lteq[T] = fn(&T, &T) -> bool ;
|
|||
|
||||
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; }
|
||||
|
|
|
@ -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] {
|
||||
|
|
|
@ -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;
|
||||
}
|
||||
|
||||
|
||||
|
|
Loading…
Reference in New Issue