Primitive Type tuple [-]  [+]

Operations on tuples

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

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.

Examples

Using methods:

#[allow(deprecated)] fn main() { let pair = ("pi", 3.14f64); assert_eq!(pair.val0(), "pi"); assert_eq!(pair.val1(), 3.14f64); }
#[allow(deprecated)]
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 PartialEq<()> for ()

fn eq(&self, _other: &()) -> bool

fn ne(&self, _other: &()) -> bool

fn ne(&self, &()) -> bool

impl Eq for ()

fn assert_receiver_is_total_eq(&self)

impl PartialOrd<()> for ()

fn partial_cmp(&self, &()) -> Option<Ordering>

fn lt(&self, &()) -> bool

fn le(&self, &()) -> bool

fn gt(&self, &()) -> bool

fn ge(&self, &()) -> bool

impl Ord for ()

fn cmp(&self, _other: &()) -> Ordering

impl Clone for ()

fn clone(&self)

Return a deep copy of the value.

fn clone_from(&mut self, &())

impl Default for ()

fn default()

impl<S: Writer> Hash<S> for ()

fn hash(&self, state: &mut S)

impl<S: Writer, A: Hash<S>> Hash<S> for (A,)

fn hash(&self, state: &mut S)

impl<S: Writer, A: Hash<S>, B: Hash<S>> Hash<S> for (A, B)

fn hash(&self, state: &mut S)

impl<S: Writer, A: Hash<S>, B: Hash<S>, C: Hash<S>> Hash<S> for (A, B, C)

fn hash(&self, state: &mut S)

impl<S: Writer, A: Hash<S>, B: Hash<S>, C: Hash<S>, D: Hash<S>> Hash<S> for (A, B, C, D)

fn hash(&self, state: &mut S)

impl<S: Writer, A: Hash<S>, B: Hash<S>, C: Hash<S>, D: Hash<S>, E: Hash<S>> Hash<S> for (A, B, C, D, E)

fn hash(&self, state: &mut S)

impl<S: Writer, A: Hash<S>, B: Hash<S>, C: Hash<S>, D: Hash<S>, E: Hash<S>, F: Hash<S>> Hash<S> for (A, B, C, D, E, F)

fn hash(&self, state: &mut S)

impl<S: Writer, A: Hash<S>, B: Hash<S>, C: Hash<S>, D: Hash<S>, E: Hash<S>, F: Hash<S>, G: Hash<S>> Hash<S> for (A, B, C, D, E, F, G)

fn hash(&self, state: &mut S)

impl<S: Writer, A: Hash<S>, B: Hash<S>, C: Hash<S>, D: Hash<S>, E: Hash<S>, F: Hash<S>, G: Hash<S>, H: Hash<S>> Hash<S> for (A, B, C, D, E, F, G, H)

fn hash(&self, state: &mut S)

impl<S: Writer, A: Hash<S>, B: Hash<S>, C: Hash<S>, D: Hash<S>, E: Hash<S>, F: Hash<S>, G: Hash<S>, H: Hash<S>, I: Hash<S>> Hash<S> for (A, B, C, D, E, F, G, H, I)

fn hash(&self, state: &mut S)

impl<S: Writer, A: Hash<S>, B: Hash<S>, C: Hash<S>, D: Hash<S>, E: Hash<S>, F: Hash<S>, G: Hash<S>, H: Hash<S>, I: Hash<S>, J: Hash<S>> Hash<S> for (A, B, C, D, E, F, G, H, I, J)

fn hash(&self, state: &mut S)

impl<S: Writer, A: Hash<S>, B: Hash<S>, C: Hash<S>, D: Hash<S>, E: Hash<S>, F: Hash<S>, G: Hash<S>, H: Hash<S>, I: Hash<S>, J: Hash<S>, K: Hash<S>> Hash<S> for (A, B, C, D, E, F, G, H, I, J, K)

fn hash(&self, state: &mut S)

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

fn hash(&self, state: &mut S)

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<(), Error>

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<(), Error>

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<(), Error>

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<(), Error>

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<(), Error>

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<(), Error>

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<(), Error>

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<(), Error>

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

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

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

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

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

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

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

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

impl Show for ()

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

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

fn val0(self) -> A

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

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

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

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

fn clone_from(&mut self, &(A,))

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

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

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

fn ne(&self, &(A,)) -> bool

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

fn assert_receiver_is_total_eq(&self)

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

fn partial_cmp(&self, other: &(A,)) -> Option<Ordering>

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

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

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

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

fn lt(&self, &(A,)) -> bool

fn le(&self, &(A,)) -> bool

fn gt(&self, &(A,)) -> bool

