about summary refs log tree commit diff
path: root/src/libcore
diff options
context:
space:
mode:
Diffstat (limited to 'src/libcore')
-rw-r--r--src/libcore/bool.rs10
-rw-r--r--src/libcore/char.rs69
-rw-r--r--src/libcore/float.rs88
-rw-r--r--src/libcore/int.rs118
-rw-r--r--src/libcore/option.rs10
-rw-r--r--src/libcore/u64.rs16
-rw-r--r--src/libcore/uint.rs83
7 files changed, 158 insertions, 236 deletions
diff --git a/src/libcore/bool.rs b/src/libcore/bool.rs
index cc4efe54dfc..63a38e7846a 100644
--- a/src/libcore/bool.rs
+++ b/src/libcore/bool.rs
@@ -59,11 +59,11 @@ pure fn is_false(v: t) -> bool { !v }
 #[doc(
   brief = "Parse logic value from `s`"
 )]
-pure fn from_str(s: str) -> t {
+pure fn from_str(s: str) -> option<t> {
     alt check s {
-      "true" { true }
-      "false" { false }
-      _ { fail "'" + s + "' is not a valid boolean string"; }
+      "true" { some(true) }
+      "false" { some(false) }
+      _ { none }
     }
 }
 
@@ -89,7 +89,7 @@ pure fn to_bit(v: t) -> u8 { if v { 1u8 } else { 0u8 } }
 #[test]
 fn test_bool_from_str() {
     all_values { |v|
-        assert v == from_str(bool::to_str(v))
+        assert some(v) == from_str(bool::to_str(v))
     }
 }
 
diff --git a/src/libcore/char.rs b/src/libcore/char.rs
index 6f3466fb00b..123d739ba2c 100644
--- a/src/libcore/char.rs
+++ b/src/libcore/char.rs
@@ -38,7 +38,7 @@ export is_alphabetic,
        is_lowercase, is_uppercase,
        is_whitespace, is_alphanumeric,
        is_ascii, is_digit,
-       to_digit, to_lower, to_upper, maybe_digit, cmp;
+       to_digit, to_lower, to_upper, cmp;
 
 import is_alphabetic = unicode::derived_property::Alphabetic;
 import is_XID_start = unicode::derived_property::XID_Start;
@@ -102,26 +102,18 @@ pure fn is_digit(c: char) -> bool {
            Safety note: This function fails if `c` is not a valid char",
   return = "If `c` is between '0' and '9', the corresponding value \
             between 0 and 9. If `c` is 'a' or 'A', 10. If `c` is \
-            'b' or 'B', 11, etc."
+            'b' or 'B', 11, etc. Returns none if the char does not \
+            refer to a digit in the given radix."
 )]
