---

yaml
---
r: 32250
b: refs/heads/dist-snap
c: 9518fc7
h: refs/heads/master
v: v3

Author: pcwalton

[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: 45e46f5fc0e78f5855e8870a6e3eb2a0a7e5ae50
+refs/heads/dist-snap: 9518fc79eaa9979721abcdb9eaa506a1140cf3fb
 refs/tags/release-0.2: c870d2dffb391e14efb05aa27898f1f6333a9596
 refs/tags/release-0.3: b5f0d0f648d9a6153664837026ba1be43d3e2503

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

@@ -42,24 +42,9 @@ impl package : cmp::Ord {
         if self.versions.lt(other.versions) { return true; }
         return false;
     }
-    pure fn le(&&other: package) -> bool {
-        if self.name.lt(other.name) { return true; }
-        if other.name.lt(self.name) { return false; }
-        if self.uuid.lt(other.uuid) { return true; }
-        if other.uuid.lt(self.uuid) { return false; }
-        if self.url.lt(other.url) { return true; }
-        if other.url.lt(self.url) { return false; }
-        if self.method.lt(other.method) { return true; }
-        if other.method.lt(self.method) { return false; }
-        if self.description.lt(other.description) { return true; }
-        if other.description.lt(self.description) { return false; }
-        if self.tags.lt(other.tags) { return true; }
-        if other.tags.lt(self.tags) { return false; }
-        if self.versions.le(other.versions) { return true; }
-        return false;
-    }
-    pure fn ge(&&other: package) -> bool { !other.lt(self) }
-    pure fn gt(&&other: package) -> bool { !other.le(self) }
+    pure fn le(&&other: package) -> bool { !other.lt(self) }
+    pure fn ge(&&other: package) -> bool { !self.lt(other) }
+    pure fn gt(&&other: package) -> bool { other.lt(self)  }
 }
 
 type local_package = {

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

@@ -96,22 +96,9 @@ impl<A: Ord, B: Ord> (A, B): Ord {
             }
         }
     }
-    pure fn le(&&other: (A, B)) -> bool {
-        match self {
-            (self_a, self_b) => {
-                match other {
-                    (other_a, other_b) => {
-                        if self_a.lt(other_a) { return true; }
-                        if other_a.lt(self_a) { return false; }
-                        if self_b.le(other_b) { return true; }
-                        return false;
-                    }
-                }
-            }
-        }
-    }
-    pure fn ge(&&other: (A, B)) -> bool { !other.lt(self) }
-    pure fn gt(&&other: (A, B)) -> bool { !other.ge(self) }
+    pure fn le(&&other: (A, B)) -> bool { !other.lt(self) }
+    pure fn ge(&&other: (A, B)) -> bool { !self.lt(other) }
+    pure fn gt(&&other: (A, B)) -> bool { other.lt(self)  }
 }
 
 impl<A: Eq, B: Eq, C: Eq> (A, B, C): Eq {
@@ -149,24 +136,9 @@ impl<A: Ord, B: Ord, C: Ord> (A, B, C): Ord {
             }
         }
     }
-    pure fn le(&&other: (A, B, C)) -> bool {
-        match self {
-            (self_a, self_b, self_c) => {
-                match other {
-                    (other_a, other_b, other_c) => {
-                        if self_a.lt(other_a) { return true; }
-                        if other_a.lt(self_a) { return false; }
-                        if self_b.lt(other_b) { return true; }
-                        if other_b.lt(self_b) { return false; }
-                        if self_c.le(other_c) { return true; }
-                        return false;
-                    }
-                }
-            }
-        }
-    }
-    pure fn ge(&&other: (A, B, C)) -> bool { !other.lt(self) }
-    pure fn gt(&&other: (A, B, C)) -> bool { !other.ge(self) }
+    pure fn le(&&other: (A, B, C)) -> bool { !other.lt(self) }
+    pure fn ge(&&other: (A, B, C)) -> bool { !self.lt(other) }
+    pure fn gt(&&other: (A, B, C)) -> bool { other.lt(self)  }
 }
 
 #[test]

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

@@ -1443,23 +1443,9 @@ pure fn lt<T: Ord>(a: &[T], b: &[T]) -> bool {
     return a_len < b_len;
 }
 
-pure fn le<T: Ord>(a: &[T], b: &[T]) -> bool {
-    let (a_len, b_len) = (a.len(), b.len());
-    let mut end = uint::min(&a_len, &b_len);
-
-    let mut i = 0;
-    while i < end {
-        let (c_a, c_b) = (&a[i], &b[i]);
-        if *c_a < *c_b { return true; }
-        if *c_a > *c_b { return false; }
-        i += 1;
-    }
-
-    return a_len <= b_len;
-}
-
-pure fn ge<T: Ord>(a: &[T], b: &[T]) -> bool { !lt(b, a) }
-pure fn gt<T: Ord>(a: &[T], b: &[T]) -> bool { !le(b, a) }
+pure fn le<T: Ord>(a: &[T], b: &[T]) -> bool { !lt(b, a) }
+pure fn ge<T: Ord>(a: &[T], b: &[T]) -> bool { !lt(a, b) }
+pure fn gt<T: Ord>(a: &[T], b: &[T]) -> bool { lt(b, a)  }
 
 impl<T: Ord> &[T]: Ord {
     #[inline(always)]