# Кортежи в Rust (Tuples): объявление, деструктуризация и unit-тип ()

> Подробное руководство по кортежам (tuples) в языке Rust. Инициализация, доступ по индексам, деструктуризация (pattern matching) и особенности пустой сигнатуры ().

- **URL:** https://eagle2000.space/rust/rust-tuples/
- **Date:** 2026-07-31

- **Tags:** rust, dev

---## Введение. Что такое кортеж

В языке Rust есть несколько базовых композитных типов, позволяющих группировать значения. Один из наиболее простых и часто используемых — это **кортеж (tuple)**. Кортежи особенно удобны, когда нужно вернуть несколько значений из функции без создания отдельной структуры.

## Определение и синтаксис

* **Кортеж** — это композитный сложный тип данных фиксированной длины. После объявления его размер нельзя изменить.
* **Синтаксические правила:** Определяются путем перечисления типов через запятую внутри круглых скобок `()`.
* **Состав типов:** Перечисляемые в кортеже типы могут быть как абсолютно одинаковыми, так и полностью различаться.
* **Вложенность:** Допускается создание вложенных кортежей (кортеж как элемент другого кортежа).

Давайте разберём различные варианты объявления кортежей, способов доступа к их элементам и работу с единичным типом на интерактивных слайдах ниже:


### 💻 Работа с кортежами в Rust


#### Шаг 1

```rust
fn main() {
    // Пример кортежа с разными типами
    let t1: (u32, u8, f64) = (500, 1, 6.28);

    // Пример кортежа с одинаковыми типами
    let t2: (u32, u32, u32) = (10, 20, 30);

    // Пример вложенного кортежа
    let t3: (u32, (u64, u8), u32) = (100, (50, 2), 200);

    println!("t1: {:?}", t1);
    println!("t2: {:?}", t2);
    println!("t3: {:?}", t3);
}
```

**Объявление кортежей в Rust**
- Кортеж создается путем перечисления значений через запятую в круглых скобках `()`.
- Типы элементов могут полностью отличаться (`t1`) или быть одинаковыми (`t2`).
- Кортежи могут содержать другие кортежи в качестве элементов (`t3`), формируя вложенные структуры.


#### Шаг 2

```rust
fn main() {
    let x: (i32, f64, u8) = (500, 6.4, 1);

    // Доступ к элементам по порядковому номеру (индексу)
    let five_hundred = x.0;
    let six_point_four = x.1;
    let one = x.2;

    println!("Элементы: {}, {}, {}", five_hundred, six_point_four, one);

    // Деструктуризация кортежа
    let (a, b, c) = x;
    println!("Деструктуризация: a = {}, b = {}, c = {}", a, b, c);
}
```

**Доступ к элементам и деструктуризация**
- Доступ к конкретным элементам кортежа осуществляется через «точку» и его индекс: `x.0`, `x.1`, `x.2`.
- Индексация начинается с нуля.
- Кортеж также можно разобрать на отдельные переменные с помощью деструктуризации: `let (a, b, c) = x;`.


#### Шаг 3

```rust
#[allow(unused_variables)]
fn main() {
    // Пример блока кода, вычисляющегося в единичный тип ():
    let x: () = {
        println!("Печать внутри блока кода");
        // Выражение с точкой с запятой в конце возвращает ()
    };

    // Функция, не возвращающая значения, возвращает ()
    let y: () = implicit_unit();

    println!("x: {:?}", x);
    println!("y: {:?}", y);
}

// Функция неявно возвращает ()
fn implicit_unit() {
    // Нет выражения возврата
}
```

**Единичный тип (Unit-type)**
- Пустой кортеж `()` представляет собой единичный тип.
- Блоки кода, заканчивающиеся точкой с запятой `;`, вычисляются в `()`.
- Функции, не имеющие явного возвращаемого типа, неявно возвращают `()`.


## Доступ к элементам и вывод типажей

* Доступ к конкретному элементу кортежа осуществляется через **«точку»** и его порядковый **номер (индекс)**, начиная с нуля: например, `x.0`, `x.1`.
* Компилятор Rust автоматически выводит (реализует) некоторые стандартные типажи (traits) для кортежей (такие как `Debug`, `Clone`, `PartialEq` и т.д.), если все типы, входящие в состав кортежа, также реализуют эти типажи.

## Крайний случай: Пустой кортеж (Unit-тип)

* Пустой кортеж записывается как `()`.
* Альтернативное название: **«Единичный» тип (unit type)**.
* **Свойства и поведение:**
  1. Функции, у которых явно не указан возвращаемый тип (ничего не возвращают), на самом деле неявно возвращают пустой кортеж `()`.
  2. Ряд выражений языка вычисляются в пустой кортеж. К ним относятся циклы (например, `for`), а также блоки кода, завершающиеся выражением с точкой с запятой `;`.

---

## Проверь свои знания!

Пройдите короткий интерактивный тест, чтобы закрепить понимание кортежей в Rust.


### 📝 Кортежи в Rust


**1. Какое из утверждений о кортежах в Rust является верным?**

- [ ] Кортежи могут динамически изменять свою длину во время выполнения
- [ ] Кортеж — это композитный тип фиксированной длины, содержащий значения любых типов
- [ ] Элементы кортежа обязаны быть одного и того же типа
- [ ] Кортеж не может быть вложен в другой кортеж

**2. Как получить доступ к первому элементу кортежа с именем `val`?**

- [ ] val[0]
- [ ] val.first()
- [ ] val.0
- [ ] val->0

**3. Что такое единичный (unit) тип в Rust?**

- [ ] Тип данных, обозначающий нулевой указатель (null)
- [ ] Тип данных, который представляет собой пустой кортеж `()`
- [ ] Специальный тип для представления целых чисел от 0 до 1
- [ ] Тип, который может принимать только логические значения true или false

**4. Какое значение неявно возвращает блок кода, завершающийся точкой с запятой `;`?**

- [ ] 0
- [ ] null
- [ ] bool
- [ ] ()

**5. Какое значение возвращает функция, у которой явно не указан возвращаемый тип?**

- [ ] Пустой кортеж `()`
- [ ] Ничего не возвращает и приводит к ошибке компиляции
- [ ] Нулевое значение типа usize
- [ ] Ссылку на текущий контекст