Primitive Type tuple

一个有限异构序列，(T, U, ..)。

让我们依次介绍其中的每一个：

元组是有限的。换句话说，元组具有长度。这是长度为 3 的元组：

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

‘Length’ 有时也称为 ‘arity’； 每个不同长度的元组都是不同的，不同的类型。

元组是异构的。这意味着元组的每个元素可以具有不同的类型。 在上面的元组中，其类型为：

(&'static str, i32, char)

元组是一个序列。这意味着可以按位置访问它们； 这称为元组索引，它看起来像这样：

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

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

元组的顺序性质适用于各种 traits 的实现。 例如，在 PartialOrd 和 Ord 中，元素按顺序进行比较，直到找到第一个不相等的集合。

有关元组的更多信息，请参见 这本书。

trait 实现

在本文档中，简写 (T₁, T₂,…, Tₙ) 用于表示不同长度的元组。 当使用它时，在 T 上表达的任何 trait bound 都独立地应用于元组的每个元素。 请注意，这是一种方便的符号，以避免重复文档，不是有效的 Rust 语法。

由于 Rust 的类型系统的临时限制，以下 traits 仅在 arity 12 或更少的元组上实现。 在未来，这可能会改变:

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

以下 traits 用于任意长度的元组。 这些 traits 具有由编译器自动生成的实现，因此不受缺少语言特性的限制。

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

Examples

基本用法：

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

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

当您要返回多个值时，通常将元组用作返回类型：

fn calculate_point() -> (i32, i32) {
    // 不要进行计算，这不是示例的重点
    (4, 5)
}

let point = calculate_point();

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

// 将此与模式结合起来会更好。

let (x, y) = calculate_point();

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

可以从适当长度的数组创建同构元组:

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

Trait Implementations

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

这个 trait 在任意长度的元组上实现。

fn clone(&self) -> Self

返回值的副本。

fn clone_from(&mut self, source: &Self)

从 source 执行复制分配。

impl<T> Debug for (T₁, T₂, …, Tₙ)where T: ?Sized + Debug,

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

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

使用给定的格式化程序格式化该值。

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

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

fn default() -> (T,)

返回类型的 “默认值”。

impl<A, B, ExtendA, ExtendB> Extend<(A, B)> for (ExtendA, ExtendB)where ExtendA: Extend<A>, ExtendB: Extend<B>,

fn extend<T: IntoIterator<Item = (A, B)>>(&mut self, into_iter: T)

允许 extend 一个集合的元组也实现 Extend。

另请参见：Iterator::unzip

Examples

let mut tuple = (vec![0], vec![1]);
tuple.extend([(2, 3), (4, 5), (6, 7)]);
assert_eq!(tuple.0, [0, 2, 4, 6]);
assert_eq!(tuple.1, [1, 3, 5, 7]);

// 还允许任意嵌套的元组作为元素
let mut nested_tuple = (vec![1], (vec![2], vec![3]));
nested_tuple.extend([(4, (5, 6)), (7, (8, 9))]);

let (a, (b, c)) = nested_tuple;
assert_eq!(a, [1, 4, 7]);
assert_eq!(b, [2, 5, 8]);
assert_eq!(c, [3, 6, 9]);

fn extend_one(&mut self, item: (A, B))

🔬This is a nightly-only experimental API. (extend_one #72631)

用一个元素扩展一个集合。

fn extend_reserve(&mut self, additional: usize)

🔬This is a nightly-only experimental API. (extend_one #72631)

在集合中为给定数量的附加元素保留容量。

impl<T> From<[T; 1]> for (T,)

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

从输入类型转换为此类型。

impl<T> From<[T; 10]> for (T, T, T, T, T, T, T, T, T, T)

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

从输入类型转换为此类型。

impl<T> From<[T; 11]> for (T, T, T, T, T, T, T, T, T, T, T)

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

从输入类型转换为此类型。

impl<T> From<[T; 12]> for (T, T, T, T, T, T, T, T, T, T, T, T)

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

从输入类型转换为此类型。

impl<T> From<[T; 2]> for (T, T)

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

从输入类型转换为此类型。

impl<T> From<[T; 3]> for (T, T, T)

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

从输入类型转换为此类型。

impl<T> From<[T; 4]> for (T, T, T, T)

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

从输入类型转换为此类型。

impl<T> From<[T; 5]> for (T, T, T, T, T)

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

从输入类型转换为此类型。

impl<T> From<[T; 6]> for (T, T, T, T, T, T)

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

从输入类型转换为此类型。

impl<T> From<[T; 7]> for (T, T, T, T, T, T, T)

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

从输入类型转换为此类型。

impl<T> From<[T; 8]> for (T, T, T, T, T, T, T, T)

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

从输入类型转换为此类型。

impl<T> From<[T; 9]> for (T, T, T, T, T, T, T, T, T)

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

从输入类型转换为此类型。

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

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

将元组结构体 (Into <IpAddr>，u16) 转换为 SocketAddr。

此转换为 IpAddr::V4 创建 SocketAddr::V4，并为 IpAddr::V6 创建 SocketAddr::V6。

u16 被视为新创建的 SocketAddr 的端口。

impl<T> From<(T,)> for [T; 1]

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

从输入类型转换为此类型。

impl<T> From<(T, T)> for [T; 2]

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

从输入类型转换为此类型。

impl<T> From<(T, T, T)> for [T; 3]

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

从输入类型转换为此类型。

impl<T> From<(T, T, T, T)> for [T; 4]

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

从输入类型转换为此类型。

impl<T> From<(T, T, T, T, T)> for [T; 5]

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

从输入类型转换为此类型。

impl<T> From<(T, T, T, T, T, T)> for [T; 6]

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

从输入类型转换为此类型。

impl<T> From<(T, T, T, T, T, T, T)> for [T; 7]

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

从输入类型转换为此类型。

impl<T> From<(T, T, T, T, T, T, T, T)> for [T; 8]

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

从输入类型转换为此类型。

impl<T> From<(T, T, T, T, T, T, T, T, T)> for [T; 9]

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

从输入类型转换为此类型。

impl<T> From<(T, T, T, T, T, T, T, T, T, T)> for [T; 10]

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

从输入类型转换为此类型。

impl<T> From<(T, T, T, T, T, T, T, T, T, T, T)> for [T; 11]

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

从输入类型转换为此类型。

impl<T> From<(T, T, T, T, T, T, T, T, T, T, T, T)> for [T; 12]

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

从输入类型转换为此类型。

impl<T> Hash for (T₁, T₂, …, Tₙ)where T: ?Sized + Hash,

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

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

将该值输入给定的 Hasher。

impl<T> Ord for (T₁, T₂, …, Tₙ)where T: ?Sized + Ord,

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

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

此方法返回 self 和 other 之间的 Ordering。

impl<T> PartialEq<(T,)> for (T₁, T₂, …, Tₙ)where T: ?Sized + PartialEq,

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

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

此方法测试 self 和 other 值是否相等，并由 == 使用。

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

此方法测试 !=。 默认实现几乎总是足够的，并且不应在没有充分理由的情况下被覆盖。

impl<T> PartialOrd<(T,)> for (T₁, T₂, …, Tₙ)where T: ?Sized + PartialOrd,

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

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

如果存在，则此方法返回 self 和 other 值之间的顺序。

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

此方法测试的内容少于 (对于 self 和 other)，并且由 < 操作员使用。

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

此方法测试小于或等于 (对于 self 和 other)，并且由 <= 运算符使用。

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

此方法测试是否大于或等于 (对于 self 和 other)，并且由 >= 运算符使用。

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

此方法测试大于 (对于 self 和 other)，并且由 > 操作员使用。

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>,

如果范围中包含 item，则返回 true。

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>,

如果范围中包含 item，则返回 true。

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

type Output = [T]

方法返回的输出类型。

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

🔬This is a nightly-only experimental API. (slice_index_methods)

如果在边界内，则返回此位置输出的共享引用。

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

🔬This is a nightly-only experimental API. (slice_index_methods)

如果在边界内，则对此位置的输出返回一个可变引用。

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

🔬This is a nightly-only experimental API. (slice_index_methods)

返回此位置输出的共享引用，而不执行任何边界检查。 即使未使用所得的引用，使用越界索引或悬垂的 slice 指针调用此方法也是 [undefined 行为]。

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

🔬This is a nightly-only experimental API. (slice_index_methods)

返回此位置输出的变量引用，而不执行任何边界检查。 即使未使用所得的引用，使用越界索引或悬垂的 slice 指针调用此方法也是 [undefined 行为]。

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

🔬This is a nightly-only experimental API. (slice_index_methods)

返回此位置输出的共享引用，如果越界则会触发 panic。

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

🔬This is a nightly-only experimental API. (slice_index_methods)

返回此位置输出的变量引用，如果越界则会触发 panic。

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

这个 trait 在任意长度的元组上实现。

impl<T> Eq for (T₁, T₂, …, Tₙ)where T: ?Sized + Eq,

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