---

yaml
---
r: 65059
b: refs/heads/master
c: d9eec66
h: refs/heads/master
i:
  65057: 839be34
  65055: 6f31798
v: v3

Author: brendanzab

[refs]

@@ -1,5 +1,5 @@
 ---
-refs/heads/master: db453ec0e507382b4ac1bb9eae4654957b8a7e76
+refs/heads/master: d9eec664fd812dda88c349d092f327c9be8a7558
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
 refs/heads/snap-stage3: 18e3db7392d2d0697b7e27d6d986139960144d85
 refs/heads/try: 7b78b52e602bb3ea8174f9b2006bff3315f03ef9

trunk/src/libcore/tuple.rs

@@ -165,7 +165,6 @@ macro_rules! tuple_impls(
                     fn eq(&self, other: &($($T),+)) -> bool {
                         $(*self.$get_ref_fn() == *other.$get_ref_fn())&&+
                     }
-
                     #[inline(always)]
                     fn ne(&self, other: &($($T),+)) -> bool {
                         !(*self == *other)
@@ -176,29 +175,30 @@ macro_rules! tuple_impls(
                 impl<$($T:Ord),+> Ord for ($($T),+) {
                     #[inline(always)]
                     fn lt(&self, other: &($($T),+)) -> bool {
-                        $(*self.$get_ref_fn() < *other.$get_ref_fn())&&+
+                        lexical_lt!($(*self.$get_ref_fn(), *other.$get_ref_fn()),+)
                     }
-
                     #[inline(always)]
-                    fn le(&self, other: &($($T),+)) -> bool {
-                        $(*self.$get_ref_fn() <= *other.$get_ref_fn())&&+
-                    }
-
+                    fn le(&self, other: &($($T),+)) -> bool { !(*other).lt(&(*self)) }
                     #[inline(always)]
-                    fn ge(&self, other: &($($T),+)) -> bool {
-                        $(*self.$get_ref_fn() >= *other.$get_ref_fn())&&+
-                    }
-
+                    fn ge(&self, other: &($($T),+)) -> bool { !(*self).lt(other) }
                     #[inline(always)]
-                    fn gt(&self, other: &($($T),+)) -> bool {
-                        $(*self.$get_ref_fn() > *other.$get_ref_fn())&&+
-                    }
+                    fn gt(&self, other: &($($T),+)) -> bool { (*other).lt(&(*self)) }
                 }
             )+
         }
     )
 )
 
+// Constructs an expression that performs a lexical less-than ordering.
+// The values are interleaved, so the macro invocation for
+// `(a1, a2, a3) < (b1, b2, b3)` would be `lexical_lt!(a1, b1, a2, b2, a3, b3)`
+macro_rules! lexical_lt(
+    ($a:expr, $b:expr, $($rest_a:expr, $rest_b:expr),+) => (
+        if $a < $b { true } else { lexical_lt!($($rest_a, $rest_b),+) }
+    );
+    ($a:expr, $b:expr) => ($a < $b);
+)
+
 tuple_impls!(
     (CloneableTuple2, ImmutableTuple2) {
         (n0, n0_ref) -> A { (ref a,_) => a }