Обобщённые типы данных
Мы используем обобщения для создания определений элементов, таких как сигнатуры функций или структуры, которые затем можно использовать с множеством различных конкретных типов данных. Давайте сначала рассмотрим, как определять функции, структуры, перечисления и методы с использованием обобщений. Затем мы обсудим, как обобщения влияют на производительность кода.
В определениях функций
При определении функции, использующей обобщения, мы помещаем обобщения в сигнатуру функции туда, где мы обычно указываем типы данных параметров и возвращаемого значения. Это делает наш код более гибким и предоставляет больше функциональности вызывающим нашу функцию, предотвращая дублирование кода.
Продолжая с нашей функцией largest, листинг 10-4 показывает две функции, которые
обе находят наибольшее значение в срезе. Затем мы объединим их в одну
функцию, использующую обобщения.
fn largest_i32(list: &[i32]) -> &i32 {
let mut largest = &list[0];
for item in list {
if item > largest {
largest = item;
}
}
largest
}
fn largest_char(list: &[char]) -> &char {
let mut largest = &list[0];
for item in list {
if item > largest {
largest = item;
}
}
largest
}
fn main() {
let number_list = vec![34, 50, 25, 100, 65];
let result = largest_i32(&number_list);
println!("The largest number is {result}");
assert_eq!(*result, 100);
let char_list = vec!['y', 'm', 'a', 'q'];
let result = largest_char(&char_list);
println!("The largest char is {result}");
assert_eq!(*result, 'y');
}
Функция largest_i32 — та, которую мы извлекли в листинге 10-3, находящая
наибольший i32 в срезе. Функция largest_char находит наибольший
char в срезе. Тела функций содержат одинаковый код, поэтому давайте устраним
дублирование, введя параметр обобщённого типа в одну функцию.
Чтобы параметризовать типы в новой единой функции, нам нужно назвать параметр
типа, так же как мы это делаем для параметров-значений функции. Вы можете использовать
любой идентификатор в качестве имени параметра типа. Но мы будем использовать T, потому что
по соглашению имена параметров типов в Rust короткие, часто просто одна буква, и
соглашение об именовании типов в Rust — UpperCamelCase. Сокращение от type, T —
выбор по умолчанию большинства программистов на Rust.
Когда мы используем параметр в теле функции, мы должны объявить
имя параметра в сигнатуре, чтобы компилятор знал, что означает это имя.
Аналогично, когда мы используем имя параметра типа в сигнатуре функции, мы
должны объявить имя параметра типа перед его использованием. Чтобы определить обобщённую
функцию largest, мы помещаем объявления имён типов в угловые скобки,
<>, между именем функции и списком параметров, вот так:
fn largest<T>(list: &[T]) -> &T {
Мы читаем это определение как «Функция largest является обобщённой по некоторому типу
T». Эта функция имеет один параметр с именем list, который является срезом значений
типа T. Функция largest вернёт ссылку на значение того же типа T.
Листинг 10-5 показывает объединённое определение функции largest, использующее обобщённый
тип данных в своей сигнатуре. В листинге также показано, как мы можем вызвать функцию
со срезом значений i32 или значений char. Обратите внимание, что этот код пока
не скомпилируется.
fn largest<T>(list: &[T]) -> &T {
let mut largest = &list[0];
for item in list {
if item > largest {
largest = item;
}
}
largest
}
fn main() {
let number_list = vec![34, 50, 25, 100, 65];
let result = largest(&number_list);
println!("The largest number is {result}");
let char_list = vec!['y', 'm', 'a', 'q'];
let result = largest(&char_list);
println!("The largest char is {result}");
}
largest, использующая параметры обобщённого типа; она пока не компилируетсяЕсли мы скомпилируем этот код прямо сейчас, мы получим эту ошибку:
$ cargo run
Compiling chapter10 v0.1.0 (file:///projects/chapter10)
error[E0369]: binary operation `>` cannot be applied to type `&T`
--> src/main.rs:5:17
|
5 | if item > largest {
| ---- ^ ------- &T
| |
| &T
|
help: consider restricting type parameter `T` with trait `PartialOrd`
|
1 | fn largest<T: std::cmp::PartialOrd>(list: &[T]) -> &T {
| ++++++++++++++++++++++
For more information about this error, try `rustc --explain E0369`.
error: could not compile `chapter10` (bin "chapter10") due to 1 previous error
В тексте справки упоминается std::cmp::PartialOrd, который является трейтом, и мы
поговорим о трейтах в следующем разделе. Пока достаточно знать, что эта ошибка
говорит о том, что тело largest не будет работать для всех возможных типов, которыми может
быть T. Поскольку мы хотим сравнивать значения типа T в теле, мы можем
использовать только типы, значения которых можно упорядочить. Чтобы включить сравнения, стандартная
библиотека имеет трейт std::cmp::PartialOrd, который вы можете реализовать для типов
(см. приложение C для получения дополнительной информации об этом трейте). Чтобы исправить листинг 10-5, мы можем последовать
предложению из текста справки и ограничить типы, допустимые для T, только теми, которые
реализуют PartialOrd. Затем листинг скомпилируется, потому что стандартная
библиотека реализует PartialOrd как для i32, так и для char.
В определениях структур
Мы также можем определить структуры для использования параметра обобщённого типа в одном или нескольких
полях, используя синтаксис <>. Листинг 10-6 определяет структуру Point<T> для хранения
значений координат x и y любого типа.
struct Point<T> {
x: T,
y: T,
}
fn main() {
let integer = Point { x: 5, y: 10 };
let float = Point { x: 1.0, y: 4.0 };
}
Point<T>, хранящая значения x и y типа TСинтаксис использования обобщений в определениях структур аналогичен тому, который используется в определениях функций. Сначала мы объявляем имя параметра типа внутри угловых скобок сразу после имени структуры. Затем мы используем обобщённый тип в определении структуры там, где мы иначе указали бы конкретные типы данных.
Обратите внимание, что поскольку мы использовали только один обобщённый тип для определения Point<T>, это
определение говорит, что структура Point<T> является обобщённой по некоторому типу T, и
поля x и y оба имеют тот же тип, каким бы этот тип ни был. Если
мы создадим экземпляр Point<T> со значениями разных типов, как в
листинге 10-7, наш код не скомпилируется.
struct Point<T> {
x: T,
y: T,
}
fn main() {
let wont_work = Point { x: 5, y: 4.0 };
}
x и y должны быть одного типа, потому что оба имеют один и тот же обобщённый тип данных T.В этом примере, когда мы присваиваем целочисленное значение 5 переменной x, мы даём
компилятору знать, что обобщённый тип T будет целочисленным для этого экземпляра
Point<T>. Затем, когда мы указываем 4.0 для y, который мы определили как
имеющий тот же тип, что и x, мы получим ошибку несоответствия типов, вот такую:
$ cargo run
Compiling chapter10 v0.1.0 (file:///projects/chapter10)
error[E0308]: mismatched types
--> src/main.rs:7:38
|
7 | let wont_work = Point { x: 5, y: 4.0 };
| ^^^ expected integer, found floating-point number
For more information about this error, try `rustc --explain E0308`.
error: could not compile `chapter10` (bin "chapter10") due to 1 previous error
Чтобы определить структуру Point, где x и y оба являются обобщёнными, но могут иметь
разные типы, мы можем использовать несколько параметров обобщённого типа. Например, в
листинге 10-8 мы меняем определение Point, чтобы оно было обобщённым по типам T
и U, где x имеет тип T, а y имеет тип U.
struct Point<T, U> {
x: T,
y: U,
}
fn main() {
let both_integer = Point { x: 5, y: 10 };
let both_float = Point { x: 1.0, y: 4.0 };
let integer_and_float = Point { x: 5, y: 4.0 };
}
Point<T, U>, обобщённая по двум типам, так что x и y могут быть значениями разных типовТеперь все показанные экземпляры Point разрешены! Вы можете использовать столько параметров обобщённого
типа в определении, сколько захотите, но использование более нескольких делает
ваш код трудным для чтения. Если вы обнаружите, что вам нужно много обобщённых типов в
вашем коде, это может указывать на то, что ваш код нуждается в реструктуризации на более мелкие
части.
В определениях перечислений
Как мы делали со структурами, мы можем определять перечисления для хранения обобщённых типов данных в их
вариантах. Давайте ещё раз взглянем на перечисление Option<T>, которое предоставляет стандартная
библиотека, и которое мы использовали в главе 6:
#![allow(unused)]
fn main() {
enum Option<T> {
Some(T),
None,
}
}
Это определение теперь должно иметь для вас больше смысла. Как видите,
перечисление Option<T> является обобщённым по типу T и имеет два варианта: Some, который
содержит одно значение типа T, и вариант None, который не содержит никакого значения.
Используя перечисление Option<T>, мы можем выразить абстрактную концепцию
необязательного значения, и поскольку Option<T> является обобщённым, мы можем использовать эту абстракцию
независимо от типа необязательного значения.
Перечисления также могут использовать несколько обобщённых типов. Определение перечисления Result,
которое мы использовали в главе 9, является одним из примеров:
#![allow(unused)]
fn main() {
enum Result<T, E> {
Ok(T),
Err(E),
}
}
Перечисление Result является обобщённым по двум типам, T и E, и имеет два варианта:
Ok, который содержит значение типа T, и Err, который содержит значение типа
E. Это определение делает удобным использование перечисления Result везде, где
у нас есть операция, которая может успешно завершиться (вернуть значение некоторого типа T) или потерпеть неудачу
(вернуть ошибку некоторого типа E). Фактически, это то, что мы использовали для открытия
файла в листинге 9-3, где T был заполнен типом std::fs::File, когда
файл был успешно открыт, а E был заполнен типом
std::io::Error, когда были проблемы с открытием файла.
Когда вы распознаёте в своём коде ситуации с несколькими определениями структур или перечислений, которые различаются только типами значений, которые они содержат, вы можете избежать дублирования, используя вместо этого обобщённые типы.
В определениях методов
Мы можем реализовывать методы для структур и перечислений (как мы делали в главе 5) и использовать
обобщённые типы в их определениях тоже. Листинг 10-9 показывает структуру Point<T>,
которую мы определили в листинге 10-6, с реализованным для неё методом с именем x.
struct Point<T> {
x: T,
y: T,
}
impl<T> Point<T> {
fn x(&self) -> &T {
&self.x
}
}
fn main() {
let p = Point { x: 5, y: 10 };
println!("p.x = {}", p.x());
}
x для структуры Point<T>, который вернёт ссылку на поле x типа TЗдесь мы определили метод с именем x для Point<T>, который возвращает ссылку
на данные в поле x.
Обратите внимание, что мы должны объявить T сразу после impl, чтобы мы могли использовать T для
указания, что мы реализуем методы для типа Point<T>. Объявив
T как обобщённый тип после impl, Rust может идентифицировать, что тип в
угловых скобках в Point является обобщённым типом, а не конкретным типом. Мы
могли бы выбрать другое имя для этого обобщённого параметра, чем обобщённый
параметр, объявленный в определении структуры, но использование того же имени является
общепринятым. Если вы напишете метод внутри impl, который объявляет обобщённый
тип, этот метод будет определён для любого экземпляра типа, независимо от того, какой
конкретный тип в конечном итоге подставляется вместо обобщённого типа.
Мы также можем указать ограничения на обобщённые типы при определении методов для
типа. Мы могли бы, например, реализовать методы только для экземпляров Point<f32>,
а не для экземпляров Point<T> с любым обобщённым типом. В листинге 10-10 мы
используем конкретный тип f32, что означает, что мы не объявляем никаких типов после impl.
struct Point<T> {
x: T,
y: T,
}
impl<T> Point<T> {
fn x(&self) -> &T {
&self.x
}
}
impl Point<f32> {
fn distance_from_origin(&self) -> f32 {
(self.x.powi(2) + self.y.powi(2)).sqrt()
}
}
fn main() {
let p = Point { x: 5, y: 10 };
println!("p.x = {}", p.x());
}
impl, который применяется только к структуре с определённым конкретным типом для параметра обобщённого типа TЭтот код означает, что тип Point<f32> будет иметь метод distance_from_origin;
другие экземпляры Point<T>, где T не является типом f32, не
будут иметь этот метод определённым. Метод измеряет, насколько наша точка удалена от
точки с координатами (0.0, 0.0), и использует математические операции, которые
доступны только для типов с плавающей точкой.
Параметры обобщённого типа в определении структуры не всегда совпадают с теми,
которые вы используете в сигнатурах методов той же структуры. Листинг 10-11 использует обобщённые
типы X1 и Y1 для структуры Point и X2 и Y2 для сигнатуры метода mixup,
чтобы сделать пример яснее. Метод создаёт новый экземпляр Point
со значением x из self Point (типа X1) и значением y
из переданного Point (типа Y2).
struct Point<X1, Y1> {
x: X1,
y: Y1,
}
impl<X1, Y1> Point<X1, Y1> {
fn mixup<X2, Y2>(self, other: Point<X2, Y2>) -> Point<X1, Y2> {
Point {
x: self.x,
y: other.y,
}
}
}
fn main() {
let p1 = Point { x: 5, y: 10.4 };
let p2 = Point { x: "Hello", y: 'c' };
let p3 = p1.mixup(p2);
println!("p3.x = {}, p3.y = {}", p3.x, p3.y);
}
В main мы определили Point, который имеет i32 для x (со значением 5)
и f64 для y (со значением 10.4). Переменная p2 — это структура Point,
которая имеет строковый срез для x (со значением "Hello") и char для y
(со значением c). Вызов mixup для p1 с аргументом p2 даёт нам p3,
который будет иметь i32 для x, потому что x пришёл из p1. Переменная p3
будет иметь char для y, потому что y пришёл из p2. Вызов макроса println!
напечатает p3.x = 5, p3.y = c.
Цель этого примера — продемонстрировать ситуацию, в которой некоторые обобщённые
параметры объявлены с impl, а некоторые объявлены с определением метода.
Здесь обобщённые параметры X1 и Y1 объявлены после
impl, потому что они идут с определением структуры. Обобщённые параметры X2
и Y2 объявлены после fn mixup, потому что они относятся только к
методу.
Производительность кода, использующего обобщения
Возможно, вам интересно, есть ли накладные расходы во время выполнения при использовании параметров обобщённого типа. Хорошая новость в том, что использование обобщённых типов не заставит вашу программу работать медленнее, чем с конкретными типами.
Rust достигает этого путём мономорфизации кода, использующего обобщения, во время компиляции. Мономорфизация — это процесс превращения обобщённого кода в конкретный код путём подстановки конкретных типов, которые используются при компиляции. В этом процессе компилятор делает противоположное шагам, которые мы использовали для создания обобщённой функции в листинге 10-5: компилятор смотрит на все места, где вызывается обобщённый код, и генерирует код для конкретных типов, с которыми вызывается обобщённый код.
Давайте посмотрим, как это работает, используя обобщённое перечисление
Option<T> из стандартной библиотеки:
#![allow(unused)]
fn main() {
let integer = Some(5);
let float = Some(5.0);
}
Когда Rust компилирует этот код, он выполняет мономорфизацию. В ходе этого
процесса компилятор читает значения, которые были использованы в экземплярах Option<T>,
и идентифицирует два вида Option<T>: один — i32, а другой —
f64. Таким образом, он разворачивает обобщённое определение Option<T> в два
определения, специализированных для i32 и f64, тем самым заменяя обобщённое
определение конкретными.
Мономорфизированная версия кода выглядит примерно так (компилятор использует другие имена, чем те, которые мы используем здесь для иллюстрации):
enum Option_i32 {
Some(i32),
None,
}
enum Option_f64 {
Some(f64),
None,
}
fn main() {
let integer = Option_i32::Some(5);
let float = Option_f64::Some(5.0);
}
Обобщённое Option<T> заменяется конкретными определениями, созданными
компилятором. Поскольку Rust компилирует обобщённый код в код, который указывает
тип в каждом экземпляре, мы не платим накладных расходов во время выполнения за использование обобщений. Когда код
выполняется, он работает так же, как если бы мы вручную дублировали каждое определение.
Процесс мономорфизации делает обобщения Rust чрезвычайно эффективными
во время выполнения.