fix to #1315 + small additions to std::either and result

src/libcore/bool.rs

@@ -123,7 +123,7 @@ Returns:
 
 An u8 whose first bit is set if `if_true(v)` holds
 */
-fn to_bit(v: t) -> u8 { if v { 1u8 } else { 0u8 } }
+pure fn to_bit(v: t) -> u8 { if v { 1u8 } else { 0u8 } }
 
 // Local Variables:
 // mode: rust;

src/libcore/box.rs

@@ -10,7 +10,7 @@ Function: ptr_eq
 
 Determine if two shared boxes point to the same object
 */
-fn ptr_eq<T>(a: @T, b: @T) -> bool {
+pure fn ptr_eq<T>(a: @T, b: @T) -> bool {
     // FIXME: ptr::addr_of
     unsafe {
         let a_ptr: uint = unsafe::reinterpret_cast(a);

src/libcore/char.rs

@@ -122,7 +122,7 @@ pure fn to_digit(c: char) -> u8 unsafe {
  Convert a char to the corresponding digit. Returns none when the
  character is not a valid hexadecimal digit.
 */
-fn maybe_digit(c: char) -> option::t<u8> {
+pure fn maybe_digit(c: char) -> option::t<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)) }
@@ -143,7 +143,7 @@ fn maybe_digit(c: char) -> option::t<u8> {
  Returns:
   -1 if a<b, 0 if a==b, +1 if a>b
 */
-fn cmp(a: char, b: char) -> int {
+pure fn cmp(a: char, b: char) -> int {
     ret  if b > a { -1 }
     else if b < a { 1 }
     else { 0 }

src/libcore/either.rs

@@ -78,6 +78,31 @@ fn partition<copy T, copy U>(eithers: [t<T, U>])
     ret {lefts: lefts, rights: rights};
 }
 
+/*
+Function: flip
+
+Flips between left and right of a given either
+*/
+pure fn flip<copy T, copy U>(eith: t<T, U>) -> t<U, T> {
+    alt eith {
+      right(r) { left(r) }
+      left(l) { right(l) }
+    }
+}
+
+/*
+Function: to_result
+
+Converts either::t to a result::t, making the "right" choice
+an ok result, and the "left" choice a fail
+*/
+pure fn to_result<copy T, copy U>(eith: t<T, U>) -> result::t<U, T> {
+    alt eith {
+      right(r) { result::ok(r) }
+      left(l) { result::err(l) }
+    }
+}
+
 //
 // Local Variables:
 // mode: rust

src/libcore/option.rs

@@ -30,7 +30,7 @@ Failure:
 
 Fails if the value equals `none`.
 */
-fn get<copy T>(opt: t<T>) -> T {
+pure fn get<copy T>(opt: t<T>) -> T {
     alt opt { some(x) { ret x; } none. { fail "option none"; } }
 }
 
@@ -61,7 +61,7 @@ Function: from_maybe
 
 Returns the contained value or a default
 */
-fn from_maybe<T>(def: T, opt: t<T>) -> T {
+pure fn from_maybe<T>(def: T, opt: t<T>) -> T {
     alt opt { some(x) { x } none. { def } }
 }
 

src/libcore/result.rs

@@ -42,7 +42,7 @@ fn get<T, U>(res: t<T, U>) -> T {
       ok(t) { t }
       err(_) {
         // FIXME: Serialize the error value
-        // and include it in the fail message
+        // and include it in the fail message (maybe just note it)
         fail "get called on error result";
       }
     }
@@ -71,7 +71,7 @@ Function: success
 
 Returns true if the result is <ok>
 */
-fn success<T, U>(res: t<T, U>) -> bool {
+pure fn success<T, U>(res: t<T, U>) -> bool {
     alt res {
       ok(_) { true }
       err(_) { false }
@@ -83,10 +83,17 @@ Function: failure
 
 Returns true if the result is <error>
 */
-fn failure<T, U>(res: t<T, U>) -> bool {
+pure fn failure<T, U>(res: t<T, U>) -> bool {
     !success(res)
 }
 
+pure fn to_either<copy T, copy U>(res: t<U, T>) -> either::t<T, U> {
+    alt res {
+      ok(res) { either::right(res) }
+      err(fail_) { either::left(fail_) }
+    }
+}
+
 /*
 Function: chain
 

src/libcore/str.rs

@@ -26,14 +26,14 @@ Function: eq
 
 Bytewise string equality
 */
-fn eq(&&a: str, &&b: str) -> bool { a == b }
+pure fn eq(&&a: str, &&b: str) -> bool { a == b }
 
 /*
 Function: lteq
 
 Bytewise less than or equal
 */
-fn lteq(&&a: str, &&b: str) -> bool { a <= b }
+pure fn lteq(&&a: str, &&b: str) -> bool { a <= b }
 
 /*
 Function: hash
@@ -131,7 +131,7 @@ Function: byte_len
 
 Returns the length in bytes of a string
 */
-fn byte_len(s: str) -> uint unsafe {
+pure fn byte_len(s: str) -> uint unsafe {
     let v: [u8] = unsafe::reinterpret_cast(s);
     let vlen = vec::len(v);
     unsafe::leak(v);
@@ -261,7 +261,7 @@ Function: utf8_char_width
 
 FIXME: What does this function do?
 */
-fn utf8_char_width(b: u8) -> uint {
+pure fn utf8_char_width(b: u8) -> uint {
     let byte: uint = b as uint;
     if byte < 128u { ret 1u; }
     if byte < 192u {

src/libcore/sys.rs

@@ -42,7 +42,7 @@ Function: last_os_error
 Get a string representing the platform-dependent last error
 */
 fn last_os_error() -> str {
-    ret rustrt::last_os_error();
+    rustrt::last_os_error()
 }
 
 /*

src/libcore/vec.rs

@@ -181,7 +181,7 @@ Returns the first element of a vector
 Predicates:
 <is_not_empty> (v)
 */
-fn head<copy T>(v: [const T]) : is_not_empty(v) -> T { ret v[0]; }
+pure fn head<copy T>(v: [const T]) : is_not_empty(v) -> T { ret v[0]; }
 
 /*
 Function: tail
@@ -221,7 +221,7 @@ Returns:
 An option containing the last element of `v` if `v` is not empty, or
 none if `v` is empty.
 */
-fn last<copy T>(v: [const T]) -> option::t<T> {
+pure fn last<copy T>(v: [const T]) -> option::t<T> {
     if len(v) == 0u { ret none; }
     ret some(v[len(v) - 1u]);
 }
@@ -234,7 +234,7 @@ Returns the last element of a non-empty vector `v`
 Predicates:
 <is_not_empty> (v)
 */
-fn last_total<copy T>(v: [const T]) : is_not_empty(v) -> T {
+pure fn last_total<copy T>(v: [const T]) : is_not_empty(v) -> T {
     ret v[len(v) - 1u];
 }
 

src/libstd/bitv.rs

@@ -128,7 +128,7 @@ Function: get
 
 Retreive the value at index `i`
 */
-fn get(v: t, i: uint) -> bool {
+pure fn get(v: t, i: uint) -> bool {
     assert (i < v.nbits);
     let bits = uint_bits;
     let w = i / bits;

src/libstd/list.rs

@@ -112,7 +112,7 @@ Function: tail
 
 Returns all but the first element of a list
 */
-fn tail<copy T>(ls: list<T>) -> list<T> {
+pure fn tail<copy T>(ls: list<T>) -> list<T> {
     alt ls { cons(_, tl) { ret *tl; } nil. { fail "list empty" } }
 }
 
@@ -121,7 +121,7 @@ Function: head
 
 Returns the first element of a list
 */
-fn head<copy T>(ls: list<T>) -> T {
+pure fn head<copy T>(ls: list<T>) -> T {
     alt ls { cons(hd, _) { ret hd; } nil. { fail "list empty" } }
 }
 
@@ -130,7 +130,7 @@ Function: append
 
 Appends one list to another
 */
-fn append<copy T>(l: list<T>, m: list<T>) -> list<T> {
+pure fn append<copy T>(l: list<T>, m: list<T>) -> list<T> {
     alt l {
       nil. { ret m; }
       cons(x, xs) { let rest = append(*xs, m); ret cons(x, @rest); }

src/libstd/posix_fs.rs

@@ -30,6 +30,7 @@ fn list_dir(path: str) -> [str] {
 
 }
 
+// FIXME make pure when str::char_at is
 fn path_is_absolute(p: str) -> bool { ret str::char_at(p, 0u) == '/'; }
 
 const path_sep: char = '/';

src/libstd/rope.rs

@@ -310,7 +310,7 @@ Returns:
 
 A negative value if `left < right`, 0 if eq(left, right) or a positive
 value if `left > right`
- */
+*/
 fn cmp(left: rope, right: rope) -> int {
     alt((left, right)) {
       (node::empty., node::empty.) { ret 0; }

src/libstd/unicode.rs

@@ -151,16 +151,16 @@ mod icu {
     #[link_name = "icuuc"]
     #[abi = "cdecl"]
     native mod libicu {
-        fn u_hasBinaryProperty(c: UChar32, which: UProperty) -> UBool;
+        pure fn u_hasBinaryProperty(c: UChar32, which: UProperty) -> UBool;
     }
 }
 
-fn is_XID_start(c: char) -> bool {
+pure fn is_XID_start(c: char) -> bool {
     ret icu::libicu::u_hasBinaryProperty(c, icu::UCHAR_XID_START)
         == icu::TRUE;
 }
 
-fn is_XID_continue(c: char) -> bool {
+pure fn is_XID_continue(c: char) -> bool {
     ret icu::libicu::u_hasBinaryProperty(c, icu::UCHAR_XID_START)
         == icu::TRUE;
 }