Primitive Type tuple []

Operations on tuples

To access the N-th element of a tuple one can use N itself as a field of the tuple.

Indexing starts from zero, so 0 returns first value, 1 returns second value, and so on. In general, a tuple with S elements provides aforementioned fields from 0 to S-1.

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

Examples

Accessing elements of a tuple at specified indices:

fn main() { let x = ("colorless", "green", "ideas", "sleep", "furiously"); assert_eq!(x.3, "sleep"); let v = (3, 3); let u = (1, -5); assert_eq!(v.0 * u.0 + v.1 * u.1, -12); }
let x = ("colorless",  "green", "ideas", "sleep", "furiously");
assert_eq!(x.3, "sleep");

let v = (3, 3);
let u = (1, -5);
assert_eq!(v.0 * u.0 + v.1 * u.1, -12);

Using traits implemented for tuples:

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

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

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

Trait Implementations

impl PartialEq<()> for ()

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

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

impl Eq for ()

impl PartialOrd<()> for ()

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

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

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

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

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

impl Ord for ()

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

impl Clone for ()

fn clone(&self)

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

impl Default for ()

fn default()

impl Hash for ()

fn hash<H>(&self, _state: &mut H) where H: Hasher

fn hash_slice<H>(data: &[Self], state: &mut H) where H: Hasher

impl<A> Hash for (A,) where A: Hash

fn hash<S>(&self, state: &mut S) where S: Hasher

fn hash_slice<H>(data: &[Self], state: &mut H) where H: Hasher

impl<A, B> Hash for (A, B) where A: Hash, B: Hash

fn hash<S>(&self, state: &mut S) where S: Hasher

fn hash_slice<H>(data: &[Self], state: &mut H) where H: Hasher

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

fn hash<S>(&self, state: &mut S) where S: Hasher

fn hash_slice<H>(data: &[Self], state: &mut H) where H: Hasher

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

fn hash<S>(&self, state: &mut S) where S: Hasher

fn hash_slice<H>(data: &[Self], state: &mut H) where H: Hasher

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

fn hash<S>(&self, state: &mut S) where S: Hasher

fn hash_slice<H>(data: &[Self], state: &mut H) where H: Hasher

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

fn hash<S>(&self, state: &mut S) where S: Hasher

fn hash_slice<H>(data: &[Self], state: &mut H) where H: Hasher

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

fn hash<S>(&self, state: &mut S) where S: Hasher

fn hash_slice<H>(data: &[Self], state: &mut H) where H: Hasher

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

fn hash<S>(&self, state: &mut S) where S: Hasher

fn hash_slice<H>(data: &[Self], state: &mut H) where H: Hasher

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

fn hash<S>(&self, state: &mut S) where S: Hasher

fn hash_slice<H>(data: &[Self], state: &mut H) where H: Hasher

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

fn hash<S>(&self, state: &mut S) where S: Hasher

fn hash_slice<H>(data: &[Self], state: &mut H) where H: Hasher

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

fn hash<S>(&self, state: &mut S) where S: Hasher

fn hash_slice<H>(data: &[Self], state: &mut H) where H: Hasher

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

fn hash<S>(&self, state: &mut S) where S: Hasher

fn hash_slice<H>(data: &[Self], state: &mut H) where H: Hasher

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

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

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

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

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

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

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

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

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

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

impl<T5, T6, T7, T8, T9, T10, T11> Debug for (T5, T6, T7, T8, T9, T10, T11) where T7: Debug, T5: Debug, T6: Debug, T9: Debug, T11: Debug, T10: Debug, T8: Debug

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

impl<T6, T7, T8, T9, T10, T11> Debug for (T6, T7, T8, T9, T10, T11) where T11: Debug, T8: Debug, T9: Debug, T6: Debug, T7: Debug, T10: Debug

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

impl<T7, T8, T9, T10, T11> Debug for (T7, T8, T9, T10, T11) where T7: Debug, T8: Debug, T10: Debug, T11: Debug, T9: Debug

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

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

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

impl<T9, T10, T11> Debug for (T9, T10, T11) where T11: Debug, T9: Debug, T10: Debug

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

impl<T10, T11> Debug for (T10, T11) where T10: Debug, T11: Debug

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

impl<T11> Debug for (T11,) where T11: Debug

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

impl Debug for ()

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

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

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

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

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

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

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

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

impl<A> PartialOrd<(A,)> for (A,) where A: PartialEq<A> + PartialOrd<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

impl<A> Ord for (A,) where A: Ord

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

impl<A> Default for (A,) where A: Default

fn default() -> (A,)

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

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

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

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

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

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

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

impl<A, B> PartialOrd<(A, B)> for (A, B) where A: PartialEq<A> + PartialOrd<A>, B: PartialEq<B> + PartialOrd<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

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

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

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

fn default() -> (A, B)

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

impl<A, B, C, D> PartialOrd<(A, B, C, D)> for (A, B, C, D) where B: PartialEq<B> + PartialOrd<B>, A: PartialEq<A> + PartialOrd<A>, C: PartialEq<C> + PartialOrd<C>, D: PartialEq<D> + PartialOrd<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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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, B, C, D, E, F, G> Eq for (A, B, C, D, E, F, G) where D: Eq, F: Eq, E: Eq, A: Eq, C: Eq, G: Eq, B: Eq

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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> Clone for (A, B, C, D, E, F, G, H, I, J, K, L) where A: Clone, E: Clone, B: Clone, J: Clone, D: Clone, C: Clone, G: Clone, K: Clone, L: Clone, H: Clone, I: Clone, F: Clone

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

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

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

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

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

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

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

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

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

impl ToSocketAddrs for (IpAddr, u16)

type Iter = IntoIter<SocketAddr>

fn to_socket_addrs(&self) -> Result<IntoIter<SocketAddr>>

impl ToSocketAddrs for (Ipv4Addr, u16)

type Iter = IntoIter<SocketAddr>

fn to_socket_addrs(&self) -> Result<IntoIter<SocketAddr>>

impl ToSocketAddrs for (Ipv6Addr, u16)

type Iter = IntoIter<SocketAddr>

fn to_socket_addrs(&self) -> Result<IntoIter<SocketAddr>>

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

type Iter = IntoIter<SocketAddr>

fn to_socket_addrs(&self) -> Result<IntoIter<SocketAddr>>

impl Rand for ()

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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