Продвинутые типы
В системе типов Rust есть некоторые возможности, которые мы до сих пор упоминали, но ещё
не обсуждали. Мы начнём с обсуждения newtype-паттерна в целом, рассматривая, почему
они полезны как типы. Затем мы перейдём к псевдонимам типов — возможности,
похожей на newtype, но с несколько иной семантикой. Мы также обсудим
тип ! и динамически размерные типы.
Безопасность типов и абстракция с помощью newtype-паттерна
Этот раздел предполагает, что вы прочитали более ранний раздел «Реализация внешних трейтов с помощью паттерна newtype». Newtype-паттерн
также полезен для задач, помимо тех, которые мы обсуждали до сих пор, включая
статическое обеспечение того, чтобы значения никогда не путались, и указание единиц
измерения значения. Вы видели пример использования newtype для указания единиц в листинге
20-16: вспомните, что структуры Millimeters и Meters оборачивали значения u32
в newtype. Если бы мы написали функцию с параметром типа Millimeters, мы
не смогли бы скомпилировать программу, которая случайно попыталась бы вызвать эту
функцию со значением типа Meters или простым u32.
Мы также можем использовать newtype-паттерн, чтобы абстрагироваться от некоторых деталей реализации типа: новый тип может предоставлять публичный API, отличный от API приватного внутреннего типа.
Newtype также могут скрывать внутреннюю реализацию. Например, мы могли бы предоставить
тип People для обёртывания HashMap<i32, String>, который хранит ID человека,
связанный с его именем. Код, использующий People, взаимодействовал бы только с
публичным API, который мы предоставляем, например, с методом для добавления строки имени в
коллекцию People; этому коду не нужно было бы знать, что мы присваиваем i32 ID именам
внутренне. Newtype-паттерн — это лёгкий способ достичь инкапсуляции,
чтобы скрыть детали реализации, которые мы обсуждали в разделе «Инкапсуляция, скрывающая детали реализации»
главы 18.
Синонимы типов и псевдонимы типов
Rust предоставляет возможность объявить псевдоним типа, чтобы дать существующему типу
другое имя. Для этого мы используем ключевое слово type. Например, мы можем создать
псевдоним Kilometers для i32 вот так:
fn main() {
type Kilometers = i32;
let x: i32 = 5;
let y: Kilometers = 5;
println!("x + y = {}", x + y);
}
Теперь псевдоним Kilometers — это синоним для i32; в отличие от типов Millimeters
и Meters, которые мы создали в листинге 20-16, Kilometers не является отдельным,
новым типом. Значения типа Kilometers будут трактоваться так же, как
значения типа i32:
fn main() {
type Kilometers = i32;
let x: i32 = 5;
let y: Kilometers = 5;
println!("x + y = {}", x + y);
}
Поскольку Kilometers и i32 — один и тот же тип, мы можем складывать значения обоих
типов и передавать значения Kilometers в функции, принимающие параметры i32.
Однако, используя этот метод, мы не получаем преимуществ проверки типов,
которые мы получаем от newtype-паттерна, обсуждавшегося ранее. Иными словами, если мы
где-то перепутаем значения Kilometers и i32, компилятор не выдаст нам
ошибку.
Основной случай использования синонимов типов — сокращение повторений. Например, у нас может быть длинный тип, вроде такого:
Box<dyn Fn() + Send + 'static>
Записывать этот длинный тип в сигнатурах функций и в аннотациях типов по всему коду может быть утомительно и чревато ошибками. Представьте себе проект, полный такого кода, как в листинге 20-25.
fn main() {
let f: Box<dyn Fn() + Send + 'static> = Box::new(|| println!("hi"));
fn takes_long_type(f: Box<dyn Fn() + Send + 'static>) {
// --snip--
}
fn returns_long_type() -> Box<dyn Fn() + Send + 'static> {
// --snip--
Box::new(|| ())
}
}
Псевдоним типа делает этот код более управляемым, сокращая повторение. В
листинге 20-26 мы ввели псевдоним с именем Thunk для многословного типа и
можем заменить все использования типа более коротким псевдонимом Thunk.
fn main() {
type Thunk = Box<dyn Fn() + Send + 'static>;
let f: Thunk = Box::new(|| println!("hi"));
fn takes_long_type(f: Thunk) {
// --snip--
}
fn returns_long_type() -> Thunk {
// --snip--
Box::new(|| ())
}
}
Thunk для сокращения повторенияЭтот код гораздо легче читать и писать! Выбор осмысленного имени для псевдонима типа может также помочь передать ваше намерение (thunk — это слово для кода, который должен быть вычислен позже, так что это подходящее имя для замыкания, которое сохраняется).
Псевдонимы типов также обычно используются с типом Result<T, E> для сокращения
повторений. Рассмотрим модуль std::io в стандартной библиотеке. Операции ввода-вывода
часто возвращают Result<T, E> для обработки ситуаций, когда операции
не удаются. В этой библиотеке есть структура std::io::Error, которая представляет все
возможные ошибки ввода-вывода. Многие функции в std::io будут возвращать
Result<T, E>, где E — это std::io::Error, например, эти функции в
трейте Write:
use std::fmt;
use std::io::Error;
pub trait Write {
fn write(&mut self, buf: &[u8]) -> Result<usize, Error>;
fn flush(&mut self) -> Result<(), Error>;
fn write_all(&mut self, buf: &[u8]) -> Result<(), Error>;
fn write_fmt(&mut self, fmt: fmt::Arguments) -> Result<(), Error>;
}
Result<..., Error> повторяется очень часто. Поэтому в std::io есть это объявление
псевдонима типа:
use std::fmt;
type Result<T> = std::result::Result<T, std::io::Error>;
pub trait Write {
fn write(&mut self, buf: &[u8]) -> Result<usize>;
fn flush(&mut self) -> Result<()>;
fn write_all(&mut self, buf: &[u8]) -> Result<()>;
fn write_fmt(&mut self, fmt: fmt::Arguments) -> Result<()>;
}
Поскольку это объявление находится в модуле std::io, мы можем использовать полностью
квалифицированный псевдоним std::io::Result<T>; то есть Result<T, E> с E,
заполненным как std::io::Error. Сигнатуры функций трейта Write в итоге
выглядят так:
use std::fmt;
type Result<T> = std::result::Result<T, std::io::Error>;
pub trait Write {
fn write(&mut self, buf: &[u8]) -> Result<usize>;
fn flush(&mut self) -> Result<()>;
fn write_all(&mut self, buf: &[u8]) -> Result<()>;
fn write_fmt(&mut self, fmt: fmt::Arguments) -> Result<()>;
}
Псевдоним типа помогает двумя способами: он делает код проще для написания и даёт
нам согласованный интерфейс во всём std::io. Поскольку это псевдоним, это
просто ещё один Result<T, E>, что означает, что мы можем использовать любые методы, работающие с
Result<T, E>, с ним, а также специальный синтаксис, такой как оператор ?.
Тип «никогда», который никогда не возвращается
В Rust есть специальный тип с именем !, известный в терминологии теории типов как
пустой тип, потому что у него нет значений. Мы предпочитаем называть его типом «никогда»,
потому что он занимает место возвращаемого типа, когда функция никогда не
возвращается. Вот пример:
fn bar() -> ! {
// --snip--
panic!();
}
Этот код читается как «функция bar возвращает никогда». Функции, которые возвращают
никогда, называются дивергентными функциями. Мы не можем создавать значения типа !,
поэтому bar никогда не сможет вернуться.
Но какая польза от типа, для которого вы никогда не можете создать значения? Вспомните код из листинга 2-5, часть игры по угадыванию чисел; мы воспроизвели его часть здесь в листинге 20-27.
use std::cmp::Ordering;
use std::io;
use rand::prelude::*;
fn main() {
println!("Guess the number!");
let secret_number = rand::rng().random_range(1..=100);
println!("The secret number is: {secret_number}");
loop {
println!("Please input your guess.");
let mut guess = String::new();
// --snip--
io::stdin()
.read_line(&mut guess)
.expect("Failed to read line");
let guess: u32 = match guess.trim().parse() {
Ok(num) => num,
Err(_) => continue,
};
println!("You guessed: {guess}");
// --snip--
match guess.cmp(&secret_number) {
Ordering::Less => println!("Too small!"),
Ordering::Greater => println!("Too big!"),
Ordering::Equal => {
println!("You win!");
break;
}
}
}
}
match с ветвью, которая заканчивается continueВ то время мы пропустили некоторые детали в этом коде. В разделе «Конструкция
потока управления match»
главы 6 мы обсуждали, что ветви match должны все возвращать один и тот же
тип. Так, например, следующий код не работает:
fn main() {
let guess = "3";
let guess = match guess.trim().parse() {
Ok(_) => 5,
Err(_) => "hello",
};
}
Тип guess в этом коде должен был бы быть целым числом и строкой,
а Rust требует, чтобы у guess был только один тип. Итак, что возвращает continue?
Как нам было разрешено вернуть u32 из одной ветви и иметь другую ветвь,
которая заканчивается continue, в листинге 20-27?
Как вы, возможно, догадались, continue имеет значение !. То есть, когда Rust
вычисляет тип guess, он смотрит на обе ветви match, первая со
значением u32, а вторая со значением !. Поскольку ! никогда не может иметь
значение, Rust решает, что тип guess — u32.
Формальный способ описания этого поведения состоит в том, что выражения типа ! могут
быть приведены к любому другому типу. Нам разрешено закончить эту ветвь match
выражением continue, потому что continue не возвращает значение; вместо этого он перемещает управление
обратно в начало цикла, поэтому в случае Err мы никогда не присваиваем значение
guess.
Тип «никогда» также полезен с макросом panic!. Вспомните функцию unwrap,
которую мы вызываем для значений Option<T>, чтобы получить значение или запаниковать с
таким определением:
enum Option<T> {
Some(T),
None,
}
use crate::Option::*;
impl<T> Option<T> {
pub fn unwrap(self) -> T {
match self {
Some(val) => val,
None => panic!("called `Option::unwrap()` on a `None` value"),
}
}
}
В этом коде происходит то же самое, что и в match в листинге 20-27: Rust
видит, что val имеет тип T, а panic! имеет тип !, так что результат
всего выражения match — T. Этот код работает, потому что panic!
не производит значение; он завершает программу. В случае None мы не будем
возвращать значение из unwrap, поэтому этот код действителен.
Последнее выражение, которое имеет тип !, — это цикл:
fn main() {
print!("forever ");
loop {
print!("and ever ");
}
}
Здесь цикл никогда не заканчивается, поэтому ! — это значение выражения. Однако это
не было бы верно, если бы мы включили break, потому что цикл завершился бы,
когда дошёл бы до break.
Динамически размерные типы и трейт Sized
Rust нужно знать определённые детали о своих типах, такие как сколько места выделить для значения определённого типа. Это оставляет один уголок его системы типов немного запутанным поначалу: концепция динамически sized типов. Иногда называемые DST или unsized типами, эти типы позволяют нам писать код, используя значения, размер которых мы можем знать только во время выполнения.
Давайте углубимся в детали динамически sized типа с именем str, который
мы использовали на протяжении всей книги. Правильно, не &str, а str сам по себе
является DST. Во многих случаях, например, при сохранении текста, введённого пользователем,
мы не можем знать, насколько длинной будет строка, до времени выполнения. Это означает, что мы не можем создать
переменную типа str, и мы не можем принять аргумент типа str. Рассмотрим
следующий код, который не работает:
fn main() {
let s1: str = "Hello there!";
let s2: str = "How's it going?";
}
Rust нужно знать, сколько памяти выделить для любого значения определённого
типа, и все значения типа должны использовать одинаковое количество памяти. Если бы Rust
позволил нам написать этот код, эти два значения str должны были бы занимать
одинаковое количество места. Но они имеют разную длину: s1 нужно 12 байт
памяти, а s2 нужно 15. Вот почему невозможно создать переменную,
содержащую динамически sized тип.
Итак, что мы делаем? В этом случае вы уже знаете ответ: мы делаем тип
s1 и s2 строковым срезом (&str), а не str. Вспомните из
раздела «Строковые срезы» главы 4, что
структура данных среза хранит только начальную позицию и длину
среза. Итак, хотя &T — это одно значение, которое хранит адрес памяти
того, где находится T, строковый срез — это два значения: адрес
str и его длина. Таким образом, мы можем знать размер значения строкового среза во
время компиляции: это удвоенная длина usize. То есть мы всегда знаем
размер строкового среза, независимо от того, насколько длинной является строка, на которую он ссылается. В
общем, это способ, которым динамически размерные типы используются в Rust:
у них есть дополнительный бит метаданных, который хранит размер динамической
информации. Золотое правило динамически sized типов состоит в том, что мы должны всегда
помещать значения динамически sized типов за указателем какого-либо вида.
Мы можем комбинировать str со всеми видами указателей: например, Box<str> или
Rc<str>. Фактически, вы видели это раньше, но с другим динамически
sized типом: трейтами. Каждый трейт — это динамически sized тип, на который мы можем ссылаться,
используя имя трейта. В разделе «Использование трейт-объектов для абстрагирования над
общим поведением» главы 18 мы упомянули, что для использования трейтов как трейт-объектов,
мы должны поместить их за указателем, таким как &dyn Trait или Box<dyn Trait> (Rc<dyn Trait> тоже работал бы).
Для работы с DST Rust предоставляет трейт Sized, чтобы определить, известен ли
размер типа во время компиляции. Этот трейт автоматически реализуется
для всего, чей размер известен во время компиляции. Кроме того, Rust
неявно добавляет ограничение на Sized к каждой обобщённой функции. То есть
определение обобщённой функции, вроде этого:
fn generic<T>(t: T) {
// --snip--
}
фактически трактуется так, как если бы мы написали это:
fn generic<T: Sized>(t: T) {
// --snip--
}
По умолчанию обобщённые функции будут работать только с типами, которые имеют известный размер во время компиляции. Однако вы можете использовать следующий специальный синтаксис, чтобы ослабить это ограничение:
fn generic<T: ?Sized>(t: &T) {
// --snip--
}
Ограничение трейта ?Sized означает «T может быть или не быть Sized», и эта
нотация переопределяет значение по умолчанию, что обобщённые типы должны иметь известный размер во
время компиляции. Синтаксис ?Trait с этим значением доступен только для
Sized, а не для любых других трейтов.
Также обратите внимание, что мы изменили тип параметра t с T на &T.
Поскольку тип может не быть Sized, нам нужно использовать его за указателем какого-либо вида.
В этом случае мы выбрали ссылку.
Далее мы поговорим о функциях и замыканиях!