Primitive Type tuple

Operations on tuples

To access a single element of a tuple one can use the following methods:

valN - returns a value of N-th element
refN - returns a reference to N-th element
mutN - returns a mutable reference to N-th element

Indexing starts from zero, so val0 returns first value, val1 returns second value, and so on. In general, a tuple with S elements provides aforementioned methods suffixed with numbers from 0 to S-1. Traits which contain these methods are implemented for tuples with up to 12 elements.

If every type inside a tuple implements one of the following traits, then a tuple itself also implements it.

Clone
PartialEq
Eq
PartialOrd
Ord
Default

Examples

Using methods:

fn main() { let pair = ("pi", 3.14f64); assert_eq!(pair.val0(), "pi"); assert_eq!(pair.val1(), 3.14f64); }

let pair = ("pi", 3.14f64);
assert_eq!(pair.val0(), "pi");
assert_eq!(pair.val1(), 3.14f64);

Using traits implemented for tuples:

fn main() { use std::default::Default; let a = (1i, 2i); let b = (3i, 4i); assert!(a != b); let c = b.clone(); assert!(b == c); let d : (u32, f32) = Default::default(); assert_eq!(d, (0u32, 0.0f32)); }

use std::default::Default;

let a = (1i, 2i);
let b = (3i, 4i);
assert!(a != b);

let c = b.clone();
assert!(b == c);

let d : (u32, f32) = Default::default();
assert_eq!(d, (0u32, 0.0f32));

Trait Implementations

`impl<A> Tuple1<A> for (A)`

`fn val0(self) -> A`

`fn ref0<'a>(&'a self) -> &'a A`

`fn mut0<'a>(&'a mut self) -> &'a mut A`

`impl<A: Clone> Clone for (A)`

`fn clone(&self) -> (A)`

`fn clone_from(&mut self, source: &Self)`

`impl<A: PartialEq> PartialEq for (A)`

`fn eq(&self, other: &(A)) -> bool`

`fn ne(&self, other: &(A)) -> bool`

`impl<A: Eq> Eq for (A)`

`impl<A: PartialOrd + PartialEq> PartialOrd for (A)`

`fn lt(&self, other: &(A)) -> bool`

`fn le(&self, other: &(A)) -> bool`

`fn ge(&self, other: &(A)) -> bool`

`fn gt(&self, other: &(A)) -> bool`

`impl<A: Ord> Ord for (A)`

`fn cmp(&self, other: &(A)) -> Ordering`

`impl<A: Default> Default for (A)`

`fn default() -> (A)`

`impl<A, B> Tuple2<A, B> for (A, B)`

`fn val0(self) -> A`

`fn ref0<'a>(&'a self) -> &'a A`

`fn mut0<'a>(&'a mut self) -> &'a mut A`

`fn val1(self) -> B`

`fn ref1<'a>(&'a self) -> &'a B`

`fn mut1<'a>(&'a mut self) -> &'a mut B`

`impl<A: Clone, B: Clone> Clone for (A, B)`

`fn clone(&self) -> (A, B)`

`fn clone_from(&mut self, source: &Self)`

`impl<A: PartialEq, B: PartialEq> PartialEq for (A, B)`

`fn eq(&self, other: &(A, B)) -> bool`

`fn ne(&self, other: &(A, B)) -> bool`

`impl<A: Eq, B: Eq> Eq for (A, B)`

`impl<A: PartialOrd + PartialEq, B: PartialOrd + PartialEq> PartialOrd for (A, B)`

`fn lt(&self, other: &(A, B)) -> bool`

`fn le(&self, other: &(A, B)) -> bool`

`fn ge(&self, other: &(A, B)) -> bool`

`fn gt(&self, other: &(A, B)) -> bool`

`impl<A: Ord, B: Ord> Ord for (A, B)`

`fn cmp(&self, other: &(A, B)) -> Ordering`

`impl<A: Default, B: Default> Default for (A, B)`

`fn default() -> (A, B)`

`impl<A, B, C> Tuple3<A, B, C> for (A, B, C)`

`fn val0(self) -> A`

`fn ref0<'a>(&'a self) -> &'a A`

`fn mut0<'a>(&'a mut self) -> &'a mut A`

`fn val1(self) -> B`

`fn ref1<'a>(&'a self) -> &'a B`

`fn mut1<'a>(&'a mut self) -> &'a mut B`

`fn val2(self) -> C`

`fn ref2<'a>(&'a self) -> &'a C`

`fn mut2<'a>(&'a mut self) -> &'a mut C`

`impl<A: Clone, B: Clone, C: Clone> Clone for (A, B, C)`

`fn clone(&self) -> (A, B, C)`

`fn clone_from(&mut self, source: &Self)`

`impl<A: PartialEq, B: PartialEq, C: PartialEq> PartialEq for (A, B, C)`

`fn eq(&self, other: &(A, B, C)) -> bool`

`fn ne(&self, other: &(A, B, C)) -> bool`

`impl<A: Eq, B: Eq, C: Eq> Eq for (A, B, C)`

`impl<A: PartialOrd + PartialEq, B: PartialOrd + PartialEq, C: PartialOrd + PartialEq> PartialOrd for (A, B, C)`

