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

Let’s cover each of those in turn:

Tuples arefinite. In other words, a tuple has a length. Here’s a tupleof length3:

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

‘Length’ is also sometimes called ‘arity’ here; each tuple of a differentlength is a different, distinct type.

Tuples areheterogeneous. This means that each element of the tuple canhave a different type. In that tuple above, it has the type:

(&'staticstr, i32, char)

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

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

The sequential nature of the tuple applies to its implementations of varioustraits. For example, inPartialOrd andOrd, the elements are comparedsequentially until the first non-equal set is found.

For more about tuples, seethe book.

§Trait implementations

In this documentation the shorthand(T₁, T₂, …, Tₙ) is used to represent tuples of varyinglength. When that is used, any trait bound expressed onT applies to each element of thetuple independently. Note that this is a convenience notation to avoid repetitivedocumentation, not valid Rust syntax.

Due to a temporary restriction in Rust’s type system, the following traits are onlyimplemented on tuples of arity 12 or less. In the future, this may change:

• PartialEq
• Eq
• PartialOrd
• Ord
• Debug
• Default
• Hash
• From<[T; N]>

The following traits are implemented for tuples of any length. These traits haveimplementations that are automatically generated by the compiler, so are not limited bymissing language features.

• Clone
• Copy
• Send
• Sync
• Unpin
• UnwindSafe
• RefUnwindSafe

§Examples

Basic usage:

lettuple = ("hello",5,'c');assert_eq!(tuple.0,"hello");

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

fncalculate_point() -> (i32, i32) {// Don't do a calculation, that's not the point of the example(4,5)}letpoint = 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);

Homogeneous tuples can be created from arrays of appropriate length:

letarray: [u32;3] = [1,2,3];lettuple: (u32, u32, u32) = array.into();