diff --git a/src/libcore/prelude.rs b/src/libcore/prelude.rs
index 77371b6336848..684c4c7a27178 100644
--- a/src/libcore/prelude.rs
+++ b/src/libcore/prelude.rs
@@ -52,8 +52,12 @@ pub use from_str::{FromStr};
 pub use to_bytes::IterBytes;
 pub use to_str::{ToStr, ToStrConsume};
 pub use tuple::{CopyableTuple, ImmutableTuple, ExtendedTupleOps};
-pub use tuple::{Tuple2, Tuple3, Tuple4, Tuple5, Tuple6, Tuple7, Tuple8, Tuple9};
-pub use tuple::{Tuple10, Tuple11, Tuple12};
+pub use tuple::{CloneableTuple2, CloneableTuple3, CloneableTuple4, CloneableTuple5};
+pub use tuple::{CloneableTuple6, CloneableTuple7, CloneableTuple8, CloneableTuple9};
+pub use tuple::{CloneableTuple10, CloneableTuple11, CloneableTuple12};
+pub use tuple::{ImmutableTuple2, ImmutableTuple3, ImmutableTuple4, ImmutableTuple5};
+pub use tuple::{ImmutableTuple6, ImmutableTuple7, ImmutableTuple8, ImmutableTuple9};
+pub use tuple::{ImmutableTuple10, ImmutableTuple11, ImmutableTuple12};
 pub use vec::{CopyableVector, ImmutableVector};
 pub use vec::{ImmutableEqVector, ImmutableCopyableVector};
 pub use vec::{OwnedVector, OwnedCopyableVector, MutableVector};
diff --git a/src/libcore/tuple.rs b/src/libcore/tuple.rs
index c872839146ab0..639df89a3776f 100644
--- a/src/libcore/tuple.rs
+++ b/src/libcore/tuple.rs
@@ -10,13 +10,10 @@
 
 //! Operations on tuples
 
-use clone::Clone;
 use kinds::Copy;
 use vec;
 