`fn lt(&self, other: &(A, B, C)) -> bool`

`fn le(&self, other: &(A, B, C)) -> bool`

`fn ge(&self, other: &(A, B, C)) -> bool`

`fn gt(&self, other: &(A, B, C)) -> bool`

`impl<A: Ord, B: Ord, C: Ord> Ord for (A, B, C)`

`fn cmp(&self, other: &(A, B, C)) -> Ordering`

`impl<A: Default, B: Default, C: Default> Default for (A, B, C)`

`fn default() -> (A, B, C)`

`impl<A, B, C, D> Tuple4<A, B, C, D> for (A, B, C, D)`

`fn val0(self) -> A`

`fn ref0<'a>(&'a self) -> &'a A`

`fn mut0<'a>(&'a mut self) -> &'a mut A`

`fn val1(self) -> B`

`fn ref1<'a>(&'a self) -> &'a B`

`fn mut1<'a>(&'a mut self) -> &'a mut B`

`fn val2(self) -> C`

`fn ref2<'a>(&'a self) -> &'a C`

`fn mut2<'a>(&'a mut self) -> &'a mut C`

`fn val3(self) -> D`

`fn ref3<'a>(&'a self) -> &'a D`

`fn mut3<'a>(&'a mut self) -> &'a mut D`

`impl<A: Clone, B: Clone, C: Clone, D: Clone> Clone for (A, B, C, D)`

`fn clone(&self) -> (A, B, C, D)`

`fn clone_from(&mut self, source: &Self)`

`impl<A: PartialEq, B: PartialEq, C: PartialEq, D: PartialEq> PartialEq for (A, B, C, D)`

`fn eq(&self, other: &(A, B, C, D)) -> bool`

`fn ne(&self, other: &(A, B, C, D)) -> bool`

`impl<A: Eq, B: Eq, C: Eq, D: Eq> Eq for (A, B, C, D)`

`impl<A: PartialOrd + PartialEq, B: PartialOrd + PartialEq, C: PartialOrd + PartialEq, D: PartialOrd + PartialEq> PartialOrd for (A, B, C, D)`

`fn lt(&self, other: &(A, B, C, D)) -> bool`

`fn le(&self, other: &(A, B, C, D)) -> bool`

`fn ge(&self, other: &(A, B, C, D)) -> bool`

`fn gt(&self, other: &(A, B, C, D)) -> bool`

`impl<A: Ord, B: Ord, C: Ord, D: Ord> Ord for (A, B, C, D)`

`fn cmp(&self, other: &(A, B, C, D)) -> Ordering`

`impl<A: Default, B: Default, C: Default, D: Default> Default for (A, B, C, D)`

`fn default() -> (A, B, C, D)`

`impl<A, B, C, D, E> Tuple5<A, B, C, D, E> for (A, B, C, D, E)`

`fn val0(self) -> A`

`fn ref0<'a>(&'a self) -> &'a A`

`fn mut0<'a>(&'a mut self) -> &'a mut A`

`fn val1(self) -> B`

`fn ref1<'a>(&'a self) -> &'a B`

`fn mut1<'a>(&'a mut self) -> &'a mut B`

`fn val2(self) -> C`

`fn ref2<'a>(&'a self) -> &'a C`

`fn mut2<'a>(&'a mut self) -> &'a mut C`

`fn val3(self) -> D`

`fn ref3<'a>(&'a self) -> &'a D`

`fn mut3<'a>(&'a mut self) -> &'a mut D`

`fn val4(self) -> E`

`fn ref4<'a>(&'a self) -> &'a E`

`fn mut4<'a>(&'a mut self) -> &'a mut E`

`impl<A: Clone, B: Clone, C: Clone, D: Clone, E: Clone> Clone for (A, B, C, D, E)`

`fn clone(&self) -> (A, B, C, D, E)`

`fn clone_from(&mut self, source: &Self)`

`impl<A: PartialEq, B: PartialEq, C: PartialEq, D: PartialEq, E: PartialEq> PartialEq for (A, B, C, D, E)`

`fn eq(&self, other: &(A, B, C, D, E)) -> bool`

`fn ne(&self, other: &(A, B, C, D, E)) -> bool`

`impl<A: Eq, B: Eq, C: Eq, D: Eq, E: Eq> Eq for (A, B, C, D, E)`

`impl<A: PartialOrd + PartialEq, B: PartialOrd + PartialEq, C: PartialOrd + PartialEq, D: PartialOrd + PartialEq, E: PartialOrd + PartialEq> PartialOrd for (A, B, C, D, E)`

`fn lt(&self, other: &(A, B, C, D, E)) -> bool`

`fn le(&self, other: &(A, B, C, D, E)) -> bool`

`fn ge(&self, other: &(A, B, C, D, E)) -> bool`

`fn gt(&self, other: &(A, B, C, D, E)) -> bool`

`impl<A: Ord, B: Ord, C: Ord, D: Ord, E: Ord> Ord for (A, B, C, D, E)`

`fn cmp(&self, other: &(A, B, C, D, E)) -> Ordering`

