core: Generalize int-string conversions to all int types

Issue #2239

Author: brson

src/libcore/core.rc

@@ -56,8 +56,8 @@ export priv;
 #[doc = "Operations and constants for `int`"]
 #[path = "int-template"]
 mod int {
-    import inst::{ hash, parse_buf, from_str, to_str, str, pow };
-    export hash, parse_buf, from_str, to_str, str, pow;
+    import inst::{ hash, pow };
+    export hash, pow;
     #[path = "int.rs"]
     mod inst;
 }

src/libcore/int-template.rs

@@ -9,6 +9,7 @@ export is_nonpositive, is_nonnegative;
 export range;
 export compl;
 export abs;
+export parse_buf, from_str, to_str, str;
 
 const min_value: T = -1 as T << (inst::bits - 1 as T);
 const max_value: T = min_value - 1 as T;
@@ -50,3 +51,101 @@ pure fn compl(i: T) -> T {
 pure fn abs(i: T) -> T {
     if is_negative(i) { -i } else { i }
 }
+
+#[doc = "
+Parse a buffer of bytes
+
+# Arguments
+
+* buf - A byte buffer
+* radix - The base of the number
+"]
+fn parse_buf(buf: [u8], radix: uint) -> option<T> {
+    if vec::len(buf) == 0u { ret none; }
+    let mut i = vec::len(buf) - 1u;
+    let mut start = 0u;
+    let mut power = 1 as T;
+
+    if buf[0] == ('-' as u8) {
+        power = -1 as T;
+        start = 1u;
+    }
+    let mut n = 0 as T;
+    loop {
+        alt char::to_digit(buf[i] as char, radix) {
+          some(d) { n += (d as T) * power; }
+          none { ret none; }
+        }
+        power *= radix as T;
+        if i <= start { ret some(n); }
+        i -= 1u;
+    };
+}
+
+#[doc = "Parse a string to an int"]
+fn from_str(s: str) -> option<T> { parse_buf(str::bytes(s), 10u) }
+
+#[doc = "Convert to a string in a given base"]
+fn to_str(n: T, radix: uint) -> str {
+    assert (0u < radix && radix <= 16u);
+    ret if n < 0 as T {
+            "-" + uint::to_str(-n as uint, radix)
+        } else { uint::to_str(n as uint, radix) };
+}
+
+#[doc = "Convert to a string"]
+fn str(i: T) -> str { ret to_str(i, 10u); }
+
+
+#[test]
+fn test_from_str() {
+    assert from_str("0") == some(0 as T);
+    assert from_str("3") == some(3 as T);
+    assert from_str("10") == some(10 as T);
+    assert from_str("123456789") == some(123456789 as T);
+    assert from_str("00100") == some(100 as T);
+
+    assert from_str("-1") == some(-1 as T);
+    assert from_str("-3") == some(-3 as T);
+    assert from_str("-10") == some(-10 as T);
+    assert from_str("-123456789") == some(-123456789 as T);
+    assert from_str("-00100") == some(-100 as T);
+
+    assert from_str(" ") == none;
+    assert from_str("x") == none;
+}
+
+#[test]
+fn test_parse_buf() {
+    import str::bytes;
+    assert parse_buf(bytes("123"), 10u) == some(123 as T);
+    assert parse_buf(bytes("1001"), 2u) == some(9 as T);
+    assert parse_buf(bytes("123"), 8u) == some(83 as T);
+    assert parse_buf(bytes("123"), 16u) == some(291 as T);
+    assert parse_buf(bytes("ffff"), 16u) == some(65535 as T);
+    assert parse_buf(bytes("FFFF"), 16u) == some(65535 as T);
+    assert parse_buf(bytes("z"), 36u) == some(35 as T);
+    assert parse_buf(bytes("Z"), 36u) == some(35 as T);
+
+    assert parse_buf(bytes("-123"), 10u) == some(-123 as T);
+    assert parse_buf(bytes("-1001"), 2u) == some(-9 as T);
+    assert parse_buf(bytes("-123"), 8u) == some(-83 as T);
+    assert parse_buf(bytes("-123"), 16u) == some(-291 as T);
+    assert parse_buf(bytes("-ffff"), 16u) == some(-65535 as T);
+    assert parse_buf(bytes("-FFFF"), 16u) == some(-65535 as T);
+    assert parse_buf(bytes("-z"), 36u) == some(-35 as T);
+    assert parse_buf(bytes("-Z"), 36u) == some(-35 as T);
+
+    assert parse_buf(str::bytes("Z"), 35u) == none;
+    assert parse_buf(str::bytes("-9"), 2u) == none;
+}
+
+#[test]
+fn test_to_str() {
+    import str::eq;
+    assert (eq(to_str(0 as T, 10u), "0"));
+    assert (eq(to_str(1 as T, 10u), "1"));
+    assert (eq(to_str(-1 as T, 10u), "-1"));
+    assert (eq(to_str(127 as T, 16u), "7f"));
+    assert (eq(to_str(100 as T, 10u), "100"));
+}

src/libcore/int-template/int.rs

@@ -9,50 +9,6 @@ const bits: T = 64 as T;
 #[doc = "Produce a uint suitable for use in a hash table"]
 pure fn hash(x: int) -> uint { ret x as uint; }
 
-#[doc = "
-Parse a buffer of bytes
-
-# Arguments
-
-* buf - A byte buffer
-* radix - The base of the number
-"]
-fn parse_buf(buf: [u8], radix: uint) -> option<int> {
-    if vec::len(buf) == 0u { ret none; }
-    let mut i = vec::len(buf) - 1u;
-    let mut start = 0u;
-    let mut power = 1;
-
-    if buf[0] == ('-' as u8) {
-        power = -1;
-        start = 1u;
-    }
-    let mut n = 0;
-    loop {
-        alt char::to_digit(buf[i] as char, radix) {
-          some(d) { n += (d as int) * power; }
-          none { ret none; }
-        }
-        power *= radix as int;
-        if i <= start { ret some(n); }
-        i -= 1u;
-    };
-}
-
-#[doc = "Parse a string to an int"]
-fn from_str(s: str) -> option<int> { parse_buf(str::bytes(s), 10u) }
-
-#[doc = "Convert to a string in a given base"]
-fn to_str(n: int, radix: uint) -> str {
-    assert (0u < radix && radix <= 16u);
-    ret if n < 0 {
-            "-" + uint::to_str(-n as uint, radix)
-        } else { uint::to_str(n as uint, radix) };
-}
-
-#[doc = "Convert to a string"]
-fn str(i: int) -> str { ret to_str(i, 10u); }
-
 #[doc = "Returns `base` raised to the power of `exponent`"]
 fn pow(base: int, exponent: uint) -> int {
     if exponent == 0u { ret 1; } //Not mathemtically true if [base == 0]
@@ -70,60 +26,6 @@ fn pow(base: int, exponent: uint) -> int {
     ret acc;
 }
 
-
-#[test]
-fn test_from_str() {
-    assert from_str("0") == some(0);
-    assert from_str("3") == some(3);
-    assert from_str("10") == some(10);
-    assert from_str("123456789") == some(123456789);
-    assert from_str("00100") == some(100);
-
-    assert from_str("-1") == some(-1);
-    assert from_str("-3") == some(-3);
-    assert from_str("-10") == some(-10);
-    assert from_str("-123456789") == some(-123456789);
-    assert from_str("-00100") == some(-100);
-
-    assert from_str(" ") == none;
-    assert from_str("x") == none;
-}
-
-#[test]
-fn test_parse_buf() {
-    import str::bytes;
-    assert parse_buf(bytes("123"), 10u) == some(123);
-    assert parse_buf(bytes("1001"), 2u) == some(9);
-    assert parse_buf(bytes("123"), 8u) == some(83);
-    assert parse_buf(bytes("123"), 16u) == some(291);
-    assert parse_buf(bytes("ffff"), 16u) == some(65535);
-    assert parse_buf(bytes("FFFF"), 16u) == some(65535);
-    assert parse_buf(bytes("z"), 36u) == some(35);
-    assert parse_buf(bytes("Z"), 36u) == some(35);
-
-    assert parse_buf(bytes("-123"), 10u) == some(-123);
-    assert parse_buf(bytes("-1001"), 2u) == some(-9);
-    assert parse_buf(bytes("-123"), 8u) == some(-83);
-    assert parse_buf(bytes("-123"), 16u) == some(-291);
-    assert parse_buf(bytes("-ffff"), 16u) == some(-65535);
-    assert parse_buf(bytes("-FFFF"), 16u) == some(-65535);
-    assert parse_buf(bytes("-z"), 36u) == some(-35);
-    assert parse_buf(bytes("-Z"), 36u) == some(-35);
-
-    assert parse_buf(str::bytes("Z"), 35u) == none;
-    assert parse_buf(str::bytes("-9"), 2u) == none;
-}
-
-#[test]
-fn test_to_str() {
-    import str::eq;
-    assert (eq(to_str(0, 10u), "0"));
-    assert (eq(to_str(1, 10u), "1"));
-    assert (eq(to_str(-1, 10u), "-1"));
-    assert (eq(to_str(255, 16u), "ff"));
-    assert (eq(to_str(100, 10u), "100"));
-}
-
 #[test]
 fn test_pow() {
     assert (pow(0, 0u) == 1);