---

yaml
---
r: 126926
b: refs/heads/snap-stage3
c: 39135ec
h: refs/heads/master
v: v3

Author: dotdash

[refs]

@@ -1,7 +1,7 @@
 ---
 refs/heads/master: 7be8f0af0393dcdb077c2f6b1653836fd3fba235
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
-refs/heads/snap-stage3: 6635fe7db4336ef31d2b372e7bfcce01d21853e0
+refs/heads/snap-stage3: 39135ecb18a6c7ef4dbb6e9838e1eda7407ccd2f
 refs/heads/try: 502e4c045236682e9728539dc0d2b3d0b237f55c
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/ndm: f3868061cd7988080c30d6d5bf352a5a5fe2460b

branches/snap-stage3/src/libcollections/bitv.rs

@@ -67,7 +67,6 @@ use core::cmp;
 use core::default::Default;
 use core::fmt;
 use core::iter::Take;
-use core::iter;
 use core::ops::Index;
 use core::slice;
 use core::uint;
@@ -831,20 +830,6 @@ impl Clone for Bitv {
     }
 }
 
-impl PartialOrd for Bitv {
-    #[inline]
-    fn partial_cmp(&self, other: &Bitv) -> Option<Ordering> {
-        iter::order::partial_cmp(self.iter(), other.iter())
-    }
-}
-
-impl Ord for Bitv {
-    #[inline]
-    fn cmp(&self, other: &Bitv) -> Ordering {
-        iter::order::cmp(self.iter(), other.iter())
-    }
-}
-
 impl fmt::Show for Bitv {
     fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
         for bit in self.iter() {
@@ -970,7 +955,7 @@ impl<'a> RandomAccessIterator<bool> for Bits<'a> {
 /// assert!(bv.eq_vec([true, true, false, true,
 ///                    false, false, false, false]));
 /// ```
-#[deriving(Clone, PartialEq, Eq, PartialOrd, Ord)]
+#[deriving(Clone, PartialEq, Eq)]
 pub struct BitvSet(Bitv);
 
 impl Default for BitvSet {
@@ -2204,37 +2189,6 @@ mod tests {
         assert_eq!(a.capacity(), uint::BITS);
     }
 
-    #[test]
-    fn test_bitv_lt() {
-        let mut a = Bitv::with_capacity(5u, false);
-        let mut b = Bitv::with_capacity(5u, false);
-
-        assert!(!(a < b) && !(b < a));
-        b.set(2, true);
-        assert!(a < b);
-        a.set(3, true);
-        assert!(a < b);
-        a.set(2, true);
-        assert!(!(a < b) && b < a);
-        b.set(0, true);
-        assert!(a < b);
-    }
-
-    #[test]
-    fn test_ord() {
-        let mut a = Bitv::with_capacity(5u, false);
-        let mut b = Bitv::with_capacity(5u, false);
-
-        assert!(a <= b && a >= b);
-        a.set(1, true);
-        assert!(a > b && a >= b);
-        assert!(b < a && b <= a);
-        b.set(1, true);
-        b.set(2, true);
-        assert!(b > a && b >= a);
-        assert!(a < b && a <= b);
-    }
-
     #[test]
     fn test_bitv_clone() {
         let mut a = BitvSet::new();

branches/snap-stage3/src/libcollections/hash/mod.rs

@@ -155,36 +155,29 @@ macro_rules! impl_hash_tuple(
         }
     );
 
-    ( $($name:ident)+) => (
-        impl<S: Writer, $($name: Hash<S>),*> Hash<S> for ($($name,)*) {
-            #[allow(uppercase_variables)]
+    ($A:ident $($B:ident)*) => (
+        impl<
+            S: Writer,
+            $A: Hash<S> $(, $B: Hash<S>)*
+        > Hash<S> for ($A, $($B),*) {
             #[inline]
             fn hash(&self, state: &mut S) {
                 match *self {
-                    ($(ref $name,)*) => {
+                    (ref $A, $(ref $B),*) => {
+                        $A.hash(state);
                         $(
-                            $name.hash(state);
+                            $B.hash(state);
                         )*
                     }
                 }
             }
         }
+
+        impl_hash_tuple!($($B)*)
     );
 )
 
-impl_hash_tuple!()
-impl_hash_tuple!(A)
-impl_hash_tuple!(A B)
-impl_hash_tuple!(A B C)
-impl_hash_tuple!(A B C D)
-impl_hash_tuple!(A B C D E)
-impl_hash_tuple!(A B C D E F)
-impl_hash_tuple!(A B C D E F G)
-impl_hash_tuple!(A B C D E F G H)
-impl_hash_tuple!(A B C D E F G H I)
-impl_hash_tuple!(A B C D E F G H I J)
-impl_hash_tuple!(A B C D E F G H I J K)
-impl_hash_tuple!(A B C D E F G H I J K L)
+impl_hash_tuple!(a0 a1 a2 a3 a4 a5 a6 a7)
 
 impl<'a, S: Writer, T: Hash<S>> Hash<S> for &'a [T] {
     #[inline]

branches/snap-stage3/src/libcollections/smallintmap.rs

@@ -373,20 +373,6 @@ impl<V:Clone> SmallIntMap<V> {
     }
 }
 
-impl<V: PartialOrd> PartialOrd for SmallIntMap<V> {
-    #[inline]
-    fn partial_cmp(&self, other: &SmallIntMap<V>) -> Option<Ordering> {
-        iter::order::partial_cmp(self.iter(), other.iter())
-    }
-}
-
-impl<V: Ord> Ord for SmallIntMap<V> {
-    #[inline]
-    fn cmp(&self, other: &SmallIntMap<V>) -> Ordering {
-        iter::order::cmp(self.iter(), other.iter())
-    }
-}
-
 impl<V: fmt::Show> fmt::Show for SmallIntMap<V> {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         try!(write!(f, "{{"));
@@ -784,38 +770,6 @@ mod test_map {
         assert!(a == b);
     }
 
-    #[test]
-    fn test_lt() {
-        let mut a = SmallIntMap::new();
-        let mut b = SmallIntMap::new();
-
-        assert!(!(a < b) && !(b < a));
-        assert!(b.insert(2u, 5i));
-        assert!(a < b);
-        assert!(a.insert(2, 7));
-        assert!(!(a < b) && b < a);
-        assert!(b.insert(1, 0));
-        assert!(b < a);
-        assert!(a.insert(0, 6));
-        assert!(a < b);
-        assert!(a.insert(6, 2));
-        assert!(a < b && !(b < a));
-    }
-
-    #[test]
-    fn test_ord() {
-        let mut a = SmallIntMap::new();
-        let mut b = SmallIntMap::new();
-
-        assert!(a <= b && a >= b);
-        assert!(a.insert(1u, 1i));
-        assert!(a > b && a >= b);
-        assert!(b < a && b <= a);
-        assert!(b.insert(2, 2));
-        assert!(b > a && b >= a);
-        assert!(a < b && a <= b);
-    }
-
     #[test]
     fn test_hash() {
         let mut x = SmallIntMap::new();