`impl<A: Default, B: Default, C: Default, D: Default, E: Default> Default for (A, B, C, D, E)`

`fn default() -> (A, B, C, D, E)`

`impl<A, B, C, D, E, F> Tuple6<A, B, C, D, E, F> for (A, B, C, D, E, F)`

`fn val0(self) -> A`

`fn ref0<'a>(&'a self) -> &'a A`

`fn mut0<'a>(&'a mut self) -> &'a mut A`

`fn val1(self) -> B`

`fn ref1<'a>(&'a self) -> &'a B`

`fn mut1<'a>(&'a mut self) -> &'a mut B`

`fn val2(self) -> C`

`fn ref2<'a>(&'a self) -> &'a C`

`fn mut2<'a>(&'a mut self) -> &'a mut C`

`fn val3(self) -> D`

`fn ref3<'a>(&'a self) -> &'a D`

`fn mut3<'a>(&'a mut self) -> &'a mut D`

`fn val4(self) -> E`

`fn ref4<'a>(&'a self) -> &'a E`

`fn mut4<'a>(&'a mut self) -> &'a mut E`

`fn val5(self) -> F`

`fn ref5<'a>(&'a self) -> &'a F`

`fn mut5<'a>(&'a mut self) -> &'a mut F`

`impl<A: Clone, B: Clone, C: Clone, D: Clone, E: Clone, F: Clone> Clone for (A, B, C, D, E, F)`

`fn clone(&self) -> (A, B, C, D, E, F)`

`fn clone_from(&mut self, source: &Self)`

`impl<A: PartialEq, B: PartialEq, C: PartialEq, D: PartialEq, E: PartialEq, F: PartialEq> PartialEq for (A, B, C, D, E, F)`

`fn eq(&self, other: &(A, B, C, D, E, F)) -> bool`

`fn ne(&self, other: &(A, B, C, D, E, F)) -> bool`

`impl<A: Eq, B: Eq, C: Eq, D: Eq, E: Eq, F: Eq> Eq for (A, B, C, D, E, F)`

`impl<A: PartialOrd + PartialEq, B: PartialOrd + PartialEq, C: PartialOrd + PartialEq, D: PartialOrd + PartialEq, E: PartialOrd + PartialEq, F: PartialOrd + PartialEq> PartialOrd for (A, B, C, D, E, F)`

`fn lt(&self, other: &(A, B, C, D, E, F)) -> bool`

`fn le(&self, other: &(A, B, C, D, E, F)) -> bool`

`fn ge(&self, other: &(A, B, C, D, E, F)) -> bool`

`fn gt(&self, other: &(A, B, C, D, E, F)) -> bool`

`impl<A: Ord, B: Ord, C: Ord, D: Ord, E: Ord, F: Ord> Ord for (A, B, C, D, E, F)`

`fn cmp(&self, other: &(A, B, C, D, E, F)) -> Ordering`

`impl<A: Default, B: Default, C: Default, D: Default, E: Default, F: Default> Default for (A, B, C, D, E, F)`

`fn default() -> (A, B, C, D, E, F)`

`impl<A, B, C, D, E, F, G> Tuple7<A, B, C, D, E, F, G> for (A, B, C, D, E, F, G)`

`fn val0(self) -> A`

`fn ref0<'a>(&'a self) -> &'a A`

`fn mut0<'a>(&'a mut self) -> &'a mut A`

`fn val1(self) -> B`

`fn ref1<'a>(&'a self) -> &'a B`

`fn mut1<'a>(&'a mut self) -> &'a mut B`

`fn val2(self) -> C`

`fn ref2<'a>(&'a self) -> &'a C`

`fn mut2<'a>(&'a mut self) -> &'a mut C`

`fn val3(self) -> D`

`fn ref3<'a>(&'a self) -> &'a D`

`fn mut3<'a>(&'a mut self) -> &'a mut D`

`fn val4(self) -> E`

`fn ref4<'a>(&'a self) -> &'a E`

`fn mut4<'a>(&'a mut self) -> &'a mut E`

`fn val5(self) -> F`

`fn ref5<'a>(&'a self) -> &'a F`

`fn mut5<'a>(&'a mut self) -> &'a mut F`

`fn val6(self) -> G`

`fn ref6<'a>(&'a self) -> &'a G`

`fn mut6<'a>(&'a mut self) -> &'a mut G`

`impl<A: Clone, B: Clone, C: Clone, D: Clone, E: Clone, F: Clone, G: Clone> Clone for (A, B, C, D, E, F, G)`

`fn clone(&self) -> (A, B, C, D, E, F, G)`

`fn clone_from(&mut self, source: &Self)`

`impl<A: PartialEq, B: PartialEq, C: PartialEq, D: PartialEq, E: PartialEq, F: PartialEq, G: PartialEq> PartialEq for (A, B, C, D, E, F, G)`

`fn eq(&self, other: &(A, B, C, D, E, F, G)) -> bool`

`fn ne(&self, other: &(A, B, C, D, E, F, G)) -> bool`

`impl<A: Eq, B: Eq, C: Eq, D: Eq, E: Eq, F: Eq, G: Eq> Eq for (A, B, C, D, E, F, G)`

