Primitive Type tuple

1.0.0

Expand description

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');

‘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)

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');

The sequential nature of the tuple applies to its implementations of various traits. For example, in PartialOrd and Ord, the elements are compared sequentially until the first non-equal set is found.

For more about tuples, see the book.

§Trait implementations

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

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

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

§Examples

Basic usage:

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

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

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);

Homogeneous tuples can be created from arrays of appropriate length:

let array: [u32; 3] = [1, 2, 3];
let tuple: (u32, u32, u32) = array.into();

Trait Implementations§

1.0.0 · Source§

impl<T: Debug> Debug for (T₁, T₂, …, Tₙ)

This trait is implemented for tuples up to twelve items long.

tuple

Primitive Type tuple Copy item path

§Trait implementations

§Examples

Trait Implementations§

impl<T: Debug> Debug for (T₁, T₂, …, Tₙ)

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

impl<T: Default> Default for (T₁, T₂, …, Tₙ)

fn default() -> (T,)

impl<T, ExtendT> Extend<(T₁, T₂, …, Tₙ)> for (ExtendT₁, ExtendT₂, …, ExtendTₙ)where ExtendT: Extend<T>,

fn extend<I: IntoIterator<Item = (T,)>>(&mut self, iter: I)

§Examples

fn extend_one(&mut self, item: (T,))

fn extend_reserve(&mut self, additional: usize)

impl<T> From<[T; N]> for (T₁, T₂, …, Tₙ)

fn from(array: [T; 1]) -> Self

impl<I: Into<IpAddr>> From<(I, u16)> for SocketAddr

fn from(pieces: (I, u16)) -> SocketAddr

impl<T> From<(T₁, T₂, …, Tₙ)> for [T; N]

fn from(tuple: (T,)) -> Self

impl<T, ExtendT> FromIterator<(T₁, T₂, …, Tₙ)> for (ExtendT₁, ExtendT₂, …, ExtendTₙ)where ExtendT: Default + Extend<T>,

fn from_iter<Iter: IntoIterator<Item = (T,)>>(iter: Iter) -> Self

impl<T: Hash> Hash for (T₁, T₂, …, Tₙ)

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

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

impl<T> IntoBounds<T> for (Bound<T>, Bound<T>)

fn into_bounds(self) -> (Bound<T>, Bound<T>)

fn intersect<R>(self, other: R) -> (Bound<T>, Bound<T>)where Self: Sized, T: Ord, R: Sized + IntoBounds<T>,

impl<T: Ord> Ord for (T₁, T₂, …, Tₙ)

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

fn max(self, other: Self) -> Selfwhere Self: Sized,

fn min(self, other: Self) -> Selfwhere Self: Sized,

fn clamp(self, min: Self, max: Self) -> Selfwhere Self: Sized,

impl<T: PartialEq> PartialEq for (T₁, T₂, …, Tₙ)

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

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

impl<T: PartialOrd> PartialOrd for (T₁, T₂, …, Tₙ)

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

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

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

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

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

impl<'a, T: ?Sized + 'a> RangeBounds<T> for (Bound<&'a T>, Bound<&'a T>)

fn start_bound(&self) -> Bound<&T>

fn end_bound(&self) -> Bound<&T>

fn contains<U>(&self, item: &U) -> boolwhere T: PartialOrd<U>, U: ?Sized + PartialOrd<T>,

fn is_empty(&self) -> boolwhere T: PartialOrd,

impl<T> RangeBounds<T> for (Bound<T>, Bound<T>)

fn start_bound(&self) -> Bound<&T>

fn end_bound(&self) -> Bound<&T>

fn contains<U>(&self, item: &U) -> boolwhere T: PartialOrd<U>, U: ?Sized + PartialOrd<T>,

fn is_empty(&self) -> boolwhere T: PartialOrd,

impl<T> SliceIndex<[T]> for (Bound<usize>, Bound<usize>)

type Output = [T]

fn get(self, slice: &[T]) -> Option<&Self::Output>

fn get_mut(self, slice: &mut [T]) -> Option<&mut Self::Output>

unsafe fn get_unchecked(self, slice: *const [T]) -> *const Self::Output

unsafe fn get_unchecked_mut(self, slice: *mut [T]) -> *mut Self::Output

fn index(self, slice: &[T]) -> &Self::Output

