auto merge of #6591 : bjz/rust/tuple-elements, r=thestinger

This commit implements element getters for tuples with an arity of 2 to 12. The getters return references to the elements, so no copying occurs. The traits are re-exported in `core::prelude` so you can use them from regular Rust code.

Here is an example of one of the getters in use:

~~~rust
assert_eq!((2, "hi", 75.0).n1(), &"hi");
~~~

src/libcore/prelude.rs

@@ -52,6 +52,8 @@ 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 vec::{CopyableVector, ImmutableVector};
 pub use vec::{ImmutableEqVector, ImmutableCopyableVector};
 pub use vec::{OwnedVector, OwnedCopyableVector, MutableVector};

src/libcore/tuple.rs

@@ -16,6 +16,8 @@ use vec;
 
 #[cfg(not(test))] use cmp::{Eq, Ord};
 
+pub use self::getters::*;
+
 pub trait CopyableTuple<T, U> {
     fn first(&self) -> T;
     fn second(&self) -> U;
@@ -246,25 +248,181 @@ impl<A:Ord,B:Ord,C:Ord> Ord for (A, B, C) {
     fn gt(&self, other: &(A, B, C)) -> bool { (*other).lt(&(*self))  }
 }
 
+// Tuple element getters
+
+macro_rules! tuple_getters(
+    ($(
+        $name:ident {
+            $(fn $method:ident -> $T:ident { $accessor:pat => $t:expr })+
+        }
+    )+) => (
+        pub mod getters {
+            $(pub trait $name<$($T),+> {
+                    $(fn $method<'a>(&'a self) -> &'a $T;)+
+            })+
+
+            $(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 }
+    }
+
+    Tuple3 {
+        fn n0 -> A { (ref a,_,_) => a }
+        fn n1 -> B { (_,ref b,_) => b }
+        fn n2 -> 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 }
+    }
+
+    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 }
+    }
+
+    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 }
+    }
+
+    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 }
+    }
+
+    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 }
+    }
+
+    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 }
+    }
+
+    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 }
+    }
+
+    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 }
+    }
+
+    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 }
+    }
+)
+
 #[test]
 fn test_tuple_ref() {
     let x = (~"foo", ~"bar");
-    assert!(x.first_ref() == &~"foo");
-    assert!(x.second_ref() == &~"bar");
+    assert_eq!(x.first_ref(), &~"foo");
+    assert_eq!(x.second_ref(), &~"bar");
 }
 
 #[test]
 #[allow(non_implicitly_copyable_typarams)]
 fn test_tuple() {
-    assert!((948, 4039.48).first() == 948);
-    assert!((34.5, ~"foo").second() == ~"foo");
-    assert!(('a', 2).swap() == (2, 'a'));
+    assert_eq!((948, 4039.48).first(), 948);
+    assert_eq!((34.5, ~"foo").second(), ~"foo");
+    assert_eq!(('a', 2).swap(), (2, 'a'));
 }
 
 #[test]
 fn test_clone() {
     let a = (1, ~"2");
     let b = a.clone();
-    assert!(a.first() == b.first());
-    assert!(a.second() == b.second());
+    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);
 }