`impl<A: PartialOrd + PartialEq, B: PartialOrd + PartialEq, C: PartialOrd + PartialEq, D: PartialOrd + PartialEq, E: PartialOrd + PartialEq, F: PartialOrd + PartialEq, G: PartialOrd + PartialEq> PartialOrd for (A, B, C, D, E, F, G)`

`fn lt(&self, other: &(A, B, C, D, E, F, G)) -> bool`

`fn le(&self, other: &(A, B, C, D, E, F, G)) -> bool`

`fn ge(&self, other: &(A, B, C, D, E, F, G)) -> bool`

`fn gt(&self, other: &(A, B, C, D, E, F, G)) -> bool`

`impl<A: Ord, B: Ord, C: Ord, D: Ord, E: Ord, F: Ord, G: Ord> Ord for (A, B, C, D, E, F, G)`

`fn cmp(&self, other: &(A, B, C, D, E, F, G)) -> Ordering`

`impl<A: Default, B: Default, C: Default, D: Default, E: Default, F: Default, G: Default> Default for (A, B, C, D, E, F, G)`

`fn default() -> (A, B, C, D, E, F, G)`

`impl<A, B, C, D, E, F, G, H> Tuple8<A, B, C, D, E, F, G, H> for (A, B, C, D, E, F, G, H)`

`fn val0(self) -> A`

`fn ref0<'a>(&'a self) -> &'a A`

`fn mut0<'a>(&'a mut self) -> &'a mut A`

`fn val1(self) -> B`

`fn ref1<'a>(&'a self) -> &'a B`

`fn mut1<'a>(&'a mut self) -> &'a mut B`

`fn val2(self) -> C`

`fn ref2<'a>(&'a self) -> &'a C`

`fn mut2<'a>(&'a mut self) -> &'a mut C`

`fn val3(self) -> D`

`fn ref3<'a>(&'a self) -> &'a D`

`fn mut3<'a>(&'a mut self) -> &'a mut D`

`fn val4(self) -> E`

`fn ref4<'a>(&'a self) -> &'a E`

`fn mut4<'a>(&'a mut self) -> &'a mut E`

`fn val5(self) -> F`

`fn ref5<'a>(&'a self) -> &'a F`

`fn mut5<'a>(&'a mut self) -> &'a mut F`

`fn val6(self) -> G`

`fn ref6<'a>(&'a self) -> &'a G`

`fn mut6<'a>(&'a mut self) -> &'a mut G`

`fn val7(self) -> H`

`fn ref7<'a>(&'a self) -> &'a H`

`fn mut7<'a>(&'a mut self) -> &'a mut H`

`impl<A: Clone, B: Clone, C: Clone, D: Clone, E: Clone, F: Clone, G: Clone, H: Clone> Clone for (A, B, C, D, E, F, G, H)`

`fn clone(&self) -> (A, B, C, D, E, F, G, H)`

`fn clone_from(&mut self, source: &Self)`

`impl<A: PartialEq, B: PartialEq, C: PartialEq, D: PartialEq, E: PartialEq, F: PartialEq, G: PartialEq, H: PartialEq> PartialEq for (A, B, C, D, E, F, G, H)`

`fn eq(&self, other: &(A, B, C, D, E, F, G, H)) -> bool`

`fn ne(&self, other: &(A, B, C, D, E, F, G, H)) -> bool`

`impl<A: Eq, B: Eq, C: Eq, D: Eq, E: Eq, F: Eq, G: Eq, H: Eq> Eq for (A, B, C, D, E, F, G, H)`

`impl<A: PartialOrd + PartialEq, B: PartialOrd + PartialEq, C: PartialOrd + PartialEq, D: PartialOrd + PartialEq, E: PartialOrd + PartialEq, F: PartialOrd + PartialEq, G: PartialOrd + PartialEq, H: PartialOrd + PartialEq> PartialOrd for (A, B, C, D, E, F, G, H)`

`fn lt(&self, other: &(A, B, C, D, E, F, G, H)) -> bool`

`fn le(&self, other: &(A, B, C, D, E, F, G, H)) -> bool`

`fn ge(&self, other: &(A, B, C, D, E, F, G, H)) -> bool`

`fn gt(&self, other: &(A, B, C, D, E, F, G, H)) -> bool`

`impl<A: Ord, B: Ord, C: Ord, D: Ord, E: Ord, F: Ord, G: Ord, H: Ord> Ord for (A, B, C, D, E, F, G, H)`

`fn cmp(&self, other: &(A, B, C, D, E, F, G, H)) -> Ordering`

`impl<A: Default, B: Default, C: Default, D: Default, E: Default, F: Default, G: Default, H: Default> Default for (A, B, C, D, E, F, G, H)`

`fn default() -> (A, B, C, D, E, F, G, H)`

`impl<A, B, C, D, E, F, G, H, I> Tuple9<A, B, C, D, E, F, G, H, I> for (A, B, C, D, E, F, G, H, I)`

`fn val0(self) -> A`

`fn ref0<'a>(&'a self) -> &'a A`

`fn mut0<'a>(&'a mut self) -> &'a mut A`

`fn val1(self) -> B`

