Примитивный тип unit (единичный тип)

Тип (), также называемый "единичным" (unit).

Тип () имеет ровно одно значение (), и используется, когда нет другого значимого значения, которое может быть возвращено.

Описание

() чаще всего встречается неявно:

Функции без указания возвращаемого типа (-> ...) неявно имеют тип возвращаемого значения ().

Эти функции эквивалентны:

#![allow(unused)]
fn main() {
fn long() -> () {}
fn short() {}
}

Использование точки с запятой `;`

Точка с запятой ; может использоваться для отбрасывания результата выражения в конце блока, заставляя выражение (и, следовательно, блок) вычисляться в ().

Примеры

#![allow(unused)]
fn main() {
fn returns_i64() -> i64 {
    1i64
}

fn returns_unit() {
    1i64;  // Точка с запятой отбрасывает результат
}

let is_i64 = {
    returns_i64()  // Без точки с запятой - возвращает i64
};

let is_unit = {
    returns_i64();  // С точкой с запятой - возвращает ()
};
}

Реализации трейтов

Реализация `Debug`

Метод	Описание	Версия	Пример
`fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>`	Форматирует значение с помощью заданного форматировщика.	1.0.0	`println!("{:?}", ()); // Выводит: ()`

Реализация `Default`

Метод	Описание	Константность	Версия
`default() -> ()`	Возвращает значение по умолчанию для `()`.	-	1.0.0

Реализация `Extend<()>` для `()`

Метод	Описание	Версия	Статус
`extend<T>(&mut self, iter: T)`	Расширяет коллекцию содержимым итератора.	1.28.0	Стабильный
`extend_one(&mut self, _item: ())`	Расширяет коллекцию ровно одним элементом.	Nightly	Экспериментальный
`extend_reserve(&mut self, additional: usize)`	Резервирует ёмкость в коллекции для заданного количества дополнительных элементов.	Nightly	Экспериментальный

Реализация `FromIterator<()>` для `()`

Метод	Описание	Версия	Пример
`from_iter<I>(iter: I)`	Создаёт значение из итератора. Сворачивает все единичные элементы из итератора в один.	1.23.0	`let res: Result<()> = data.iter().map(

Реализация `Hash`

Метод	Описание	Версия
`hash<H>(&self, _state: &mut H)`	Подаёт это значение в заданный Hasher.	1.0.0
`hash_slice<H>(data: &[Self], state: &mut H)`	Подаёт срез этого типа в заданный Hasher.	1.3.0

Реализация `Ord`

Метод	Описание	Константность	Версия
`cmp(&self, _other: &()) -> Ordering`	Сравнивает `self` с `other`.	-	1.0.0
`max(self, other: Self) -> Self`	Сравнивает и возвращает максимум двух значений.	-	1.21.0
`min(self, other: Self) -> Self`	Сравнивает и возвращает минимум двух значений.	-	1.21.0
`clamp(self, min: Self, max: Self) -> Self`	Ограничивает значение определённым интервалом.	-	1.50.0

Реализация `PartialEq`

Метод	Описание	Константность	Версия
`eq(&self, _other: &()) -> bool`	Проверяет равенство значений `self` и `other`.	-	1.0.0
`ne(&self, _other: &()) -> bool`	Проверяет неравенство значений.	-	1.0.0

Реализация `PartialOrd`

Метод	Описание	Константность	Версия
`partial_cmp(&self, _: &()) -> Option<Ordering>`	Возвращает упорядочение между `self` и `other`, если оно существует.	-	1.0.0
`lt(&self, other: &Rhs) -> bool`	Проверяет "меньше" (для `self` и `other`).	-	1.0.0
`le(&self, other: &Rhs) -> bool`	Проверяет "меньше или равно" (для `self` и `other`).	-	1.0.0
`gt(&self, other: &Rhs) -> bool`	Проверяет "больше" (для `self` и `other`).	-	1.0.0
`ge(&self, other: &Rhs) -> bool`	Проверяет "больше или равно" (для `self` и `other`).	-	1.0.0

Реализация `Termination`

Метод	Описание	Версия
`report(self) -> ExitCode`	Вызывается для получения представления значения в виде кода завершения.	1.61.0

Примеры использования

1. Функции без возвращаемого значения

#![allow(unused)]
fn main() {
fn print_hello() {
    println!("Hello!");
    // Неявно возвращает ()
}

fn explicit_return() -> () {
    println!("Explicit");
    // Явно возвращает ()
}
}

2. Отбрасывание результатов

#![allow(unused)]
fn main() {
let x = {
    let y = 5 + 3;
    y * 2  // Возвращает 16 (i32)
};

let unit = {
    let y = 5 + 3;
    y * 2;  // Точка с запятой отбрасывает результат, возвращает ()
};
}

3. Коллекции и итераторы

#![allow(unused)]
fn main() {
use std::io::*;

let data = vec![1, 2, 3, 4, 5];
// Собираем все результаты записи в единый Result<()>
let res: Result<()> = data.iter()
    .map(|x| writeln!(stdout(), "{x}"))
    .collect();
assert!(res.is_ok());
}

4. Паттерн-матчинг

#![allow(unused)]
fn main() {
fn process_result(result: Result<i32, String>) -> () {
    match result {
        Ok(value) => println!("Got value: {}", value),
        Err(error) => println!("Error: {}", error),
    }
}
}

Автоматические реализации трейтов

Трейт	Описание
`Freeze`	Тип можно безопасно замораживать.
`RefUnwindSafe`	Ссылки на этот тип безопасны при размотке стека.
`Send`	Значения этого типа можно безопасно передавать между потоками.
`Sync`	Ссылки на этот тип можно безопасно использовать из нескольких потоков одновременно.
`Unpin`	Значения этого типа можно безопасно перемещать.
`UnwindSafe`	Значения этого типа безопасны при размотке стека.

Специальные реализации

Трейт	Описание	Версия
`ConstParamTy_`	Тип может использоваться как параметр константного типа.	-
`Eq`	Тип реализует отношение эквивалентности.	1.0.0
`StructuralPartialEq`	Структурное частичное равенство.	-

Библиотека RUST