Home - News ( United States | United Kingdom | Italy | Germany ) - Football scores

Showing content from https://doc.rust-lang.org/nightly/std/primitive.tuple.html below:

tuple - Rust

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:

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

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:

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

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.

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

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

Homogeneous tuples can be created from arrays of appropriate length:

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

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

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

Extends a collection with the contents of an iterator.

Extends a collection with exactly one element.

Reserves capacity in a collection for the given number of additional elements.

Extends a collection with the contents of an iterator.

Extends a collection with exactly one element.

Reserves capacity in a collection for the given number of additional elements.

This trait is implemented for tuples up to twelve items long. The impls for 1- and 3- through 12-ary tuples were stabilized after 2-tuples, in 1.85.0.

Allows to extend a tuple of collections that also implement Extend.

See also: Iterator::unzip

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

Extends a collection with exactly one element.

Reserves capacity in a collection for the given number of additional elements.

Extends a collection with the contents of an iterator.

Extends a collection with exactly one element.

Reserves capacity in a collection for the given number of additional elements.

Inserts all new key-values from the iterator and replaces values with existing keys with new values returned from the iterator.

Extends a collection with the contents of an iterator.

Extends a collection with exactly one element.

Reserves capacity in a collection for the given number of additional elements.

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

Converts to this type from the input type.

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

Converts to this type from the input type.

This implementation turns an iterator of tuples into a tuple of types which implement Default and Extend.

This is similar to Iterator::unzip, but is also composable with other FromIterator implementations:

let string = "1,2,123,4";

let (numbers, lengths): (Vec<_>, Vec<_>) = string
    .split(',')
    .map(|s| s.parse().map(|n: u32| (n, s.len())))
    .collect::<Result<_, _>>()?;

assert_eq!(numbers, [1, 2, 123, 4]);
assert_eq!(lengths, [1, 1, 3, 1]);

This trait is implemented for tuples up to twelve items long. The impls for 1- and 3- through 12-ary tuples were stabilized after 2-tuples, in 1.85.0.

Constructs a BTreeMap<K, V> from an iterator of key-value pairs.

If the iterator produces any pairs with equal keys, all but one of the corresponding values will be dropped.

Constructs a HashMap<K, V> from an iterator of key-value pairs.

If the iterator produces any pairs with equal keys, all but one of the corresponding values will be dropped.

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

Convert this range into the start and end bounds. Returns

.

Compute the intersection of

and

.

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

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

Tests for self and other values to be equal, and is used by ==.

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

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

This method returns an ordering between

and

values if one exists.

Tests less than (for

and

) and is used by the

operator.

Tests less than or equal to (for

and

) and is used by the

operator.

Tests greater than or equal to (for

and

) and is used by the

operator.

Tests greater than (for

and

) and is used by the

operator.

Returns

if

is contained in the range.

Returns

if the range contains no items. One-sided ranges (

, etc) always return

.

Returns

if

is contained in the range.

Returns

if the range contains no items. One-sided ranges (

, etc) always return

.

The output type returned by methods.

Returns a shared reference to the output at this location, if in bounds.

Returns a mutable reference to the output at this location, if in bounds.

Returns a pointer to the output at this location, without performing any bounds checking.

Returns a mutable pointer to the output at this location, without performing any bounds checking.

Returns a shared reference to the output at this location, panicking if out of bounds.

Returns a mutable reference to the output at this location, panicking if out of bounds.

The output type returned by methods.

Returns a shared reference to the output at this location, if in bounds.

Returns a mutable reference to the output at this location, if in bounds.

Returns a pointer to the output at this location, without performing any bounds checking.

Returns a mutable pointer to the output at this location, without performing any bounds checking.

Returns a shared reference to the output at this location, panicking if out of bounds.

Returns a mutable reference to the output at this location, panicking if out of bounds.

Implements substring slicing for arbitrary bounds.

Returns a slice of the given string bounded by the byte indices provided by each bound.

This operation is O(1).

Panics if begin or end (if it exists and once adjusted for inclusion/exclusion) does not point to the starting byte offset of a character (as defined by is_char_boundary), if begin > end, or if end > len.

The output type returned by methods.

Returns a shared reference to the output at this location, if in bounds.

Returns a mutable reference to the output at this location, if in bounds.

Returns a pointer to the output at this location, without performing any bounds checking.

Returns a mutable pointer to the output at this location, without performing any bounds checking.

Returns a shared reference to the output at this location, panicking if out of bounds.

Returns a mutable reference to the output at this location, panicking if out of bounds.

Returned iterator over socket addresses which this type may correspond to.

Returned iterator over socket addresses which this type may correspond to.

Returned iterator over socket addresses which this type may correspond to.

Returned iterator over socket addresses which this type may correspond to.

Returned iterator over socket addresses which this type may correspond to.

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

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

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

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

RetroSearch is an open source project built by @garambo | Open a GitHub Issue

Search and Browse the WWW like it's 1997 | Search results from DuckDuckGo

HTML: 3.2 | Encoding: UTF-8 | Version: 0.7.4