-pure fn to_digit(c: char) -> u8 unsafe {
-    alt maybe_digit(c) {
-      option::some(x) { x }
-      option::none { fail; }
-    }
-}
-
-#[doc(
-  brief = "Convert a char to the corresponding digit. Returns none when \
-           character is not a valid hexadecimal digit."
-)]
-pure fn maybe_digit(c: char) -> option<u8> {
-    alt c {
-      '0' to '9' { option::some(c as u8 - ('0' as u8)) }
-      'a' to 'z' { option::some(c as u8 + 10u8 - ('a' as u8)) }
-      'A' to 'Z' { option::some(c as u8 + 10u8 - ('A' as u8)) }
-      _ { option::none }
-    }
+pure fn to_digit(c: char, radix: uint) -> option<uint> {
+    let val = alt c {
+      '0' to '9' { c as uint - ('0' as uint) }
+      'a' to 'z' { c as uint + 10u - ('a' as uint) }
+      'A' to 'Z' { c as uint + 10u - ('A' as uint) }
+      _ { ret none; }
+    };
+    if val < radix { some(val) }
+    else { none }
 }
 
 /*
@@ -192,30 +184,19 @@ fn test_is_whitespace() {
 
 #[test]
 fn test_to_digit() {
-    assert (to_digit('0') == 0u8);
-    assert (to_digit('1') == 1u8);
-    assert (to_digit('2') == 2u8);
-    assert (to_digit('9') == 9u8);
-    assert (to_digit('a') == 10u8);
-    assert (to_digit('A') == 10u8);
-    assert (to_digit('b') == 11u8);
-    assert (to_digit('B') == 11u8);
-    assert (to_digit('z') == 35u8);
-    assert (to_digit('Z') == 35u8);
-}
-
-#[test]
-#[should_fail]
-#[ignore(cfg(target_os = "win32"))]
-fn test_to_digit_fail_1() {
-    to_digit(' ');
-}
-
-#[test]
-#[should_fail]
-#[ignore(cfg(target_os = "win32"))]
-fn test_to_digit_fail_2() {
-    to_digit('$');
+    assert to_digit('0', 10u) == some(0u);
+    assert to_digit('1', 2u) == some(1u);
+    assert to_digit('2', 3u) == some(2u);
+    assert to_digit('9', 10u) == some(9u);
+    assert to_digit('a', 16u) == some(10u);
+    assert to_digit('A', 16u) == some(10u);
+    assert to_digit('b', 16u) == some(11u);
+    assert to_digit('B', 16u) == some(11u);
+    assert to_digit('z', 36u) == some(35u);
+    assert to_digit('Z', 36u) == some(35u);
+
+    assert to_digit(' ', 10u) == none;
+    assert to_digit('$', 36u) == none;
 }
 
 #[test]
diff --git a/src/libcore/float.rs b/src/libcore/float.rs
index c4e6e040319..b21d154097f 100644
--- a/src/libcore/float.rs
+++ b/src/libcore/float.rs
@@ -122,28 +122,27 @@ Leading and trailing whitespace are ignored.
 
 Parameters:
 
-num - A string, possibly empty.
+num - A string
 
 Returns:
 
-<NaN> If the string did not represent a valid number.
-Otherwise, the floating-point number represented [num].
+none if the string did not represent a valid number.
+Otherwise, some(n) where n is the floating-point
+number represented by [num].
 */
-fn from_str(num: str) -> float {
-   let num = str::trim(num);
-
+fn from_str(num: str) -> option<float> {
    let pos = 0u;                  //Current byte position in the string.
                                   //Used to walk the string in O(n).
    let len = str::len_bytes(num);  //Length of the string, in bytes.
 
-   if len == 0u { ret 0.; }
+   if len == 0u { ret none; }
    let total = 0f;                //Accumulated result
    let c     = 'z';               //Latest char.
 
    //The string must start with one of the following characters.
    alt str::char_at(num, 0u) {
       '-' | '+' | '0' to '9' | '.' {}
-      _ { ret NaN; }
+      _ { ret none; }
    }
 
    //Determine if first char is '-'/'+'. Set [pos] and [neg] accordingly.
@@ -173,7 +172,7 @@ fn from_str(num: str) -> float {
            break;
          }
          _ {
-           ret NaN;
+           ret none;
          }
        }
    }
@@ -193,7 +192,7 @@ fn from_str(num: str) -> float {
                  break;
              }
              _ {
-                 ret NaN;
+                 ret none;
              }
          }
       }
@@ -238,17 +237,17 @@ fn from_str(num: str) -> float {
              total = total * multiplier;
           }
       } else {
-         ret NaN;
+         ret none;
       }
    }
 
    if(pos < len) {
-     ret NaN;
+     ret none;
    } else {
      if(neg) {
         total *= -1f;
      }
-     ret total;
+     ret some(total);
    }
 }
 