`fn ref1<'a>(&'a self) -> &'a B`

`fn mut1<'a>(&'a mut self) -> &'a mut B`

`fn val2(self) -> C`

`fn ref2<'a>(&'a self) -> &'a C`

`fn mut2<'a>(&'a mut self) -> &'a mut C`

`fn val3(self) -> D`

`fn ref3<'a>(&'a self) -> &'a D`

`fn mut3<'a>(&'a mut self) -> &'a mut D`

`fn val4(self) -> E`

`fn ref4<'a>(&'a self) -> &'a E`

`fn mut4<'a>(&'a mut self) -> &'a mut E`

`fn val5(self) -> F`

`fn ref5<'a>(&'a self) -> &'a F`

`fn mut5<'a>(&'a mut self) -> &'a mut F`

`fn val6(self) -> G`

`fn ref6<'a>(&'a self) -> &'a G`

`fn mut6<'a>(&'a mut self) -> &'a mut G`

`fn val7(self) -> H`

`fn ref7<'a>(&'a self) -> &'a H`

`fn mut7<'a>(&'a mut self) -> &'a mut H`

`fn val8(self) -> I`

`fn ref8<'a>(&'a self) -> &'a I`

`fn mut8<'a>(&'a mut self) -> &'a mut I`

`impl<A: Clone, B: Clone, C: Clone, D: Clone, E: Clone, F: Clone, G: Clone, H: Clone, I: Clone> Clone for (A, B, C, D, E, F, G, H, I)`

`fn clone(&self) -> (A, B, C, D, E, F, G, H, I)`

`fn clone_from(&mut self, source: &Self)`

`impl<A: PartialEq, B: PartialEq, C: PartialEq, D: PartialEq, E: PartialEq, F: PartialEq, G: PartialEq, H: PartialEq, I: PartialEq> PartialEq for (A, B, C, D, E, F, G, H, I)`

`fn eq(&self, other: &(A, B, C, D, E, F, G, H, I)) -> bool`

`fn ne(&self, other: &(A, B, C, D, E, F, G, H, I)) -> bool`

`impl<A: Eq, B: Eq, C: Eq, D: Eq, E: Eq, F: Eq, G: Eq, H: Eq, I: Eq> Eq for (A, B, C, D, E, F, G, H, I)`

`impl<A: PartialOrd + PartialEq, B: PartialOrd + PartialEq, C: PartialOrd + PartialEq, D: PartialOrd + PartialEq, E: PartialOrd + PartialEq, F: PartialOrd + PartialEq, G: PartialOrd + PartialEq, H: PartialOrd + PartialEq, I: PartialOrd + PartialEq> PartialOrd for (A, B, C, D, E, F, G, H, I)`

`fn lt(&self, other: &(A, B, C, D, E, F, G, H, I)) -> bool`

`fn le(&self, other: &(A, B, C, D, E, F, G, H, I)) -> bool`

`fn ge(&self, other: &(A, B, C, D, E, F, G, H, I)) -> bool`

`fn gt(&self, other: &(A, B, C, D, E, F, G, H, I)) -> bool`

`impl<A: Ord, B: Ord, C: Ord, D: Ord, E: Ord, F: Ord, G: Ord, H: Ord, I: Ord> Ord for (A, B, C, D, E, F, G, H, I)`

`fn cmp(&self, other: &(A, B, C, D, E, F, G, H, I)) -> Ordering`

`impl<A: Default, B: Default, C: Default, D: Default, E: Default, F: Default, G: Default, H: Default, I: Default> Default for (A, B, C, D, E, F, G, H, I)`

`fn default() -> (A, B, C, D, E, F, G, H, I)`

`impl<A, B, C, D, E, F, G, H, I, J> Tuple10<A, B, C, D, E, F, G, H, I, J> for (A, B, C, D, E, F, G, H, I, J)`

`fn val0(self) -> A`

`fn ref0<'a>(&'a self) -> &'a A`

`fn mut0<'a>(&'a mut self) -> &'a mut A`

`fn val1(self) -> B`

`fn ref1<'a>(&'a self) -> &'a B`

`fn mut1<'a>(&'a mut self) -> &'a mut B`

`fn val2(self) -> C`

`fn ref2<'a>(&'a self) -> &'a C`

`fn mut2<'a>(&'a mut self) -> &'a mut C`

`fn val3(self) -> D`

`fn ref3<'a>(&'a self) -> &'a D`

`fn mut3<'a>(&'a mut self) -> &'a mut D`

`fn val4(self) -> E`

`fn ref4<'a>(&'a self) -> &'a E`

`fn mut4<'a>(&'a mut self) -> &'a mut E`

`fn val5(self) -> F`

`fn ref5<'a>(&'a self) -> &'a F`

`fn mut5<'a>(&'a mut self) -> &'a mut F`

`fn val6(self) -> G`

`fn ref6<'a>(&'a self) -> &'a G`

`fn mut6<'a>(&'a mut self) -> &'a mut G`

`fn val7(self) -> H`

`fn ref7<'a>(&'a self) -> &'a H`

`fn mut7<'a>(&'a mut self) -> &'a mut H`

