Primitive Type tuple []

A finite heterogeneous sequence, (T, U, ..).

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 B: 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> 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 C: Hash, B: Hash, D: 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 A: Hash, C: Hash, D: Hash, B: Hash, E: 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, C: Hash, A: Hash, F: Hash, B: Hash, E: 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 D: Hash, C: Hash, E: Hash, B: Hash, A: Hash, G: Hash, F: 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 F: Hash, B: Hash, C: Hash, H: Hash, E: Hash, A: Hash, G: 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> Hash for (A, B, C, D, E, F, G, H, I) where A: Hash, D: Hash, I: Hash, G: Hash, E: Hash, B: Hash, F: Hash, H: 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, I, J> Hash for (A, B, C, D, E, F, G, H, I, J) where I: Hash, E: Hash, D: Hash, C: Hash, G: Hash, F: Hash, J: Hash, A: Hash, B: 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 K: Hash, F: Hash, D: Hash, C: Hash, B: Hash, E: Hash, J: Hash, G: Hash, I: Hash, A: 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, L> Hash for (A, B, C, D, E, F, G, H, I, J, K, L) where J: Hash, L: Hash, I: Hash, C: Hash, K: Hash, G: Hash, B: Hash, D: Hash, F: Hash, H: 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<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 T1: Debug, T0: Debug, T6: Debug, T10: Debug, T5: Debug, T11: Debug, T4: Debug, T8: Debug, T9: Debug, T2: Debug, T7: 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 T4: Debug, T3: Debug, T10: Debug, T7: Debug, T1: Debug, T8: Debug, T11: Debug, T5: Debug, T6: Debug, T9: Debug, T2: 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 T2: Debug, T9: Debug, T8: Debug, T5: Debug, T4: Debug, T3: Debug, T10: Debug, T11: Debug, T7: Debug, T6: 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 T3: Debug, T9: Debug, T5: Debug, T11: Debug, T6: Debug, T4: Debug, T10: Debug, T7: Debug, T8: 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 T8: Debug, T10: Debug, T7: Debug, T5: Debug, T4: Debug, T6: Debug, T9: Debug, T11: 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 T10: Debug, T9: Debug, T7: Debug, T6: Debug, T8: Debug, T11: Debug, T5: 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 T8: Debug, T9: Debug, T6: Debug, T10: Debug, T7: Debug, T11: Debug

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

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

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

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

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

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

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

impl<T10, T11> Debug for (T10, T11) where T11: Debug, T10: 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 B: PartialEq<B>, A: PartialEq<A>

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 B: PartialEq<B> + PartialOrd<B>, A: PartialEq<A> + PartialOrd<A>

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 B: Clone, C: Clone, A: 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, A: Eq, C: Eq

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

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 C: Ord, A: Ord, B: Ord

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

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

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

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

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

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 B: Ord, D: Ord, C: Ord, A: Ord

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

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

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

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

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

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 C: Ord, E: Ord, A: Ord, D: Ord, B: 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, B: Default, C: Default, E: Default

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

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

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 E: Eq, B: Eq, C: Eq, F: Eq, A: Eq, D: Eq

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

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 F: Ord, B: Ord, C: Ord, A: Ord, E: Ord, D: 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 E: Default, A: Default, B: Default, C: Default, F: Default, D: 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 A: Clone, D: Clone, G: Clone, B: Clone, E: Clone, F: Clone, C: 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 G: PartialEq<G>, A: PartialEq<A>, E: PartialEq<E>, C: PartialEq<C>, D: PartialEq<D>, F: PartialEq<F>, B: PartialEq<B>

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, B: Eq, F: Eq, G: Eq, E: Eq, A: Eq, C: 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 F: PartialEq<F> + PartialOrd<F>, C: PartialEq<C> + PartialOrd<C>, B: PartialEq<B> + PartialOrd<B>, D: PartialEq<D> + PartialOrd<D>, G: PartialEq<G> + PartialOrd<G>, E: PartialEq<E> + PartialOrd<E>, A: PartialEq<A> + PartialOrd<A>

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, A: Ord, G: Ord, E: Ord, D: Ord, C: Ord, F: 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 A: Default, E: Default, D: Default, C: Default, G: Default, B: Default, F: 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 A: Clone, E: Clone, D: Clone, C: Clone, F: Clone, H: Clone, G: Clone, B: 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 A: PartialEq<A>, F: PartialEq<F>, H: PartialEq<H>, G: PartialEq<G>, B: PartialEq<B>, C: PartialEq<C>, D: PartialEq<D>, E: PartialEq<E>

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 B: Eq, F: Eq, G: Eq, H: Eq, A: Eq, D: Eq, C: Eq, E: 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 B: PartialEq<B> + PartialOrd<B>, C: PartialEq<C> + PartialOrd<C>, H: PartialEq<H> + PartialOrd<H>, G: PartialEq<G> + PartialOrd<G>, F: PartialEq<F> + PartialOrd<F>, D: PartialEq<D> + PartialOrd<D>, A: PartialEq<A> + PartialOrd<A>, 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 G: Ord, C: Ord, H: Ord, A: Ord, E: Ord, D: Ord, B: Ord, F: 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 A: Default, E: Default, B: Default, D: Default, C: Default, H: Default, F: Default, G: 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, E: Clone, C: Clone, I: Clone, H: Clone, B: Clone, G: Clone, F: Clone, D: 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 H: PartialEq<H>, D: PartialEq<D>, C: PartialEq<C>, B: PartialEq<B>, F: PartialEq<F>, I: PartialEq<I>, G: PartialEq<G>, E: PartialEq<E>, A: PartialEq<A>

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 G: Eq, D: Eq, I: Eq, C: Eq, H: Eq, B: Eq, E: Eq, F: Eq, A: 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 E: PartialEq<E> + PartialOrd<E>, C: PartialEq<C> + PartialOrd<C>, I: PartialEq<I> + PartialOrd<I>, F: PartialEq<F> + PartialOrd<F>, G: PartialEq<G> + PartialOrd<G>, D: PartialEq<D> + PartialOrd<D>, H: PartialEq<H> + PartialOrd<H>, B: PartialEq<B> + PartialOrd<B>, A: PartialEq<A> + PartialOrd<A>

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, G: Ord, D: Ord, A: Ord, F: Ord, C: Ord, I: Ord, H: Ord, E: 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 E: Default, A: Default, G: Default, H: Default, B: Default, I: Default, F: Default, C: Default, D: 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 E: Clone, H: Clone, B: Clone, F: Clone, G: Clone, A: Clone, C: Clone, J: Clone, D: Clone, I: 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>, B: PartialEq<B>, E: PartialEq<E>, H: PartialEq<H>, F: PartialEq<F>, I: PartialEq<I>, C: PartialEq<C>, A: PartialEq<A>, D: PartialEq<D>, G: PartialEq<G>

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

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

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

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

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