Primitive Type tuple1.0.0 [−]

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

Let's cover each of those in turn:

Tuples are finite. In other words, a tuple has a length. Here's a tuple of length 3:

("hello", 5, 'c');Run

'Length' is also sometimes called 'arity' here; each tuple of a different length is a different, distinct type.

Tuples are heterogeneous. This means that each element of the tuple can have a different type. In that tuple above, it has the type:

(&'static str, i32, char)Run

Tuples are a sequence. This means that they can be accessed by position; this is called 'tuple indexing', and it looks like this:

let tuple = ("hello", 5, 'c');

assert_eq!(tuple.0, "hello");
assert_eq!(tuple.1, 5);
assert_eq!(tuple.2, 'c');Run

For more about tuples, see the book.

Trait implementations

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

Due to a temporary restriction in Rust's type system, these traits are only implemented on tuples of arity 12 or less. In the future, this may change.

Examples

Basic usage:

let tuple = ("hello", 5, 'c');

assert_eq!(tuple.0, "hello");Run

Tuples are often used as a return type when you want to return more than one value:

fn calculate_point() -> (i32, i32) {
    // Don't do a calculation, that's not the point of the example
    (4, 5)
}

let point = calculate_point();

assert_eq!(point.0, 4);
assert_eq!(point.1, 5);

// Combining this with patterns can be nicer.

let (x, y) = calculate_point();

assert_eq!(x, 4);
assert_eq!(y, 5);Run

Trait Implementations

`impl<T> RangeArgument<T> for (Bound<T>, Bound<T>)`
[src]

`fn start(&self) -> Bound<&T>`

🔬 This is a nightly-only experimental API. (collections_range #30877)

waiting for dust to settle on inclusive ranges

Start index bound Read more

`fn end(&self) -> Bound<&T>`

🔬 This is a nightly-only experimental API. (collections_range #30877)

waiting for dust to settle on inclusive ranges

End index bound Read more

`impl<'a, T> RangeArgument<T> for (Bound<&'a T>, Bound<&'a T>) where T: 'a + ?Sized`
[src]

`fn start(&self) -> Bound<&T>`

🔬 This is a nightly-only experimental API. (collections_range #30877)

waiting for dust to settle on inclusive ranges

Start index bound Read more

`fn end(&self) -> Bound<&T>`

🔬 This is a nightly-only experimental API. (collections_range #30877)

waiting for dust to settle on inclusive ranges

End index bound Read more

`impl Eq for ()`
[src]

`impl<A> Eq for (A,) where A: Eq`
[src]

`impl<A, B> Eq for (A, B) where A: Eq, B: Eq`
[src]

`impl<A, B, C> Eq for (A, B, C) where A: Eq, B: Eq, C: Eq`
[src]

`impl<A, B, C, D> Eq for (A, B, C, D) where A: Eq, B: Eq, C: Eq, D: Eq`
[src]

`impl<A, B, C, D, E> Eq for (A, B, C, D, E) where A: Eq, B: Eq, C: Eq, D: Eq, E: Eq`
[src]

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

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

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

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

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

`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 A: Eq, B: Eq, C: Eq, D: Eq, E: Eq, F: Eq, G: Eq, H: Eq, I: Eq, J: Eq, K: Eq`
[src]

`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 A: Eq, B: Eq, C: Eq, D: Eq, E: Eq, F: Eq, G: Eq, H: Eq, I: Eq, J: Eq, K: Eq, L: Eq`
[src]

`impl Debug for ()`
[src]

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

Formats the value using the given formatter.

`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 T0: Debug, T1: Debug, T10: Debug, T11: Debug, T2: Debug, T3: Debug, T4: Debug, T5: Debug, T6: Debug, T7: Debug, T8: Debug, T9: Debug`
[src]

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

Formats the value using the given formatter.

`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 T1: Debug, T10: Debug, T11: Debug, T2: Debug, T3: Debug, T4: Debug, T5: Debug, T6: Debug, T7: Debug, T8: Debug, T9: Debug`
[src]

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

Formats the value using the given formatter.

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

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

Formats the value using the given formatter.

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

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

Formats the value using the given formatter.

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

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

Formats the value using the given formatter.

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

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

Formats the value using the given formatter.

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

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

Formats the value using the given formatter.

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

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

Formats the value using the given formatter.

`impl<T8, T9, T10, T11> Debug for (T8, T9, T10, T11) where T10: Debug, T11: Debug, T8: Debug, T9: Debug`
[src]

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

Formats the value using the given formatter.

`impl<T9, T10, T11> Debug for (T9, T10, T11) where T10: Debug, T11: Debug, T9: Debug`
[src]

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

Formats the value using the given formatter.

`impl<T10, T11> Debug for (T10, T11) where T10: Debug, T11: Debug`
[src]

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

Formats the value using the given formatter.

`impl<T11> Debug for (T11,) where T11: Debug`
[src]