`fn val8(self) -> I`

`fn ref8<'a>(&'a self) -> &'a I`

`fn mut8<'a>(&'a mut self) -> &'a mut I`

`fn val9(self) -> J`

`fn ref9<'a>(&'a self) -> &'a J`

`fn mut9<'a>(&'a mut self) -> &'a mut J`

`impl<A: Clone, B: Clone, C: Clone, D: Clone, E: Clone, F: Clone, G: Clone, H: Clone, I: Clone, J: Clone> Clone for (A, B, C, D, E, F, G, H, I, J)`

`fn clone(&self) -> (A, B, C, D, E, F, G, H, I, J)`

`fn clone_from(&mut self, source: &Self)`

`impl<A: PartialEq, B: PartialEq, C: PartialEq, D: PartialEq, E: PartialEq, F: PartialEq, G: PartialEq, H: PartialEq, I: PartialEq, J: PartialEq> PartialEq for (A, B, C, D, E, F, G, H, I, J)`

`fn eq(&self, other: &(A, B, C, D, E, F, G, H, I, J)) -> bool`

`fn ne(&self, other: &(A, B, C, D, E, F, G, H, I, J)) -> bool`

`impl<A: Eq, B: Eq, C: Eq, D: Eq, E: Eq, F: Eq, G: Eq, H: Eq, I: Eq, J: Eq> Eq for (A, B, C, D, E, F, G, H, I, J)`

`impl<A: PartialOrd + PartialEq, B: PartialOrd + PartialEq, C: PartialOrd + PartialEq, D: PartialOrd + PartialEq, E: PartialOrd + PartialEq, F: PartialOrd + PartialEq, G: PartialOrd + PartialEq, H: PartialOrd + PartialEq, I: PartialOrd + PartialEq, J: PartialOrd + PartialEq> PartialOrd for (A, B, C, D, E, F, G, H, I, J)`

`fn lt(&self, other: &(A, B, C, D, E, F, G, H, I, J)) -> bool`

`fn le(&self, other: &(A, B, C, D, E, F, G, H, I, J)) -> bool`

`fn ge(&self, other: &(A, B, C, D, E, F, G, H, I, J)) -> bool`

`fn gt(&self, other: &(A, B, C, D, E, F, G, H, I, J)) -> bool`

`impl<A: Ord, B: Ord, C: Ord, D: Ord, E: Ord, F: Ord, G: Ord, H: Ord, I: Ord, J: Ord> Ord for (A, B, C, D, E, F, G, H, I, J)`

`fn cmp(&self, other: &(A, B, C, D, E, F, G, H, I, J)) -> Ordering`

`impl<A: Default, B: Default, C: Default, D: Default, E: Default, F: Default, G: Default, H: Default, I: Default, J: Default> Default for (A, B, C, D, E, F, G, H, I, J)`

`fn default() -> (A, B, C, D, E, F, G, H, I, J)`

`impl<A, B, C, D, E, F, G, H, I, J, K> Tuple11<A, B, C, D, E, F, G, H, I, J, K> for (A, B, C, D, E, F, G, H, I, J, K)`

`fn val0(self) -> A`

`fn ref0<'a>(&'a self) -> &'a A`

`fn mut0<'a>(&'a mut self) -> &'a mut A`

`fn val1(self) -> B`

`fn ref1<'a>(&'a self) -> &'a B`

`fn mut1<'a>(&'a mut self) -> &'a mut B`

`fn val2(self) -> C`

`fn ref2<'a>(&'a self) -> &'a C`

`fn mut2<'a>(&'a mut self) -> &'a mut C`

`fn val3(self) -> D`

`fn ref3<'a>(&'a self) -> &'a D`

`fn mut3<'a>(&'a mut self) -> &'a mut D`

`fn val4(self) -> E`

`fn ref4<'a>(&'a self) -> &'a E`

`fn mut4<'a>(&'a mut self) -> &'a mut E`

`fn val5(self) -> F`

`fn ref5<'a>(&'a self) -> &'a F`

`fn mut5<'a>(&'a mut self) -> &'a mut F`

`fn val6(self) -> G`

`fn ref6<'a>(&'a self) -> &'a G`

`fn mut6<'a>(&'a mut self) -> &'a mut G`

`fn val7(self) -> H`

`fn ref7<'a>(&'a self) -> &'a H`

`fn mut7<'a>(&'a mut self) -> &'a mut H`

`fn val8(self) -> I`

`fn ref8<'a>(&'a self) -> &'a I`

`fn mut8<'a>(&'a mut self) -> &'a mut I`

`fn val9(self) -> J`

`fn ref9<'a>(&'a self) -> &'a J`

`fn mut9<'a>(&'a mut self) -> &'a mut J`

`fn val10(self) -> K`

`fn ref10<'a>(&'a self) -> &'a K`

`fn mut10<'a>(&'a mut self) -> &'a mut K`

`impl<A: Clone, B: Clone, C: Clone, D: Clone, E: Clone, F: Clone, G: Clone, H: Clone, I: Clone, J: Clone, K: Clone> Clone for (A, B, C, D, E, F, G, H, I, J, K)`

