Rust
Кортеж

Вступление

Синтаксис

• (A, B, C) // трехстрочный (кортеж с тремя элементами), первый элемент которого имеет тип A, второй тип B и третий тип C
• (A, B) // двухстрочный, два элемента которого имеют тип A и B соответственно
• (А,) // один-кортеж (обратите внимание на завершающем , ), который содержит только один элемент типа А
• () // пустой кортеж, который является как типом, так и единственным типом элемента

Типы кортежей и значения кортежа

Кортежи ржавчины, как и на большинстве других языков, представляют собой списки фиксированного размера, элементы которых могут быть разных типов.

// Tuples in Rust are comma-separated values or types enclosed in parentheses.
let _ = ("hello", 42, true);
// The type of a tuple value is a type tuple with the same number of elements.
// Each element in the type tuple is the type of the corresponding value element.
let _: (i32, bool) = (42, true);
// Tuples can have any number of elements, including one ..
let _: (bool,) = (true,);
// .. or even zero!
let _: () = ();
// this last type has only one possible value, the empty tuple ()
// this is also the type (and value) of the return value of functions
// that do not return a value ..
let _: () = println!("hello");
// .. or of expressions with no value.
let mut a = 0;
let _: () = if true { a += 1; };

Соответствие значений кортежа

Программы ржавчины широко используют шаблоны для деконструирования значений, независимо от того, используют ли они match , if let или деконструируют шаблоны let . Кортежи могут быть деконструированы, как вы могли бы ожидать, используя match

fn foo(x: (&str, isize, bool)) {
    match x {
        (_, 42, _) => println!("it's 42"),
        (_, _, false) => println!("it's not true"),
        _ => println!("it's something else"),
    }
}

или if let

fn foo(x: (&str, isize, bool)) {
    if let (_, 42, _) = x {
        println!("it's 42");
    } else {
        println!("it's something else");
    }
}

вы также можете связать внутри кортежа, используя let -deconstruction

fn foo(x: (&str, isize, bool)) {
    let (_, n, _) = x;
    println!("the number is {}", n);
}

Внутри кортежей

Чтобы напрямую обращаться к элементам кортежа, вы можете использовать формат .n для доступа к n му элементу

let x = ("hello", 42, true);
assert_eq!(x.0, "hello");
assert_eq!(x.1, 42);
assert_eq!(x.2, true);

Вы также можете частично выйти из кортежа

let x = (String::from("hello"), 42);
let (s, _) = x;
let (_, n) = x;
println!("{}, {}", s, n);
// the following would fail however, since x.0 has already been moved
// let foo = x.0;

основы

Кортеж - это просто конкатенация нескольких значений:

• возможных типов
• число и типы которых известны статически

Например, (1, "Hello") является 2-мя элементами, состоящими из i32 и a &str , и его тип обозначается как (i32, &'static str) аналогично его значению.

Чтобы получить доступ к элементу кортежа, просто просто используется его индекс:

let tuple =  (1, "Hello");
println!("First element: {}, second element: {}", tuple.0, tuple.1);

Поскольку кортеж встроен, также возможно использовать сопоставление образцов по кортежам:

match (1, "Hello") {
    (i, _) if i < 0 => println!("Negative integer: {}", i),
    (_, s) => println!("{} World", s),
}

Особые случаи

Корневой элемент 0: () также называется единицей , типом единицы или одноточечным типом и используется для обозначения отсутствия значимых значений. Это возвращаемый тип функции по умолчанию (когда -> не указано). См. Также: Какой тип «type ()» в Rust? ,

1-элементный кортеж: (a,) с конечной запятой обозначает 1 элементный кортеж. Форма без запятой (a) интерпретируется как выражение, заключенное в круглые скобки, и оценивается как a .

И хотя мы и находимся в этом, конечные запятые всегда принимаются: (1, "Hello",) .

Ограничения

Сегодня язык ржавчины не поддерживает вариации , кроме кортежей. Поэтому невозможно просто реализовать признак для всех кортежей, и в результате стандартные черты реализуются только для кортежей до ограниченного числа элементов (сегодня до 12 включительно). Поддерживаются кортежи с большим количеством элементов, но не реализуют стандартные черты (хотя вы можете реализовать свои собственные черты).

Это ограничение, мы надеемся, будет снято в будущем.

Распаковка кортежей

// It's possible to unpack tuples to assign their inner values to variables
let tup = (0, 1, 2);
// Unpack the tuple into variables a, b, and c
let (a, b, c) = tup;

assert_eq!(a, 0);
assert_eq!(b, 1);

// This works for nested data structures and other complex data types
let complex = ((1, 2), 3, Some(0));

let (a, b, c) = complex;
let (aa, ab) = a;

assert_eq!(aa, 1);
assert_eq!(ab, 2);