# 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.

- `Clone`
- `PartialEq`
- `Eq`
- `PartialOrd`
- `Ord`
- `Debug`
- `Default`
- `Hash`

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

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

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

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

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

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

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

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

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

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

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

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

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

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

#### `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 C: Eq, B: Eq, D: Eq, A: Eq`

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

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

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

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

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

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

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

#### `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 E: Ord, A: Ord, D: Ord, B: Ord, C: 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 B: Default, E: Default, D: Default, A: Default, C: 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, F: Clone, B: Clone, C: Clone, A: Clone, E: 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 A: PartialEq<A>, D: PartialEq<D>, C: PartialEq<C>, B: PartialEq<B>, E: PartialEq<E>, F: PartialEq<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, B, C, D, E, F> Eq for (A, B, C, D, E, F) where D: Eq, E: Eq, F: Eq, A: Eq, B: Eq, C: Eq`

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

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

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

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

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

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

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

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

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

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

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

# Help

## Keyboard Shortcuts

?
  Show this help dialog
S
  Focus the search field
⇤
  Move up in search results
⇥
  Move down in search results
⏎
  Go to active search result

## Search Tricks

Prefix searches with a type followed by a colon (e.g. `fn:`) to restrict the search to a given type.

Accepted types are: `fn`, `mod`, `struct`, `enum`, `trait`, `type`, `macro`, and `const`.

Search functions by type signature (e.g. `vec -> usize`)