`fn clone(&self) -> (A, B, C, D, E, F, G, H, I, J, K)`

`fn clone_from(&mut self, source: &Self)`

`impl<A: PartialEq, B: PartialEq, C: PartialEq, D: PartialEq, E: PartialEq, F: PartialEq, G: PartialEq, H: PartialEq, I: PartialEq, J: PartialEq, K: PartialEq> PartialEq for (A, B, C, D, E, F, G, H, I, J, K)`

`fn eq(&self, other: &(A, B, C, D, E, F, G, H, I, J, K)) -> bool`

`fn ne(&self, other: &(A, B, C, D, E, F, G, H, I, J, K)) -> bool`

`impl<A: Eq, B: Eq, C: Eq, D: Eq, E: Eq, F: Eq, G: Eq, H: Eq, I: Eq, J: Eq, K: Eq> Eq for (A, B, C, D, E, F, G, H, I, J, K)`

`impl<A: PartialOrd + PartialEq, B: PartialOrd + PartialEq, C: PartialOrd + PartialEq, D: PartialOrd + PartialEq, E: PartialOrd + PartialEq, F: PartialOrd + PartialEq, G: PartialOrd + PartialEq, H: PartialOrd + PartialEq, I: PartialOrd + PartialEq, J: PartialOrd + PartialEq, K: PartialOrd + PartialEq> PartialOrd for (A, B, C, D, E, F, G, H, I, J, K)`

`fn lt(&self, other: &(A, B, C, D, E, F, G, H, I, J, K)) -> bool`

`fn le(&self, other: &(A, B, C, D, E, F, G, H, I, J, K)) -> bool`

`fn ge(&self, other: &(A, B, C, D, E, F, G, H, I, J, K)) -> bool`

`fn gt(&self, other: &(A, B, C, D, E, F, G, H, I, J, K)) -> bool`

`impl<A: Ord, B: Ord, C: Ord, D: Ord, E: Ord, F: Ord, G: Ord, H: Ord, I: Ord, J: Ord, K: Ord> Ord for (A, B, C, D, E, F, G, H, I, J, K)`

`fn cmp(&self, other: &(A, B, C, D, E, F, G, H, I, J, K)) -> Ordering`

`impl<A: Default, B: Default, C: Default, D: Default, E: Default, F: Default, G: Default, H: Default, I: Default, J: Default, K: Default> Default for (A, B, C, D, E, F, G, H, I, J, K)`

`fn default() -> (A, B, C, D, E, F, G, H, I, J, K)`

`impl<A, B, C, D, E, F, G, H, I, J, K, L> Tuple12<A, B, C, D, E, F, G, H, I, J, K, L> for (A, B, C, D, E, F, G, H, I, J, K, L)`

`fn val0(self) -> A`

`fn ref0<'a>(&'a self) -> &'a A`

`fn mut0<'a>(&'a mut self) -> &'a mut A`

`fn val1(self) -> B`

`fn ref1<'a>(&'a self) -> &'a B`

`fn mut1<'a>(&'a mut self) -> &'a mut B`

`fn val2(self) -> C`

`fn ref2<'a>(&'a self) -> &'a C`

`fn mut2<'a>(&'a mut self) -> &'a mut C`

`fn val3(self) -> D`

`fn ref3<'a>(&'a self) -> &'a D`

`fn mut3<'a>(&'a mut self) -> &'a mut D`

`fn val4(self) -> E`

`fn ref4<'a>(&'a self) -> &'a E`

`fn mut4<'a>(&'a mut self) -> &'a mut E`

`fn val5(self) -> F`

`fn ref5<'a>(&'a self) -> &'a F`

`fn mut5<'a>(&'a mut self) -> &'a mut F`

`fn val6(self) -> G`

`fn ref6<'a>(&'a self) -> &'a G`

`fn mut6<'a>(&'a mut self) -> &'a mut G`

`fn val7(self) -> H`

`fn ref7<'a>(&'a self) -> &'a H`

`fn mut7<'a>(&'a mut self) -> &'a mut H`

`fn val8(self) -> I`

`fn ref8<'a>(&'a self) -> &'a I`

`fn mut8<'a>(&'a mut self) -> &'a mut I`

`fn val9(self) -> J`

`fn ref9<'a>(&'a self) -> &'a J`

`fn mut9<'a>(&'a mut self) -> &'a mut J`

`fn val10(self) -> K`

`fn ref10<'a>(&'a self) -> &'a K`

`fn mut10<'a>(&'a mut self) -> &'a mut K`

`fn val11(self) -> L`

`fn ref11<'a>(&'a self) -> &'a L`

`fn mut11<'a>(&'a mut self) -> &'a mut L`

`impl<A: Clone, B: Clone, C: Clone, D: Clone, E: Clone, F: Clone, G: Clone, H: Clone, I: Clone, J: Clone, K: Clone, L: Clone> Clone for (A, B, C, D, E, F, G, H, I, J, K, L)`

`fn clone(&self) -> (A, B, C, D, E, F, G, H, I, J, K, L)`

`fn clone_from(&mut self, source: &Self)`