@@ -291,39 +290,36 @@ fn pow_uint_to_uint_as_float(x: uint, pow: uint) -> float {
 
 #[test]
 fn test_from_str() {
-   assert ( from_str("3") == 3. );
-   assert ( from_str("  3  ") == 3. );
-   assert ( from_str("3.14") == 3.14 );
-   assert ( from_str("+3.14") == 3.14 );
-   assert ( from_str("-3.14") == -3.14 );
-   assert ( from_str("2.5E10") == 25000000000. );
-   assert ( from_str("2.5e10") == 25000000000. );
-   assert ( from_str("25000000000.E-10") == 2.5 );
-   assert ( from_str("") == 0. );
-   assert ( from_str(".") == 0. );
-   assert ( from_str(".e1") == 0. );
-   assert ( from_str(".e-1") == 0. );
-   assert ( from_str("5.") == 5. );
-   assert ( from_str(".5") == 0.5 );
-   assert ( from_str("0.5") == 0.5 );
-   assert ( from_str("0.5 ") == 0.5 );
-   assert ( from_str(" 0.5 ") == 0.5 );
-   assert ( from_str(" -.5 ") == -0.5 );
-   assert ( from_str(" -.5 ") == -0.5 );
-   assert ( from_str(" -5 ") == -5. );
-
-   assert ( is_NaN(from_str("x")) );
-   assert ( from_str(" ") == 0. );
-   assert ( from_str("   ") == 0. );
-   assert ( from_str(" 0.5") == 0.5 );
-   assert ( from_str(" 0.5 ") == 0.5 );
-   assert ( from_str(" .1 ") == 0.1 );
-   assert ( is_NaN(from_str("e")) );
-   assert ( is_NaN(from_str("E")) );
-   assert ( is_NaN(from_str("E1")) );
-   assert ( is_NaN(from_str("1e1e1")) );
-   assert ( is_NaN(from_str("1e1.1")) );
-   assert ( is_NaN(from_str("1e1-1")) );
+   assert from_str("3") == some(3.);
+   assert from_str("3") == some(3.);
+   assert from_str("3.14") == some(3.14);
+   assert from_str("+3.14") == some(3.14);
+   assert from_str("-3.14") == some(-3.14);
+   assert from_str("2.5E10") == some(25000000000.);
+   assert from_str("2.5e10") == some(25000000000.);
+   assert from_str("25000000000.E-10") == some(2.5);
+   assert from_str(".") == some(0.);
+   assert from_str(".e1") == some(0.);
+   assert from_str(".e-1") == some(0.);
+   assert from_str("5.") == some(5.);
+   assert from_str(".5") == some(0.5);
+   assert from_str("0.5") == some(0.5);
+   assert from_str("0.5") == some(0.5);
+   assert from_str("0.5") == some(0.5);
+   assert from_str("-.5") == some(-0.5);
+   assert from_str("-.5") == some(-0.5);
+   assert from_str("-5") == some(-5.);
+
+   assert from_str("") == none;
+   assert from_str("x") == none;
+   assert from_str(" ") == none;
+   assert from_str("   ") == none;
+   assert from_str("e") == none;
+   assert from_str("E") == none;
+   assert from_str("E1") == none;
+   assert from_str("1e1e1") == none;
+   assert from_str("1e1.1") == none;
+   assert from_str("1e1-1") == none;
 }
 
 #[test]
diff --git a/src/libcore/int.rs b/src/libcore/int.rs
index 41814b123ad..8567fc7ccc8 100644
--- a/src/libcore/int.rs
+++ b/src/libcore/int.rs
@@ -103,17 +103,10 @@ Parameters:
 
 buf - A byte buffer
 radix - The base of the number
-
-Failure:
-
-buf must not be empty
 */
-fn parse_buf(buf: [u8], radix: uint) -> int {
-    if vec::len::<u8>(buf) == 0u {
-        #error("parse_buf(): buf is empty");
-        fail;
-    }
-    let i = vec::len::<u8>(buf) - 1u;
+fn parse_buf(buf: [u8], radix: uint) -> option<int> {
+    if vec::len(buf) == 0u { ret none; }
+    let i = vec::len(buf) - 1u;
     let start = 0u;
     let power = 1;
 
@@ -123,13 +116,12 @@ fn parse_buf(buf: [u8], radix: uint) -> int {
     }
     let n = 0;
     while true {
-        let digit = char::to_digit(buf[i] as char);
-        if (digit as uint) >= radix {
-            fail;
+        alt char::to_digit(buf[i] as char, radix) {
+          some(d) { n += (d as int) * power; }
+          none { ret none; }
         }
-        n += (digit as int) * power;
         power *= radix as int;
-        if i <= start { ret n; }
+        if i <= start { ret some(n); }
         i -= 1u;
     }
     fail;
@@ -139,12 +131,8 @@ fn parse_buf(buf: [u8], radix: uint) -> int {
 Function: from_str
 
 Parse a string to an int
-
-Failure:
-
-s must not be empty
 */
-fn from_str(s: str) -> int { parse_buf(str::bytes(s), 10u) }
+fn from_str(s: str) -> option<int> { parse_buf(str::bytes(s), 10u) }
 
 /*
 Function: to_str
@@ -198,67 +186,45 @@ fn abs(i: int) -> int {
 
 #[test]
 fn test_from_str() {
-    assert(from_str("0") == 0);
-    assert(from_str("3") == 3);
-    assert(from_str("10") == 10);
-    assert(from_str("123456789") == 123456789);
-    assert(from_str("00100") == 100);
-
-    assert(from_str("-1") == -1);
-    assert(from_str("-3") == -3);
-    assert(from_str("-10") == -10);
-    assert(from_str("-123456789") == -123456789);
-    assert(from_str("-00100") == -100);
-}
-
-#[test]
-#[should_fail]
-#[ignore(cfg(target_os = "win32"))]
-fn test_from_str_fail_1() {
-    from_str(" ");
-}
-
-#[test]
-#[should_fail]
-#[ignore(cfg(target_os = "win32"))]
-fn test_from_str_fail_2() {
-    from_str("x");
+    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) == 123);
-    assert (parse_buf(bytes("1001"), 2u) == 9);
-    assert (parse_buf(bytes("123"), 8u) == 83);
-    assert (parse_buf(bytes("123"), 16u) == 291);
-    assert (parse_buf(bytes("ffff"), 16u) == 65535);
-    assert (parse_buf(bytes("FFFF"), 16u) == 65535);
-    assert (parse_buf(bytes("z"), 36u) == 35);
-    assert (parse_buf(bytes("Z"), 36u) == 35);
-
-    assert (parse_buf(bytes("-123"), 10u) == -123);
-    assert (parse_buf(bytes("-1001"), 2u) == -9);
-    assert (parse_buf(bytes("-123"), 8u) == -83);
-    assert (parse_buf(bytes("-123"), 16u) == -291);
-    assert (parse_buf(bytes("-ffff"), 16u) == -65535);
-    assert (parse_buf(bytes("-FFFF"), 16u) == -65535);
-    assert (parse_buf(bytes("-z"), 36u) == -35);
-    assert (parse_buf(bytes("-Z"), 36u) == -35);
-}
-
-#[test]
-#[should_fail]
-#[ignore(cfg(target_os = "win32"))]
-fn test_parse_buf_fail_1() {
-    parse_buf(str::bytes("Z"), 35u);
-}
-
-#[test]
-#[should_fail]
-#[ignore(cfg(target_os = "win32"))]
-fn test_parse_buf_fail_2() {
-    parse_buf(str::bytes("-9"), 2u);
+    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]
diff --git a/src/libcore/option.rs b/src/libcore/option.rs
index 1ac8b3cc714..84421975425 100644
--- a/src/libcore/option.rs
+++ b/src/libcore/option.rs
@@ -41,6 +41,16 @@ fn map<T, U: copy>(opt: t<T>, f: fn(T) -> U) -> t<U> {
 }
 
 /*
+Function: chain
+
+Update an optional value by optionally running its content through a function
+that returns an option.
+*/
+fn chain<T, U>(opt: t<T>, f: fn(T) -> t<U>) -> t<U> {
+    alt opt { some(x) { f(x) } none { none } }
+}
+
+/*
 Function: is_none
 
 Returns true if the option equals none
diff --git a/src/libcore/u64.rs b/src/libcore/u64.rs
index 4c76e79bd0a..9edf4dd03c7 100644
--- a/src/libcore/u64.rs
+++ b/src/libcore/u64.rs
@@ -117,19 +117,17 @@ Function: from_str
 
 Parse a string as an unsigned integer.
 */
-fn from_str(buf: str, radix: u64) -> u64 {
-    if str::len_bytes(buf) == 0u {
-        #error("parse_buf(): buf is empty");
-        fail;
-    }
+fn from_str(buf: str, radix: u64) -> option<u64> {
+    if str::len_bytes(buf) == 0u { ret none; }
     let i = str::len_bytes(buf) - 1u;
     let power = 1u64, n = 0u64;
     while true {
-        let digit = char::to_digit(buf[i] as char) as u64;
-        if digit >= radix { fail; }
-        n += digit * power;
+        alt char::to_digit(buf[i] as char, radix) {
+          some(d) { n += d as u64 * power; }
+          none { ret none; }
+        }
         power *= radix;
-        if i == 0u { ret n; }
+        if i == 0u { ret some(n); }
         i -= 1u;
     }
     fail;
diff --git a/src/libcore/uint.rs b/src/libcore/uint.rs
index ee2ec7dff40..b5e425d2b1d 100644
--- a/src/libcore/uint.rs
+++ b/src/libcore/uint.rs
@@ -188,22 +188,18 @@ Failure:
 
 buf must not be empty
 */
-fn parse_buf(buf: [u8], radix: uint) -> uint {
-    if vec::len::<u8>(buf) == 0u {
-        #error("parse_buf(): buf is empty");
-        fail;
-    }
-    let i = vec::len::<u8>(buf) - 1u;
+fn parse_buf(buf: [u8], radix: uint) -> option<uint> {
+    if vec::len(buf) == 0u { ret none; }
+    let i = vec::len(buf) - 1u;
     let power = 1u;
     let n = 0u;
     while true {
-        let digit = char::to_digit(buf[i] as char);
-        if (digit as uint) >= radix {
-            fail;
+        alt char::to_digit(buf[i] as char, radix) {
+          some(d) { n += d * power; }
+          none { ret none; }
         }
-        n += (digit as uint) * power;
         power *= radix;
-        if i == 0u { ret n; }
+        if i == 0u { ret some(n); }
         i -= 1u;
     }
     fail;
@@ -213,12 +209,8 @@ fn parse_buf(buf: [u8], radix: uint) -> uint {
 Function: from_str
 
 Parse a string to an int
-
-Failure:
-
-s must not be empty
 */
-fn from_str(s: str) -> uint { parse_buf(str::bytes(s), 10u) }
+fn from_str(s: str) -> option<uint> { parse_buf(str::bytes(s), 10u) }
 
 /*
 Function: to_str
@@ -282,50 +274,29 @@ mod tests {
 
     #[test]
     fn test_from_str() {
-        assert (uint::from_str("0") == 0u);
-        assert (uint::from_str("3") == 3u);
-        assert (uint::from_str("10") == 10u);
-        assert (uint::from_str("123456789") == 123456789u);
-        assert (uint::from_str("00100") == 100u);
+        assert uint::from_str("0") == some(0u);
+        assert uint::from_str("3") == some(3u);
+        assert uint::from_str("10") == some(10u);
+        assert uint::from_str("123456789") == some(123456789u);
+        assert uint::from_str("00100") == some(100u);
+
+        assert uint::from_str("") == none;
+        assert uint::from_str(" ") == none;
+        assert uint::from_str("x") == none;
     }
 
-    #[test]
-    #[should_fail]
-    #[ignore(cfg(target_os = "win32"))]
-    fn test_from_str_fail_1() {
-        uint::from_str(" ");
-    }
-
-    #[test]
-    #[should_fail]
-    #[ignore(cfg(target_os = "win32"))]
-    fn test_from_str_fail_2() {
-        uint::from_str("x");
-    }
-
-    #[test]
+    #[Test]
     fn test_parse_buf() {
         import str::bytes;
-        assert (uint::parse_buf(bytes("123"), 10u) == 123u);
-        assert (uint::parse_buf(bytes("1001"), 2u) == 9u);
-        assert (uint::parse_buf(bytes("123"), 8u) == 83u);
-        assert (uint::parse_buf(bytes("123"), 16u) == 291u);
-        assert (uint::parse_buf(bytes("ffff"), 16u) == 65535u);
-        assert (uint::parse_buf(bytes("z"), 36u) == 35u);
-    }
-
-    #[test]
-    #[should_fail]
-    #[ignore(cfg(target_os = "win32"))]
-    fn test_parse_buf_fail_1() {
-        uint::parse_buf(str::bytes("Z"), 10u);
-    }
-
-    #[test]
-    #[should_fail]
-    #[ignore(cfg(target_os = "win32"))]
-    fn test_parse_buf_fail_2() {
-        uint::parse_buf(str::bytes("_"), 2u);
+        assert uint::parse_buf(bytes("123"), 10u) == some(123u);
+        assert uint::parse_buf(bytes("1001"), 2u) == some(9u);
+        assert uint::parse_buf(bytes("123"), 8u) == some(83u);
+        assert uint::parse_buf(bytes("123"), 16u) == some(291u);
+        assert uint::parse_buf(bytes("ffff"), 16u) == some(65535u);
+        assert uint::parse_buf(bytes("z"), 36u) == some(35u);
+
+        assert uint::parse_buf(str::bytes("Z"), 10u) == none;
+        assert uint::parse_buf(str::bytes("_"), 2u) == none;
     }
 
     #[test]
generated by cgit-pink 1.4.1-3-g733a5 (git 2.37.1) at 2026-09-28 04:11:03 +0000