fn index_mut(self, slice: &mut [T]) -> &mut Self::Output

impl SliceIndex<ByteStr> for (Bound<usize>, Bound<usize>)

type Output = ByteStr

fn get(self, slice: &ByteStr) -> Option<&Self::Output>

fn get_mut(self, slice: &mut ByteStr) -> Option<&mut Self::Output>

unsafe fn get_unchecked(self, slice: *const ByteStr) -> *const Self::Output

unsafe fn get_unchecked_mut(self, slice: *mut ByteStr) -> *mut Self::Output

fn index(self, slice: &ByteStr) -> &Self::Output

fn index_mut(self, slice: &mut ByteStr) -> &mut Self::Output

impl SliceIndex<str> for (Bound<usize>, Bound<usize>)

§Panics

type Output = str

fn get(self, slice: &str) -> Option<&str>

fn get_mut(self, slice: &mut str) -> Option<&mut str>

unsafe fn get_unchecked(self, slice: *const str) -> *const str

unsafe fn get_unchecked_mut(self, slice: *mut str) -> *mut str

fn index(self, slice: &str) -> &str

fn index_mut(self, slice: &mut str) -> &mut str

impl<T: CloneFromCell> CloneFromCell for (T₁, T₂, …, Tₙ)

impl<T: ConstParamTy_> ConstParamTy_ for (T₁, T₂, …, Tₙ)

impl<T: Eq> Eq for (T₁, T₂, …, Tₙ)

Primitive Type tuple

impl<T, ExtendT> Extend<(T₁, T₂, …, Tₙ)> for (ExtendT₁, ExtendT₂, …, ExtendTₙ)
where ExtendT: Extend<T>,

impl<T, ExtendT> FromIterator<(T₁, T₂, …, Tₙ)> for (ExtendT₁, ExtendT₂, …, ExtendTₙ)
where ExtendT: Default + Extend<T>,

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

fn intersect<R>(self, other: R) -> (Bound<T>, Bound<T>)
where Self: Sized, T: Ord, R: Sized + IntoBounds<T>,

fn max(self, other: Self) -> Self
where Self: Sized,

fn min(self, other: Self) -> Self
where Self: Sized,

fn clamp(self, min: Self, max: Self) -> Self
where Self: Sized,

fn contains<U>(&self, item: &U) -> bool
where T: PartialOrd<U>, U: ?Sized + PartialOrd<T>,

fn is_empty(&self) -> bool
where T: PartialOrd,

fn contains<U>(&self, item: &U) -> bool
where T: PartialOrd<U>, U: ?Sized + PartialOrd<T>,

fn is_empty(&self) -> bool
where T: PartialOrd,

unsafe fn get_unchecked(self, slice: const [T]) -> const Self::Output

unsafe fn get_unchecked_mut(self, slice: mut [T]) -> mut Self::Output

unsafe fn get_unchecked(self, slice: const ByteStr) -> const Self::Output

unsafe fn get_unchecked_mut(self, slice: mut ByteStr) -> mut Self::Output

unsafe fn get_unchecked(self, slice: const str) -> const str

unsafe fn get_unchecked_mut(self, slice: mut str) -> mut str

impl<T> Freeze for (T₁, T₂, …, Tₙ)
where T: Freeze,

impl<T> RefUnwindSafe for (T₁, T₂, …, Tₙ)
where T: RefUnwindSafe,

impl<T> Send for (T₁, T₂, …, Tₙ)
where T: Send,

impl<T> Sync for (T₁, T₂, …, Tₙ)
where T: Sync,

impl<T> Unpin for (T₁, T₂, …, Tₙ)
where T: Unpin,

impl<T> UnsafeUnpin for (T₁, T₂, …, Tₙ)
where T: UnsafeUnpin,

impl<T> UnwindSafe for (T₁, T₂, …, Tₙ)
where T: UnwindSafe,

impl<T> Any for T
where T: 'static + ?Sized,

impl<T> Borrow<T> for T
where T: ?Sized,

impl<T> BorrowMut<T> for T
where T: ?Sized,

impl<T> CloneToUninit for T
where T: Clone,

impl<T, U> Into<U> for T
where U: From<T>,

impl<T, U> TryFrom<U> for T
where U: Into<T>,

impl<T, U> TryInto<U> for T
where U: TryFrom<T>,