`impl<A: PartialEq, B: PartialEq, C: PartialEq, D: PartialEq, E: PartialEq, F: PartialEq, G: PartialEq, H: PartialEq, I: PartialEq, J: PartialEq, K: PartialEq, L: PartialEq> PartialEq for (A, B, C, D, E, F, G, H, I, J, K, L)`

`fn eq(&self, other: &(A, B, C, D, E, F, G, H, I, J, K, L)) -> bool`

`fn ne(&self, other: &(A, B, C, D, E, F, G, H, I, J, K, L)) -> bool`

`impl<A: Eq, B: Eq, C: Eq, D: Eq, E: Eq, F: Eq, G: Eq, H: Eq, I: Eq, J: Eq, K: Eq, L: Eq> Eq for (A, B, C, D, E, F, G, H, I, J, K, L)`

`impl<A: PartialOrd + PartialEq, B: PartialOrd + PartialEq, C: PartialOrd + PartialEq, D: PartialOrd + PartialEq, E: PartialOrd + PartialEq, F: PartialOrd + PartialEq, G: PartialOrd + PartialEq, H: PartialOrd + PartialEq, I: PartialOrd + PartialEq, J: PartialOrd + PartialEq, K: PartialOrd + PartialEq, L: PartialOrd + PartialEq> PartialOrd for (A, B, C, D, E, F, G, H, I, J, K, L)`

`fn lt(&self, other: &(A, B, C, D, E, F, G, H, I, J, K, L)) -> bool`

`fn le(&self, other: &(A, B, C, D, E, F, G, H, I, J, K, L)) -> bool`

`fn ge(&self, other: &(A, B, C, D, E, F, G, H, I, J, K, L)) -> bool`

`fn gt(&self, other: &(A, B, C, D, E, F, G, H, I, J, K, L)) -> bool`

`impl<A: Ord, B: Ord, C: Ord, D: Ord, E: Ord, F: Ord, G: Ord, H: Ord, I: Ord, J: Ord, K: Ord, L: Ord> Ord for (A, B, C, D, E, F, G, H, I, J, K, L)`

`fn cmp(&self, other: &(A, B, C, D, E, F, G, H, I, J, K, L)) -> Ordering`

`impl<A: Default, B: Default, C: Default, D: Default, E: Default, F: Default, G: Default, H: Default, I: Default, J: Default, K: Default, L: Default> Default for (A, B, C, D, E, F, G, H, I, J, K, L)`

`fn default() -> (A, B, C, D, E, F, G, H, I, J, K, L)`

`impl<T0: Show, T1: Show, T2: Show, T3: Show, T4: Show, T5: Show, T6: Show, T7: Show, T8: Show, T9: Show, T10: Show, T11: Show> Show for (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11)`

`fn fmt(&self, f: &mut Formatter) -> Result`

`impl<T1: Show, T2: Show, T3: Show, T4: Show, T5: Show, T6: Show, T7: Show, T8: Show, T9: Show, T10: Show, T11: Show> Show for (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11)`

`fn fmt(&self, f: &mut Formatter) -> Result`

`impl<T2: Show, T3: Show, T4: Show, T5: Show, T6: Show, T7: Show, T8: Show, T9: Show, T10: Show, T11: Show> Show for (T2, T3, T4, T5, T6, T7, T8, T9, T10, T11)`

`fn fmt(&self, f: &mut Formatter) -> Result`

`impl<T3: Show, T4: Show, T5: Show, T6: Show, T7: Show, T8: Show, T9: Show, T10: Show, T11: Show> Show for (T3, T4, T5, T6, T7, T8, T9, T10, T11)`

`fn fmt(&self, f: &mut Formatter) -> Result`

`impl<T4: Show, T5: Show, T6: Show, T7: Show, T8: Show, T9: Show, T10: Show, T11: Show> Show for (T4, T5, T6, T7, T8, T9, T10, T11)`

`fn fmt(&self, f: &mut Formatter) -> Result`

`impl<T5: Show, T6: Show, T7: Show, T8: Show, T9: Show, T10: Show, T11: Show> Show for (T5, T6, T7, T8, T9, T10, T11)`

`fn fmt(&self, f: &mut Formatter) -> Result`

`impl<T6: Show, T7: Show, T8: Show, T9: Show, T10: Show, T11: Show> Show for (T6, T7, T8, T9, T10, T11)`

`fn fmt(&self, f: &mut Formatter) -> Result`

`impl<T7: Show, T8: Show, T9: Show, T10: Show, T11: Show> Show for (T7, T8, T9, T10, T11)`

`fn fmt(&self, f: &mut Formatter) -> Result`

`impl<T8: Show, T9: Show, T10: Show, T11: Show> Show for (T8, T9, T10, T11)`

`fn fmt(&self, f: &mut Formatter) -> Result`

`impl<T9: Show, T10: Show, T11: Show> Show for (T9, T10, T11)`

`fn fmt(&self, f: &mut Formatter) -> Result`

`impl<T10: Show, T11: Show> Show for (T10, T11)`

`fn fmt(&self, f: &mut Formatter) -> Result`

`impl<T11: Show> Show for (T11)`

`fn fmt(&self, f: &mut Formatter) -> Result`