-#[cfg(not(test))] use cmp::{Eq, Ord};
-
-pub use self::getters::*;
+pub use self::inner::*;
 
 pub trait CopyableTuple<T, U> {
     fn first(&self) -> T;
@@ -25,36 +22,28 @@ pub trait CopyableTuple<T, U> {
 }
 
 impl<T:Copy,U:Copy> CopyableTuple<T, U> for (T, U) {
-
     /// Return the first element of self
     #[inline(always)]
     fn first(&self) -> T {
-        let (t, _) = *self;
-        return t;
+        match *self {
+            (t, _) => t,
+        }
     }
 
     /// Return the second element of self
     #[inline(always)]
     fn second(&self) -> U {
-        let (_, u) = *self;
-        return u;
+        match *self {
+            (_, u) => u,
+        }
     }
 
     /// Return the results of swapping the two elements of self
     #[inline(always)]
     fn swap(&self) -> (U, T) {
-        let (t, u) = *self;
-        return (u, t);
-    }
-
-}
-
-impl<T:Clone,U:Clone> Clone for (T, U) {
-    fn clone(&self) -> (T, U) {
-        let (a, b) = match *self {
-            (ref a, ref b) => (a, b)
-        };
-        (a.clone(), b.clone())
+        match *self {
+            (t, u) => (u, t),
+        }
     }
 }
 
@@ -104,7 +93,6 @@ impl<'self,A:Copy,B:Copy> ExtendedTupleOps<A,B> for (&'self [A], &'self [B]) {
 }
 
 impl<A:Copy,B:Copy> ExtendedTupleOps<A,B> for (~[A], ~[B]) {
-
     #[inline(always)]
     fn zip(&self) -> ~[(A, B)] {
         match *self {
@@ -124,305 +112,328 @@ impl<A:Copy,B:Copy> ExtendedTupleOps<A,B> for (~[A], ~[B]) {
     }
 }
 
-#[cfg(not(test))]
-impl<A:Eq> Eq for (A,) {
-    #[inline(always)]
-    fn eq(&self, other: &(A,)) -> bool {
-        match (*self) {
-            (ref self_a,) => match other {
-                &(ref other_a,) => {
-                    (*self_a).eq(other_a)
-                }
-            }
+// macro for implementing n-ary tuple functions and operations
+
+macro_rules! tuple_impls {
+    ($(
+        ($cloneable_trait:ident, $immutable_trait:ident) {
+            $(($get_fn:ident, $get_ref_fn:ident) -> $T:ident {
+                $get_pattern:pat => $ret:expr
+            })+
         }
-    }
-    #[inline(always)]
-    fn ne(&self, other: &(A,)) -> bool { !(*self).eq(other) }
-}
+    )+) => {
+        pub mod inner {
+            use clone::Clone;
+            #[cfg(not(test))] use cmp::*;
+
+            $(
+                pub trait $cloneable_trait<$($T),+> {
+                    $(fn $get_fn(&self) -> $T;)+
+                }
 
-#[cfg(not(test))]
-impl<A:Ord> Ord for (A,) {
-    #[inline(always)]
-    fn lt(&self, other: &(A,)) -> bool {
-        match (*self) {
-            (ref self_a,) => {
-                match (*other) {
-                    (ref other_a,) => {
-                        if (*self_a).lt(other_a) { return true; }
-                        return false;
+                impl<$($T:Clone),+> $cloneable_trait<$($T),+> for ($($T),+) {
+                    $(
+                        #[inline(always)]
+                        fn $get_fn(&self) -> $T {
+                            self.$get_ref_fn().clone()
+                        }
+                    )+
+                }
+
+                pub trait $immutable_trait<$($T),+> {
+                    $(fn $get_ref_fn<'a>(&'a self) -> &'a $T;)+
+                }
+
+                impl<$($T),+> $immutable_trait<$($T),+> for ($($T),+) {
+                    $(
+                        #[inline(always)]
+                        fn $get_ref_fn<'a>(&'a self) -> &'a $T {
+                            match *self { $get_pattern => $ret }
+                        }
+                    )+
+                }
+
+                impl<$($T:Clone),+> Clone for ($($T),+) {
+                    fn clone(&self) -> ($($T),+) {
+                        ($(self.$get_ref_fn().clone()),+)
                     }
                 }
-            }
-        }
-    }
-    #[inline(always)]
-    fn le(&self, other: &(A,)) -> bool { !other.lt(&(*self)) }
-    #[inline(always)]
-    fn ge(&self, other: &(A,)) -> bool { !self.lt(other) }
-    #[inline(always)]
-    fn gt(&self, other: &(A,)) -> bool { other.lt(&(*self))  }
-}
 
-#[cfg(not(test))]
-impl<A:Eq,B:Eq> Eq for (A, B) {
-    #[inline(always)]
-    fn eq(&self, other: &(A, B)) -> bool {
-        match (*self) {
-            (ref self_a, ref self_b) => match other {
-                &(ref other_a, ref other_b) => {
-                    (*self_a).eq(other_a) && (*self_b).eq(other_b)
+                #[cfg(not(test))]
+                impl<$($T:Eq),+> Eq for ($($T),+) {
+                    #[inline(always)]
+                    fn eq(&self, other: &($($T),+)) -> bool {
+                        $(*self.$get_ref_fn() == *other.$get_ref_fn())&&+
+                    }
+                    #[inline(always)]
+                    fn ne(&self, other: &($($T),+)) -> bool {
+                        !(*self == *other)
+                    }
                 }
-            }
-        }
-    }
-    #[inline(always)]
-    fn ne(&self, other: &(A, B)) -> bool { !(*self).eq(other) }
-}
 
-#[cfg(not(test))]
-impl<A:Ord,B:Ord> Ord for (A, B) {
-    #[inline(always)]
-    fn lt(&self, other: &(A, B)) -> bool {
-        match (*self) {
-            (ref self_a, ref self_b) => {
-                match (*other) {
-                    (ref other_a, ref other_b) => {
-                        if (*self_a).lt(other_a) { return true; }
-                        if (*other_a).lt(self_a) { return false; }
-                        if (*self_b).lt(other_b) { return true; }
-                        return false;
+                #[cfg(not(test))]
+                impl<$($T:TotalEq),+> TotalEq for ($($T),+) {
+                    #[inline(always)]
+                    fn equals(&self, other: &($($T),+)) -> bool {
+                        $(self.$get_ref_fn().equals(other.$get_ref_fn()))&&+
                     }
                 }
-            }
-        }
-    }
-    #[inline(always)]
-    fn le(&self, other: &(A, B)) -> bool { !(*other).lt(&(*self)) }
-    #[inline(always)]
-    fn ge(&self, other: &(A, B)) -> bool { !(*self).lt(other) }
-    #[inline(always)]
-    fn gt(&self, other: &(A, B)) -> bool { (*other).lt(&(*self))  }
-}
 
-#[cfg(not(test))]
-impl<A:Eq,B:Eq,C:Eq> Eq for (A, B, C) {
-    #[inline(always)]
-    fn eq(&self, other: &(A, B, C)) -> bool {
-        match (*self) {
-            (ref self_a, ref self_b, ref self_c) => match other {
-                &(ref other_a, ref other_b, ref other_c) => {
-                    (*self_a).eq(other_a) && (*self_b).eq(other_b)
-                        && (*self_c).eq(other_c)
+                #[cfg(not(test))]
+                impl<$($T:Ord),+> Ord for ($($T),+) {
+                    #[inline(always)]
+                    fn lt(&self, other: &($($T),+)) -> bool {
+                        lexical_lt!($(self.$get_ref_fn(), other.$get_ref_fn()),+)
+                    }
+                    #[inline(always)]
+                    fn le(&self, other: &($($T),+)) -> bool { !(*other).lt(&(*self)) }
+                    #[inline(always)]
+                    fn ge(&self, other: &($($T),+)) -> bool { !(*self).lt(other) }
+                    #[inline(always)]
+                    fn gt(&self, other: &($($T),+)) -> bool { (*other).lt(&(*self)) }
                 }
-            }
-        }
-    }
-    #[inline(always)]
-    fn ne(&self, other: &(A, B, C)) -> bool { !(*self).eq(other) }
-}
 
-#[cfg(not(test))]
-impl<A:Ord,B:Ord,C:Ord> Ord for (A, B, C) {
-    #[inline(always)]
-    fn lt(&self, other: &(A, B, C)) -> bool {
-        match (*self) {
-            (ref self_a, ref self_b, ref self_c) => {
-                match (*other) {
-                    (ref other_a, ref other_b, ref 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).lt(other_c) { return true; }
-                        return false;
+                #[cfg(not(test))]
+                impl<$($T:TotalOrd),+> TotalOrd for ($($T),+) {
+                    #[inline]
+                    fn cmp(&self, other: &($($T),+)) -> Ordering {
+                        lexical_cmp!($(self.$get_ref_fn(), other.$get_ref_fn()),+)
                     }
                 }
-            }
+            )+
         }
     }
-    #[inline(always)]
-    fn le(&self, other: &(A, B, C)) -> bool { !(*other).lt(&(*self)) }
-    #[inline(always)]
-    fn ge(&self, other: &(A, B, C)) -> bool { !(*self).lt(other) }
-    #[inline(always)]
-    fn gt(&self, other: &(A, B, C)) -> bool { (*other).lt(&(*self))  }
 }
 
-// Tuple element getters
+// 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)` (and similarly for `lexical_cmp`)
+macro_rules! lexical_lt {
+    ($a:expr, $b:expr, $($rest_a:expr, $rest_b:expr),+) => {
+        if *$a < *$b { true }
+        else if !(*$b < *$a) { lexical_lt!($($rest_a, $rest_b),+) }
+        else { false }
+    };
+    ($a:expr, $b:expr) => { *$a < *$b };
+}
 
-macro_rules! tuple_getters(
-    ($(
-        $name:ident {
-            $(fn $method:ident -> $T:ident { $accessor:pat => $t:expr })+
+macro_rules! lexical_cmp {
+    ($a:expr, $b:expr, $($rest_a:expr, $rest_b:expr),+) => {
+        match ($a).cmp($b) {
+            Equal => lexical_cmp!($($rest_a, $rest_b),+),
+            ordering   => ordering
         }
-    )+) => (
-        pub mod getters {
-            $(pub trait $name<$($T),+> {
-                    $(fn $method<'a>(&'a self) -> &'a $T;)+
-            })+
+    };
+    ($a:expr, $b:expr) => { ($a).cmp($b) };
+}
 
-            $(impl<$($T),+> $name<$($T),+> for ($($T),+) {
-                $(
-                    #[inline(always)]
-                    fn $method<'a>(&'a self) -> &'a $T {
-                        match *self {
-                            $accessor => $t
-                        }
-                    }
-                )+
-            })+
-        }
-    )
-)
 
-tuple_getters!(
-    Tuple2 {
-        fn n0 -> A { (ref a,_) => a }
-        fn n1 -> B { (_,ref b) => b }
+tuple_impls! {
+    (CloneableTuple2, ImmutableTuple2) {
+        (n0, n0_ref) -> A { (ref a,_) => a }
+        (n1, n1_ref) -> B { (_,ref b) => b }
     }
 
-    Tuple3 {
-        fn n0 -> A { (ref a,_,_) => a }
-        fn n1 -> B { (_,ref b,_) => b }
-        fn n2 -> C { (_,_,ref c) => c }
+    (CloneableTuple3, ImmutableTuple3) {
+        (n0, n0_ref) -> A { (ref a,_,_) => a }
+        (n1, n1_ref) -> B { (_,ref b,_) => b }
+        (n2, n2_ref) -> C { (_,_,ref c) => c }
     }
 
-    Tuple4 {
-        fn n0 -> A { (ref a,_,_,_) => a }
-        fn n1 -> B { (_,ref b,_,_) => b }
-        fn n2 -> C { (_,_,ref c,_) => c }
-        fn n3 -> D { (_,_,_,ref d) => d }
+    (CloneableTuple4, ImmutableTuple4) {
+        (n0, n0_ref) -> A { (ref a,_,_,_) => a }
+        (n1, n1_ref) -> B { (_,ref b,_,_) => b }
+        (n2, n2_ref) -> C { (_,_,ref c,_) => c }
+        (n3, n3_ref) -> D { (_,_,_,ref d) => d }
     }
 
-    Tuple5 {
-        fn n0 -> A { (ref a,_,_,_,_) => a }
-        fn n1 -> B { (_,ref b,_,_,_) => b }
-        fn n2 -> C { (_,_,ref c,_,_) => c }
-        fn n3 -> D { (_,_,_,ref d,_) => d }
-        fn n4 -> E { (_,_,_,_,ref e) => e }
+    (CloneableTuple5, ImmutableTuple5) {
+        (n0, n0_ref) -> A { (ref a,_,_,_,_) => a }
+        (n1, n1_ref) -> B { (_,ref b,_,_,_) => b }
+        (n2, n2_ref) -> C { (_,_,ref c,_,_) => c }
+        (n3, n3_ref) -> D { (_,_,_,ref d,_) => d }
+        (n4, n4_ref) -> E { (_,_,_,_,ref e) => e }
     }
 
-    Tuple6 {
-        fn n0 -> A { (ref a,_,_,_,_,_) => a }
-        fn n1 -> B { (_,ref b,_,_,_,_) => b }
-        fn n2 -> C { (_,_,ref c,_,_,_) => c }
-        fn n3 -> D { (_,_,_,ref d,_,_) => d }
-        fn n4 -> E { (_,_,_,_,ref e,_) => e }
-        fn n5 -> F { (_,_,_,_,_,ref f) => f }
+    (CloneableTuple6, ImmutableTuple6) {
+        (n0, n0_ref) -> A { (ref a,_,_,_,_,_) => a }
+        (n1, n1_ref) -> B { (_,ref b,_,_,_,_) => b }
+        (n2, n2_ref) -> C { (_,_,ref c,_,_,_) => c }
+        (n3, n3_ref) -> D { (_,_,_,ref d,_,_) => d }
+        (n4, n4_ref) -> E { (_,_,_,_,ref e,_) => e }
+        (n5, n5_ref) -> F { (_,_,_,_,_,ref f) => f }
     }
 
-    Tuple7 {
-        fn n0 -> A { (ref a,_,_,_,_,_,_) => a }
-        fn n1 -> B { (_,ref b,_,_,_,_,_) => b }
-        fn n2 -> C { (_,_,ref c,_,_,_,_) => c }
-        fn n3 -> D { (_,_,_,ref d,_,_,_) => d }
-        fn n4 -> E { (_,_,_,_,ref e,_,_) => e }
-        fn n5 -> F { (_,_,_,_,_,ref f,_) => f }
-        fn n6 -> G { (_,_,_,_,_,_,ref g) => g }
+    (CloneableTuple7, ImmutableTuple7) {
+        (n0, n0_ref) -> A { (ref a,_,_,_,_,_,_) => a }
+        (n1, n1_ref) -> B { (_,ref b,_,_,_,_,_) => b }
+        (n2, n2_ref) -> C { (_,_,ref c,_,_,_,_) => c }
+        (n3, n3_ref) -> D { (_,_,_,ref d,_,_,_) => d }
+        (n4, n4_ref) -> E { (_,_,_,_,ref e,_,_) => e }
+        (n5, n5_ref) -> F { (_,_,_,_,_,ref f,_) => f }
+        (n6, n6_ref) -> G { (_,_,_,_,_,_,ref g) => g }
     }
 
-    Tuple8 {
-        fn n0 -> A { (ref a,_,_,_,_,_,_,_) => a }
-        fn n1 -> B { (_,ref b,_,_,_,_,_,_) => b }
-        fn n2 -> C { (_,_,ref c,_,_,_,_,_) => c }
-        fn n3 -> D { (_,_,_,ref d,_,_,_,_) => d }
-        fn n4 -> E { (_,_,_,_,ref e,_,_,_) => e }
-        fn n5 -> F { (_,_,_,_,_,ref f,_,_) => f }
-        fn n6 -> G { (_,_,_,_,_,_,ref g,_) => g }
-        fn n7 -> H { (_,_,_,_,_,_,_,ref h) => h }
+    (CloneableTuple8, ImmutableTuple8) {
+        (n0, n0_ref) -> A { (ref a,_,_,_,_,_,_,_) => a }
+        (n1, n1_ref) -> B { (_,ref b,_,_,_,_,_,_) => b }
+        (n2, n2_ref) -> C { (_,_,ref c,_,_,_,_,_) => c }
+        (n3, n3_ref) -> D { (_,_,_,ref d,_,_,_,_) => d }
+        (n4, n4_ref) -> E { (_,_,_,_,ref e,_,_,_) => e }
+        (n5, n5_ref) -> F { (_,_,_,_,_,ref f,_,_) => f }
+        (n6, n6_ref) -> G { (_,_,_,_,_,_,ref g,_) => g }
+        (n7, n7_ref) -> H { (_,_,_,_,_,_,_,ref h) => h }
     }
 
-    Tuple9 {
-        fn n0 -> A { (ref a,_,_,_,_,_,_,_,_) => a }
-        fn n1 -> B { (_,ref b,_,_,_,_,_,_,_) => b }
-        fn n2 -> C { (_,_,ref c,_,_,_,_,_,_) => c }
-        fn n3 -> D { (_,_,_,ref d,_,_,_,_,_) => d }
-        fn n4 -> E { (_,_,_,_,ref e,_,_,_,_) => e }
-        fn n5 -> F { (_,_,_,_,_,ref f,_,_,_) => f }
-        fn n6 -> G { (_,_,_,_,_,_,ref g,_,_) => g }
-        fn n7 -> H { (_,_,_,_,_,_,_,ref h,_) => h }
-        fn n8 -> I { (_,_,_,_,_,_,_,_,ref i) => i }
+    (CloneableTuple9, ImmutableTuple9) {
+        (n0, n0_ref) -> A { (ref a,_,_,_,_,_,_,_,_) => a }
+        (n1, n1_ref) -> B { (_,ref b,_,_,_,_,_,_,_) => b }
+        (n2, n2_ref) -> C { (_,_,ref c,_,_,_,_,_,_) => c }
+        (n3, n3_ref) -> D { (_,_,_,ref d,_,_,_,_,_) => d }
+        (n4, n4_ref) -> E { (_,_,_,_,ref e,_,_,_,_) => e }
+        (n5, n5_ref) -> F { (_,_,_,_,_,ref f,_,_,_) => f }
+        (n6, n6_ref) -> G { (_,_,_,_,_,_,ref g,_,_) => g }
+        (n7, n7_ref) -> H { (_,_,_,_,_,_,_,ref h,_) => h }
+        (n8, n8_ref) -> I { (_,_,_,_,_,_,_,_,ref i) => i }
     }
 
-    Tuple10 {
-        fn n0 -> A { (ref a,_,_,_,_,_,_,_,_,_) => a }
-        fn n1 -> B { (_,ref b,_,_,_,_,_,_,_,_) => b }
-        fn n2 -> C { (_,_,ref c,_,_,_,_,_,_,_) => c }
-        fn n3 -> D { (_,_,_,ref d,_,_,_,_,_,_) => d }
-        fn n4 -> E { (_,_,_,_,ref e,_,_,_,_,_) => e }
-        fn n5 -> F { (_,_,_,_,_,ref f,_,_,_,_) => f }
-        fn n6 -> G { (_,_,_,_,_,_,ref g,_,_,_) => g }
-        fn n7 -> H { (_,_,_,_,_,_,_,ref h,_,_) => h }
-        fn n8 -> I { (_,_,_,_,_,_,_,_,ref i,_) => i }
-        fn n9 -> J { (_,_,_,_,_,_,_,_,_,ref j) => j }
+    (CloneableTuple10, ImmutableTuple10) {
+        (n0, n0_ref) -> A { (ref a,_,_,_,_,_,_,_,_,_) => a }
+        (n1, n1_ref) -> B { (_,ref b,_,_,_,_,_,_,_,_) => b }
+        (n2, n2_ref) -> C { (_,_,ref c,_,_,_,_,_,_,_) => c }
+        (n3, n3_ref) -> D { (_,_,_,ref d,_,_,_,_,_,_) => d }
+        (n4, n4_ref) -> E { (_,_,_,_,ref e,_,_,_,_,_) => e }
+        (n5, n5_ref) -> F { (_,_,_,_,_,ref f,_,_,_,_) => f }
+        (n6, n6_ref) -> G { (_,_,_,_,_,_,ref g,_,_,_) => g }
+        (n7, n7_ref) -> H { (_,_,_,_,_,_,_,ref h,_,_) => h }
+        (n8, n8_ref) -> I { (_,_,_,_,_,_,_,_,ref i,_) => i }
+        (n9, n9_ref) -> J { (_,_,_,_,_,_,_,_,_,ref j) => j }
     }
 
-    Tuple11 {
-        fn n0 -> A { (ref a,_,_,_,_,_,_,_,_,_,_) => a }
-        fn n1 -> B { (_,ref b,_,_,_,_,_,_,_,_,_) => b }
-        fn n2 -> C { (_,_,ref c,_,_,_,_,_,_,_,_) => c }
-        fn n3 -> D { (_,_,_,ref d,_,_,_,_,_,_,_) => d }
-        fn n4 -> E { (_,_,_,_,ref e,_,_,_,_,_,_) => e }
-        fn n5 -> F { (_,_,_,_,_,ref f,_,_,_,_,_) => f }
-        fn n6 -> G { (_,_,_,_,_,_,ref g,_,_,_,_) => g }
-        fn n7 -> H { (_,_,_,_,_,_,_,ref h,_,_,_) => h }
-        fn n8 -> I { (_,_,_,_,_,_,_,_,ref i,_,_) => i }
-        fn n9 -> J { (_,_,_,_,_,_,_,_,_,ref j,_) => j }
-        fn n10 -> K { (_,_,_,_,_,_,_,_,_,_,ref k) => k }
+    (CloneableTuple11, ImmutableTuple11) {
+        (n0,  n0_ref)  -> A { (ref a,_,_,_,_,_,_,_,_,_,_) => a }
+        (n1,  n1_ref)  -> B { (_,ref b,_,_,_,_,_,_,_,_,_) => b }
+        (n2,  n2_ref)  -> C { (_,_,ref c,_,_,_,_,_,_,_,_) => c }
+        (n3,  n3_ref)  -> D { (_,_,_,ref d,_,_,_,_,_,_,_) => d }
+        (n4,  n4_ref)  -> E { (_,_,_,_,ref e,_,_,_,_,_,_) => e }
+        (n5,  n5_ref)  -> F { (_,_,_,_,_,ref f,_,_,_,_,_) => f }
+        (n6,  n6_ref)  -> G { (_,_,_,_,_,_,ref g,_,_,_,_) => g }
+        (n7,  n7_ref)  -> H { (_,_,_,_,_,_,_,ref h,_,_,_) => h }
+        (n8,  n8_ref)  -> I { (_,_,_,_,_,_,_,_,ref i,_,_) => i }
+        (n9,  n9_ref)  -> J { (_,_,_,_,_,_,_,_,_,ref j,_) => j }
+        (n10, n10_ref) -> K { (_,_,_,_,_,_,_,_,_,_,ref k) => k }
     }
 
-    Tuple12 {
-        fn n0 -> A { (ref a,_,_,_,_,_,_,_,_,_,_,_) => a }
-        fn n1 -> B { (_,ref b,_,_,_,_,_,_,_,_,_,_) => b }
-        fn n2 -> C { (_,_,ref c,_,_,_,_,_,_,_,_,_) => c }
-        fn n3 -> D { (_,_,_,ref d,_,_,_,_,_,_,_,_) => d }
-        fn n4 -> E { (_,_,_,_,ref e,_,_,_,_,_,_,_) => e }
-        fn n5 -> F { (_,_,_,_,_,ref f,_,_,_,_,_,_) => f }
-        fn n6 -> G { (_,_,_,_,_,_,ref g,_,_,_,_,_) => g }
-        fn n7 -> H { (_,_,_,_,_,_,_,ref h,_,_,_,_) => h }
-        fn n8 -> I { (_,_,_,_,_,_,_,_,ref i,_,_,_) => i }
-        fn n9 -> J { (_,_,_,_,_,_,_,_,_,ref j,_,_) => j }
-        fn n10 -> K { (_,_,_,_,_,_,_,_,_,_,ref k,_) => k }
-        fn n11 -> L { (_,_,_,_,_,_,_,_,_,_,_,ref l) => l }
+    (CloneableTuple12, ImmutableTuple12) {
+        (n0,  n0_ref)  -> A { (ref a,_,_,_,_,_,_,_,_,_,_,_) => a }
+        (n1,  n1_ref)  -> B { (_,ref b,_,_,_,_,_,_,_,_,_,_) => b }
+        (n2,  n2_ref)  -> C { (_,_,ref c,_,_,_,_,_,_,_,_,_) => c }
+        (n3,  n3_ref)  -> D { (_,_,_,ref d,_,_,_,_,_,_,_,_) => d }
+        (n4,  n4_ref)  -> E { (_,_,_,_,ref e,_,_,_,_,_,_,_) => e }
+        (n5,  n5_ref)  -> F { (_,_,_,_,_,ref f,_,_,_,_,_,_) => f }
+        (n6,  n6_ref)  -> G { (_,_,_,_,_,_,ref g,_,_,_,_,_) => g }
+        (n7,  n7_ref)  -> H { (_,_,_,_,_,_,_,ref h,_,_,_,_) => h }
+        (n8,  n8_ref)  -> I { (_,_,_,_,_,_,_,_,ref i,_,_,_) => i }
+        (n9,  n9_ref)  -> J { (_,_,_,_,_,_,_,_,_,ref j,_,_) => j }
+        (n10, n10_ref) -> K { (_,_,_,_,_,_,_,_,_,_,ref k,_) => k }
+        (n11, n11_ref) -> L { (_,_,_,_,_,_,_,_,_,_,_,ref l) => l }
     }
-)
-
-#[test]
-fn test_tuple_ref() {
-    let x = (~"foo", ~"bar");
-    assert_eq!(x.first_ref(), &~"foo");
-    assert_eq!(x.second_ref(), &~"bar");
 }
 
-#[test]
-#[allow(non_implicitly_copyable_typarams)]
-fn test_tuple() {
-    assert_eq!((948, 4039.48).first(), 948);
-    assert_eq!((34.5, ~"foo").second(), ~"foo");
-    assert_eq!(('a', 2).swap(), (2, 'a'));
-}
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use clone::Clone;
+    use cmp::*;
+
+    #[test]
+    fn test_tuple_ref() {
+        let x = (~"foo", ~"bar");
+        assert_eq!(x.first_ref(), &~"foo");
+        assert_eq!(x.second_ref(), &~"bar");
+    }
 
-#[test]
-fn test_clone() {
-    let a = (1, ~"2");
-    let b = a.clone();
-    assert_eq!(a.first(), b.first());
-    assert_eq!(a.second(), b.second());
-}
+    #[test]
+    #[allow(non_implicitly_copyable_typarams)]
+    fn test_tuple() {
+        assert_eq!((948, 4039.48).first(), 948);
+        assert_eq!((34.5, ~"foo").second(), ~"foo");
+        assert_eq!(('a', 2).swap(), (2, 'a'));
+    }
 
-#[test]
-fn test_n_tuple() {
-    let t = (0u8, 1u16, 2u32, 3u64, 4u, 5i8, 6i16, 7i32, 8i64, 9i, 10f32, 11f64);
-    assert_eq!(*t.n0(), 0u8);
-    assert_eq!(*t.n1(), 1u16);
-    assert_eq!(*t.n2(), 2u32);
-    assert_eq!(*t.n3(), 3u64);
-    assert_eq!(*t.n4(), 4u);
-    assert_eq!(*t.n5(), 5i8);
-    assert_eq!(*t.n6(), 6i16);
-    assert_eq!(*t.n7(), 7i32);
-    assert_eq!(*t.n8(), 8i64);
-    assert_eq!(*t.n9(), 9i);
-    assert_eq!(*t.n10(), 10f32);
-    assert_eq!(*t.n11(), 11f64);
+    #[test]
+    fn test_clone() {
+        let a = (1, ~"2");
+        let b = a.clone();
+        assert_eq!(a.first(), b.first());
+        assert_eq!(a.second(), b.second());
+    }
+
+    #[test]
+    fn test_n_tuple() {
+        let t = (0u8, 1u16, 2u32, 3u64, 4u, 5i8, 6i16, 7i32, 8i64, 9i, 10f32, 11f64);
+        assert_eq!(t.n0(), 0u8);
+        assert_eq!(t.n1(), 1u16);
+        assert_eq!(t.n2(), 2u32);
+        assert_eq!(t.n3(), 3u64);
+        assert_eq!(t.n4(), 4u);
+        assert_eq!(t.n5(), 5i8);
+        assert_eq!(t.n6(), 6i16);
+        assert_eq!(t.n7(), 7i32);
+        assert_eq!(t.n8(), 8i64);
+        assert_eq!(t.n9(), 9i);
+        assert_eq!(t.n10(), 10f32);
+        assert_eq!(t.n11(), 11f64);
+
+        assert_eq!(t.n0_ref(), &0u8);
+        assert_eq!(t.n1_ref(), &1u16);
+        assert_eq!(t.n2_ref(), &2u32);
+        assert_eq!(t.n3_ref(), &3u64);
+        assert_eq!(t.n4_ref(), &4u);
+        assert_eq!(t.n5_ref(), &5i8);
+        assert_eq!(t.n6_ref(), &6i16);
+        assert_eq!(t.n7_ref(), &7i32);
+        assert_eq!(t.n8_ref(), &8i64);
+        assert_eq!(t.n9_ref(), &9i);
+        assert_eq!(t.n10_ref(), &10f32);
+        assert_eq!(t.n11_ref(), &11f64);
+    }
+
+    #[test]
+    fn test_tuple_cmp() {
+        let small = (1u, 2u, 3u), big = (3u, 2u, 1u);
+
+        // Eq
+        assert_eq!(small, small);
+        assert_eq!(big, big);
+        assert!(small != big);
+        assert!(big != small);
+
+        // Ord
+        assert!(small < big);
+        assert!(!(small < small));
+        assert!(!(big < small));
+        assert!(!(big < big));
+
+        assert!(small <= small);
+        assert!(big <= big);
+
+        assert!(big > small);
+        assert!(small >= small);
+        assert!(big >= small);
+        assert!(big >= big);
+
+        // TotalEq
+        assert!(small.equals(&small));
+        assert!(big.equals(&big));
+        assert!(!small.equals(&big));
+        assert!(!big.equals(&small));
+
+        // TotalOrd
+        assert_eq!(small.cmp(&small), Equal);
+        assert_eq!(big.cmp(&big), Equal);
+        assert_eq!(small.cmp(&big), Less);
+        assert_eq!(big.cmp(&small), Greater);
+    }
 }