---

yaml
---
r: 31588
b: refs/heads/dist-snap
c: 97452c0
h: refs/heads/master
v: v3

Author: nikomatsakis

[refs]

@@ -7,6 +7,6 @@ refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/ndm: f3868061cd7988080c30d6d5bf352a5a5fe2460b
 refs/heads/try2: d0c6ce338884ee21843f4b40bf6bf18d222ce5df
 refs/heads/incoming: d9317a174e434d4c99fc1a37fd7dc0d2f5328d37
-refs/heads/dist-snap: 476ce459bd3b687658e566c75d0fb73281450d67
+refs/heads/dist-snap: 97452c0ca16238a2de5503aca07db26ff9e8ba63
 refs/tags/release-0.2: c870d2dffb391e14efb05aa27898f1f6333a9596
 refs/tags/release-0.3: b5f0d0f648d9a6153664837026ba1be43d3e2503

branches/dist-snap/doc/rust.md

@@ -734,7 +734,7 @@ An example of imports:
 ~~~~
 import foo = core::info;
 import core::float::sin;
-import core::str::{slice, hash};
+import core::str::{slice, to_upper};
 import core::option::some;
 
 fn main() {
@@ -745,8 +745,8 @@ fn main() {
     log(info, some(1.0));
 
     // Equivalent to 'log(core::info,
-    //                    core::str::hash(core::str::slice(~"foo", 0u, 1u)));'
-    log(info, hash(slice(~"foo", 0u, 1u)));
+    //                    core::str::to_upper(core::str::slice(~"foo", 0u, 1u)));'
+    log(info, to_upper(slice(~"foo", 0u, 1u)));
 }
 ~~~~
 

branches/dist-snap/src/cargo/cargo.rs

@@ -1472,7 +1472,7 @@ fn print_pkg(s: source, p: package) {
 fn print_source(s: source) {
     info(s.name + ~" (" + s.url + ~")");
 
-    let pks = sort::merge_sort(|a, b| a < b, copy s.packages);
+    let pks = sort::merge_sort(sys::shape_lt, copy s.packages);
     let l = vec::len(pks);
 
     print(io::with_str_writer(|writer| {

branches/dist-snap/src/libcore/cmp.rs

@@ -8,3 +8,14 @@ trait eq {
     pure fn eq(&&other: self) -> bool;
 }
 
+pure fn lt<T: ord>(v1: &T, v2: &T) -> bool {
+    v1.lt(*v2)
+}
+
+pure fn le<T: ord eq>(v1: &T, v2: &T) -> bool {
+    v1.lt(*v2) || v1.eq(*v2)
+}
+
+pure fn eq<T: eq>(v1: &T, v2: &T) -> bool {
+    v1.eq(*v2)
+}

branches/dist-snap/src/libcore/extfmt.rs

@@ -96,13 +96,13 @@ mod ct {
         while i < lim {
             let size = str::utf8_char_width(s[i]);
             let curr = str::slice(s, i, i+size);
-            if str::eq(curr, ~"%") {
+            if curr == ~"%" {
                 i += 1u;
                 if i >= lim {
                     error(~"unterminated conversion at end of string");
                 }
                 let curr2 = str::slice(s, i, i+1u);
-                if str::eq(curr2, ~"%") {
+                if curr2 == ~"%" {
                     buf += curr2;
                     i += 1u;
                 } else {
@@ -232,27 +232,27 @@ mod ct {
         // FIXME (#2249): Do we really want two signed types here?
         // How important is it to be printf compatible?
         let t =
-            if str::eq(tstr, ~"b") {
+            if tstr == ~"b" {
                 ty_bool
-            } else if str::eq(tstr, ~"s") {
+            } else if tstr == ~"s" {
                 ty_str
-            } else if str::eq(tstr, ~"c") {
+            } else if tstr == ~"c" {
                 ty_char
-            } else if str::eq(tstr, ~"d") || str::eq(tstr, ~"i") {
+            } else if tstr == ~"d" || tstr == ~"i" {
                 ty_int(signed)
-            } else if str::eq(tstr, ~"u") {
+            } else if tstr == ~"u" {
                 ty_int(unsigned)
-            } else if str::eq(tstr, ~"x") {
+            } else if tstr == ~"x" {
                 ty_hex(case_lower)
-            } else if str::eq(tstr, ~"X") {
+            } else if tstr == ~"X" {
                 ty_hex(case_upper)
-            } else if str::eq(tstr, ~"t") {
+            } else if tstr == ~"t" {
                 ty_bits
-            } else if str::eq(tstr, ~"o") {
+            } else if tstr == ~"o" {
                 ty_octal
-            } else if str::eq(tstr, ~"f") {
+            } else if tstr == ~"f" {
                 ty_float
-            } else if str::eq(tstr, ~"?") {
+            } else if tstr == ~"?" {
                 ty_poly
             } else { error(~"unknown type in conversion: " + tstr) };
         return {ty: t, next: i + 1u};

branches/dist-snap/src/libcore/int-template.rs

@@ -19,18 +19,18 @@ const max_value: T = min_value - 1 as T;
 pure fn min(&&x: T, &&y: T) -> T { if x < y { x } else { y } }
 pure fn max(&&x: T, &&y: T) -> T { if x > y { x } else { y } }
 
-pure fn add(&&x: T, &&y: T) -> T { x + y }
-pure fn sub(&&x: T, &&y: T) -> T { x - y }
-pure fn mul(&&x: T, &&y: T) -> T { x * y }
-pure fn div(&&x: T, &&y: T) -> T { x / y }
-pure fn rem(&&x: T, &&y: T) -> T { x % y }
-
-pure fn lt(&&x: T, &&y: T) -> bool { x < y }
-pure fn le(&&x: T, &&y: T) -> bool { x <= y }
-pure fn eq(&&x: T, &&y: T) -> bool { x == y }
-pure fn ne(&&x: T, &&y: T) -> bool { x != y }
-pure fn ge(&&x: T, &&y: T) -> bool { x >= y }
-pure fn gt(&&x: T, &&y: T) -> bool { x > y }
+pure fn add(x: &T, y: &T) -> T { *x + *y }
+pure fn sub(x: &T, y: &T) -> T { *x - *y }
+pure fn mul(x: &T, y: &T) -> T { *x * *y }
+pure fn div(x: &T, y: &T) -> T { *x / *y }
+pure fn rem(x: &T, y: &T) -> T { *x % *y }
+
+pure fn lt(x: &T, y: &T) -> bool { *x < *y }
+pure fn le(x: &T, y: &T) -> bool { *x <= *y }
+pure fn eq(x: &T, y: &T) -> bool { *x == *y }
+pure fn ne(x: &T, y: &T) -> bool { *x != *y }
+pure fn ge(x: &T, y: &T) -> bool { *x >= *y }
+pure fn gt(x: &T, y: &T) -> bool { *x > *y }
 
 pure fn is_positive(x: T) -> bool { x > 0 as T }
 pure fn is_negative(x: T) -> bool { x < 0 as T }
@@ -221,12 +221,11 @@ fn test_parse_buf() {
 
 #[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"));
+    assert (to_str(0 as T, 10u) == ~"0");
+    assert (to_str(1 as T, 10u) == ~"1");
+    assert (to_str(-1 as T, 10u) == ~"-1");
+    assert (to_str(127 as T, 16u) == ~"7f");
+    assert (to_str(100 as T, 10u) == ~"100");
 }
 
 #[test]

branches/dist-snap/src/libcore/int-template/int.rs

@@ -7,7 +7,7 @@ const bits: T = 32 as T;
 const bits: T = 64 as T;
 
 /// Produce a uint suitable for use in a hash table
-pure fn hash(&&x: int) -> uint { return x as uint; }
+pure fn hash(x: &int) -> uint { *x as uint }
 
 /// Returns `base` raised to the power of `exponent`
 fn pow(base: int, exponent: uint) -> int {

branches/dist-snap/src/libcore/io.rs

@@ -811,7 +811,7 @@ mod tests {
         let inp: io::reader = result::get(io::file_reader(tmpfile));
         let frood2: ~str = inp.read_c_str();
         log(debug, frood2);
-        assert (str::eq(frood, frood2));
+        assert frood == frood2;
     }
 
     #[test]

branches/dist-snap/src/libcore/os.rs

@@ -579,7 +579,7 @@ fn list_dir(p: path) -> ~[~str] {
     }
 
     do rustrt::rust_list_files(star(p)).filter |filename| {
-        !str::eq(filename, ~".") && !str::eq(filename, ~"..")
+        filename != ~"." && filename != ~".."
     }
 }
 

branches/dist-snap/src/libcore/str.rs

@@ -637,8 +637,8 @@ pure fn replace(s: &str, from: &str, to: &str) -> ~str {
 Section: Comparing strings
 */
 
-/// Bytewise string equality
-pure fn eq(&&a: ~str, &&b: ~str) -> bool {
+/// Bytewise slice equality
+pure fn eq_slice(a: &str, b: &str) -> bool {
     // FIXME (#2627): This should just be "a == b" but that calls into the
     // shape code.
     let a_len = a.len();
@@ -655,12 +655,17 @@ pure fn eq(&&a: ~str, &&b: ~str) -> bool {
     return true;
 }
 
+/// Bytewise string equality
+pure fn eq(a: &~str, b: &~str) -> bool {
+    eq_slice(*a, *b)
+}
+
 /// Bytewise less than or equal
-pure fn le(&&a: ~str, &&b: ~str) -> bool { a <= b }
+pure fn le(a: &~str, b: &~str) -> bool { *a <= *b }
 
 /// String hash function
-pure fn hash(&&s: ~str) -> uint {
-    let x = do as_bytes(s) |bytes| {
+pure fn hash(s: &~str) -> uint {
+    let x = do as_bytes(*s) |bytes| {
         hash::hash_bytes(bytes)
     };
     return x as uint;
@@ -2070,17 +2075,17 @@ mod tests {
 
     #[test]
     fn test_eq() {
-        assert (eq(~"", ~""));
-        assert (eq(~"foo", ~"foo"));
-        assert (!eq(~"foo", ~"bar"));
+        assert (eq(&~"", &~""));
+        assert (eq(&~"foo", &~"foo"));
+        assert (!eq(&~"foo", &~"bar"));
     }
 
     #[test]
     fn test_le() {
-        assert (le(~"", ~""));
-        assert (le(~"", ~"foo"));
-        assert (le(~"foo", ~"foo"));
-        assert (!eq(~"foo", ~"bar"));
+        assert (le(&~"", &~""));
+        assert (le(&~"", &~"foo"));
+        assert (le(&~"foo", &~"foo"));
+        assert (!eq(&~"foo", &~"bar"));
     }
 
     #[test]
@@ -2220,7 +2225,7 @@ mod tests {
     fn test_split_str() {
         fn t(s: ~str, sep: &a/str, i: int, k: ~str) {
             let v = split_str(s, sep);
-            assert eq(v[i], k);
+            assert v[i] == k;
         }
 
         t(~"--1233345--", ~"12345", 0, ~"--1233345--");
@@ -2348,7 +2353,7 @@ mod tests {
     #[test]
     fn test_substr() {
         fn t(a: ~str, b: ~str, start: int) {
-            assert (eq(substr(a, start as uint, len(b)), b));
+            assert substr(a, start as uint, len(b)) == b;
         }
         t(~"hello", ~"llo", 2);
         t(~"hello", ~"el", 1);
@@ -2357,7 +2362,7 @@ mod tests {
 
     #[test]
     fn test_concat() {
-        fn t(v: ~[~str], s: ~str) { assert (eq(concat(v), s)); }
+        fn t(v: ~[~str], s: ~str) { assert concat(v) == s; }
         t(~[~"you", ~"know", ~"I'm", ~"no", ~"good"], ~"youknowI'mnogood");
         let v: ~[~str] = ~[];
         t(v, ~"");
@@ -2367,7 +2372,7 @@ mod tests {
     #[test]
     fn test_connect() {
         fn t(v: ~[~str], sep: ~str, s: ~str) {
-            assert (eq(connect(v, sep), s));
+            assert connect(v, sep) == s;
         }
         t(~[~"you", ~"know", ~"I'm", ~"no", ~"good"],
           ~" ", ~"you know I'm no good");
@@ -2385,7 +2390,7 @@ mod tests {
         let input = ~"abcDEF" + unicode + ~"xyz:.;";
         let expected = ~"ABCDEF" + unicode + ~"XYZ:.;";
         let actual = to_upper(input);
-        assert (eq(expected, actual));
+        assert expected == actual;
     }
 
     #[test]
@@ -2398,9 +2403,9 @@ mod tests {
     #[test]
     fn test_unsafe_slice() {
         unsafe {
-            assert (eq(~"ab", unsafe::slice_bytes(~"abc", 0u, 2u)));
-            assert (eq(~"bc", unsafe::slice_bytes(~"abc", 1u, 3u)));
-            assert (eq(~"", unsafe::slice_bytes(~"abc", 1u, 1u)));
+            assert ~"ab" == unsafe::slice_bytes(~"abc", 0u, 2u);
+            assert ~"bc" == unsafe::slice_bytes(~"abc", 1u, 3u);
+            assert ~"" == unsafe::slice_bytes(~"abc", 1u, 1u);
             fn a_million_letter_a() -> ~str {
                 let mut i = 0;
                 let mut rs = ~"";
@@ -2413,9 +2418,8 @@ mod tests {
                 while i < 100000 { push_str(rs, ~"aaaaa"); i += 1; }
                 return rs;
             }
-            assert eq(half_a_million_letter_a(),
-                      unsafe::slice_bytes(a_million_letter_a(),
-                                          0u, 500000u));
+            assert half_a_million_letter_a() ==
+                unsafe::slice_bytes(a_million_letter_a(), 0u, 500000u);
         }
     }
 
@@ -2501,10 +2505,10 @@ mod tests {
 
     #[test]
     fn test_slice() {
-        assert (eq(~"ab", slice(~"abc", 0u, 2u)));
-        assert (eq(~"bc", slice(~"abc", 1u, 3u)));
-        assert (eq(~"", slice(~"abc", 1u, 1u)));
-        assert (eq(~"\u65e5", slice(~"\u65e5\u672c", 0u, 3u)));
+        assert ~"ab" == slice(~"abc", 0u, 2u);
+        assert ~"bc" == slice(~"abc", 1u, 3u);
+        assert ~"" == slice(~"abc", 1u, 1u);
+        assert ~"\u65e5" == slice(~"\u65e5\u672c", 0u, 3u);
 
         let data = ~"ประเทศไทย中华";
         assert ~"ป" == slice(data, 0u, 3u);
@@ -2524,8 +2528,8 @@ mod tests {
             while i < 100000 { push_str(rs, ~"华华华华华"); i += 1; }
             return rs;
         }
-        assert eq(half_a_million_letter_X(),
-                  slice(a_million_letter_X(), 0u, 3u * 500000u));
+        assert half_a_million_letter_X() ==
+            slice(a_million_letter_X(), 0u, 3u * 500000u);
     }
 
     #[test]
@@ -2709,7 +2713,7 @@ mod tests {
             let s = ~"hello";
             let sb = as_buf(s, |b, _l| b);
             let s_cstr = unsafe::from_buf(sb);
-            assert (eq(s_cstr, s));
+            assert s_cstr == s;
         }
     }
 

branches/dist-snap/src/libcore/sys.rs

@@ -8,6 +8,7 @@ export pref_align_of;
 export refcount;
 export log_str;
 export lock_and_signal, condition, methods;
+export shape_eq, shape_lt, shape_le;
 
 import task::atomically;
 
@@ -39,6 +40,20 @@ extern mod rusti {
     fn min_align_of<T>() -> uint;
 }
 
+/// Compares contents of two pointers using the default method.
+/// Equivalent to `*x1 == *x2`.  Useful for hashtables.
+pure fn shape_eq<T>(x1: &T, x2: &T) -> bool {
+    *x1 == *x2
+}
+
+pure fn shape_lt<T>(x1: &T, x2: &T) -> bool {
+    *x1 < *x2
+}
+
+pure fn shape_le<T>(x1: &T, x2: &T) -> bool {
+    *x1 < *x2
+}
+
 /**
  * Returns a pointer to a type descriptor.
  *