fn ge(&self, &(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 self) -> &'a A

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

fn val1(self) -> B

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

fn mut1(&'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, &(A, B))

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

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

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

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

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

fn assert_receiver_is_total_eq(&self)

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

fn partial_cmp(&self, other: &(A, B)) -> Option<Ordering>

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

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

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

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

fn ge(&self, &(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 self) -> &'a A

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

fn val1(self) -> B

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

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

fn val2(self) -> C

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

fn mut2(&'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, &(A, B, C))

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

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

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

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

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

fn assert_receiver_is_total_eq(&self)

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

fn partial_cmp(&self, other: &(A, B, C)) -> Option<Ordering>

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

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

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

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

fn ge(&self, &(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 self) -> &'a A

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

fn val1(self) -> B

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

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

fn val2(self) -> C

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

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

fn val3(self) -> D

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

fn mut3(&'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, &(A, B, C, D))

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

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

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

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

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

fn assert_receiver_is_total_eq(&self)

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

fn partial_cmp(&self, other: &(A, B, C, D)) -> Option<Ordering>

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

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

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

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

fn ge(&self, &(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 self) -> &'a A

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

fn val1(self) -> B

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

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

fn val2(self) -> C

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

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

fn val3(self) -> D

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

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

fn val4(self) -> E

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

fn mut4(&'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, &(A, B, C, D, E))

impl<A: PartialEq<A>, B: PartialEq<B>, C: PartialEq<C>, D: PartialEq<D>, E: PartialEq<E>> PartialEq<(A, B, C, D, E)> 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

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

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

fn assert_receiver_is_total_eq(&self)

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

fn partial_cmp(&self, other: &(A, B, C, D, E)) -> Option<Ordering>

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

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

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

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

fn ge(&self, &(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 self) -> &'a A

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

fn val1(self) -> B

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

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

fn val2(self) -> C

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

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

fn val3(self) -> D

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

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

fn val4(self) -> E

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

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

fn val5(self) -> F

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

fn mut5(&'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, &(A, B, C, D, E, F))

impl<A: PartialEq<A>, B: PartialEq<B>, C: PartialEq<C>, D: PartialEq<D>, E: PartialEq<E>, F: PartialEq<F>> PartialEq<(A, B, C, D, E, F)> 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

fn ne(&self, &(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)

fn assert_receiver_is_total_eq(&self)

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

fn partial_cmp(&self, other: &(A, B, C, D, E, F)) -> Option<Ordering>

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

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

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

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

fn ge(&self, &(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 self) -> &'a A

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

fn val1(self) -> B

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

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

fn val2(self) -> C

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

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

fn val3(self) -> D

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

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

fn val4(self) -> E

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

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

fn val5(self) -> F

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

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

fn val6(self) -> G

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

fn mut6(&'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, &(A, B, C, D, E, F, G))

impl<A: PartialEq<A>, B: PartialEq<B>, C: PartialEq<C>, D: PartialEq<D>, E: PartialEq<E>, F: PartialEq<F>, G: PartialEq<G>> PartialEq<(A, B, C, D, E, F, G)> 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

fn ne(&self, &(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)

fn assert_receiver_is_total_eq(&self)

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

fn partial_cmp(&self, other: &(A, B, C, D, E, F, G)) -> Option<Ordering>

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

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

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

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

fn ge(&self, &(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 self) -> &'a A

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

fn val1(self) -> B

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

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

fn val2(self) -> C

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

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

fn val3(self) -> D

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

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

fn val4(self) -> E

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

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

fn val5(self) -> F

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

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

fn val6(self) -> G

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

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

fn val7(self) -> H

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

fn mut7(&'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, &(A, B, C, D, E, F, G, H))

impl<A: PartialEq<A>, B: PartialEq<B>, C: PartialEq<C>, D: PartialEq<D>, E: PartialEq<E>, F: PartialEq<F>, G: PartialEq<G>, H: PartialEq<H>> PartialEq<(A, B, C, D, E, F, G, H)> 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

fn ne(&self, &(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)

fn assert_receiver_is_total_eq(&self)

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

fn partial_cmp(&self, other: &(A, B, C, D, E, F, G, H)) -> Option<Ordering>

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

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

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

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

fn ge(&self, &(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 self) -> &'a A

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

fn val1(self) -> B

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

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

fn val2(self) -> C

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

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

fn val3(self) -> D

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

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

fn val4(self) -> E

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

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

fn val5(self) -> F

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

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

fn val6(self) -> G

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

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

fn val7(self) -> H

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

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

fn val8(self) -> I

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

fn mut8(&'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, &(A, B, C, D, E, F, G, H, I))

impl<A: PartialEq<A>, B: PartialEq<B>, C: PartialEq<C>, D: PartialEq<D>, E: PartialEq<E>, F: PartialEq<F>, G: PartialEq<G>, H: PartialEq<H>, I: PartialEq<I>> PartialEq<(A, B, C, D, E, F, G, H, I)> 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

fn ne(&self, &(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)

fn assert_receiver_is_total_eq(&self)

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

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

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

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

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

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

fn ge(&self, &(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 self) -> &'a A

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

fn val1(self) -> B

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

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

fn val2(self) -> C

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

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

fn val3(self) -> D

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

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

fn val4(self) -> E

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

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

fn val5(self) -> F

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

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

fn val6(self) -> G

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

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

fn val7(self) -> H

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

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

fn val8(self) -> I

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

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

fn val9(self) -> J

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

fn mut9(&'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, &(A, B, C, D, E, F, G, H, I, J))

impl<A: PartialEq<A>, B: PartialEq<B>, C: PartialEq<C>, D: PartialEq<D>, E: PartialEq<E>, F: PartialEq<F>, G: PartialEq<G>, H: PartialEq<H>, I: PartialEq<I>, J: PartialEq<J>> PartialEq<(A, B, C, D, E, F, G, H, I, J)> 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

fn ne(&self, &(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)

fn assert_receiver_is_total_eq(&self)

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

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

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

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

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

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

fn ge(&self, &(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 self) -> &'a A

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

fn val1(self) -> B

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

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

fn val2(self) -> C

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

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

fn val3(self) -> D

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

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

fn val4(self) -> E

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

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

fn val5(self) -> F

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

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

fn val6(self) -> G

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

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

fn val7(self) -> H

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

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

fn val8(self) -> I

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

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

fn val9(self) -> J

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

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

fn val10(self) -> K

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

fn mut10(&'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, &(A, B, C, D, E, F, G, H, I, J, K))

impl<A: PartialEq<A>, B: PartialEq<B>, C: PartialEq<C>, D: PartialEq<D>, E: PartialEq<E>, F: PartialEq<F>, G: PartialEq<G>, H: PartialEq<H>, I: PartialEq<I>, J: PartialEq<J>, K: PartialEq<K>> PartialEq<(A, B, C, D, E, F, G, H, I, J, K)> 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

fn ne(&self, &(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)

fn assert_receiver_is_total_eq(&self)

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

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

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

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

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

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

fn ge(&self, &(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 self) -> &'a A

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

fn val1(self) -> B

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

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

fn val2(self) -> C

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

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

fn val3(self) -> D

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

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

fn val4(self) -> E

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

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

fn val5(self) -> F

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

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

fn val6(self) -> G

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

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

fn val7(self) -> H

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

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

fn val8(self) -> I

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

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

fn val9(self) -> J

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

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

fn val10(self) -> K

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

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

fn val11(self) -> L

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

fn mut11(&'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, &(A, B, C, D, E, F, G, H, I, J, K, L))

impl<A: PartialEq<A>, B: PartialEq<B>, C: PartialEq<C>, D: PartialEq<D>, E: PartialEq<E>, F: PartialEq<F>, G: PartialEq<G>, H: PartialEq<H>, I: PartialEq<I>, J: PartialEq<J>, K: PartialEq<K>, L: PartialEq<L>> PartialEq<(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 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

fn ne(&self, &(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)

fn assert_receiver_is_total_eq(&self)

impl<A: PartialEq<A> + PartialOrd<A>, B: PartialEq<B> + PartialOrd<B>, C: PartialEq<C> + PartialOrd<C>, D: PartialEq<D> + PartialOrd<D>, E: PartialEq<E> + PartialOrd<E>, F: PartialEq<F> + PartialOrd<F>, G: PartialEq<G> + PartialOrd<G>, H: PartialEq<H> + PartialOrd<H>, I: PartialEq<I> + PartialOrd<I>, J: PartialEq<J> + PartialOrd<J>, K: PartialEq<K> + PartialOrd<K>, L: PartialEq<L> + PartialOrd<L>> PartialOrd<(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 partial_cmp(&self, other: &(A, B, C, D, E, F, G, H, I, J, K, L)) -> Option<Ordering>

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

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

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

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

fn ge(&self, &(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 ToSocketAddr for (IpAddr, u16)

fn to_socket_addr(&self) -> IoResult<SocketAddr>

fn to_socket_addr_all(&self) -> IoResult<Vec<SocketAddr>>

impl<'a> ToSocketAddr for (&'a str, u16)

fn to_socket_addr_all(&self) -> IoResult<Vec<SocketAddr>>

fn to_socket_addr(&self) -> IoResult<SocketAddr>

impl Rand for ()

fn rand<R: Rng>(&mut R)

impl<A: Rand> Rand for (A,)

fn rand<R: Rng>(_rng: &mut R) -> (A,)

impl<A: Rand, B: Rand> Rand for (A, B)

fn rand<R: Rng>(_rng: &mut R) -> (A, B)

impl<A: Rand, B: Rand, C: Rand> Rand for (A, B, C)

fn rand<R: Rng>(_rng: &mut R) -> (A, B, C)

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

fn rand<R: Rng>(_rng: &mut R) -> (A, B, C, D)

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

fn rand<R: Rng>(_rng: &mut R) -> (A, B, C, D, E)

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

fn rand<R: Rng>(_rng: &mut R) -> (A, B, C, D, E, F)

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

fn rand<R: Rng>(_rng: &mut R) -> (A, B, C, D, E, F, G)

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

fn rand<R: Rng>(_rng: &mut R) -> (A, B, C, D, E, F, G, H)

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

fn rand<R: Rng>(_rng: &mut R) -> (A, B, C, D, E, F, G, H, I)

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

fn rand<R: Rng>(_rng: &mut R) -> (A, B, C, D, E, F, G, H, I, J)

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

fn rand<R: Rng>(_rng: &mut R) -> (A, B, C, D, E, F, G, H, I, J, K)

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

fn rand<R: Rng>(_rng: &mut R) -> (A, B, C, D, E, F, G, H, I, J, K, L)