Использование трейт-объектов для абстрагирования над общим поведением
В главе 8 упоминалось, что одно из ограничений векторов — они могут
хранить элементы только одного типа. В листинге 8-9 было создано обходное решение, где
определялось перечисление SpreadsheetCell с вариантами для хранения целых чисел, чисел с плавающей точкой
и текста. Это означало, что можно было хранить различные типы данных в каждой ячейке и
при этом иметь вектор, представляющий строку ячеек. Это совершенно хорошее
решение, когда взаимозаменяемые элементы представляют собой фиксированный набор типов, известных
на момент компиляции кода.
Однако иногда требуется, чтобы пользователь библиотеки мог расширить набор
типов, допустимых в определённой ситуации. Чтобы показать, как этого можно достичь,
создадим пример инструмента графического пользовательского интерфейса (GUI), который перебирает
список элементов, вызывая для каждого метод draw, чтобы нарисовать его на
экране — распространённый приём для инструментов GUI. Создадим библиотечный крейт с именем
gui, содержащий структуру библиотеки GUI. Этот крейт может включать
некоторые типы для использования людьми, такие как Button или TextField. Кроме того,
пользователи gui захотят создавать свои собственные типы, которые можно нарисовать: например,
один программист может добавить Image, а другой — SelectBox.
На момент написания библиотеки нельзя знать и определить все типы,
которые могут захотеть создать другие программисты. Но известно, что gui должно отслеживать
множество значений различных типов и вызывать метод draw
для каждого из этих значений разных типов. Не нужно знать точно, что
произойдёт при вызове метода draw, нужно лишь знать, что у значения будет этот
метод, доступный для вызова.
Чтобы сделать это в языке с наследованием, можно определить класс с именем
Component, у которого есть метод с именем draw. Другие классы, такие как
Button, Image и SelectBox, наследовали бы от Component и таким образом
наследовали бы метод draw. Каждый из них мог бы переопределить метод draw, чтобы задать
своё собственное поведение, но фреймворк мог бы рассматривать все типы так, как если бы
они были экземплярами Component, и вызывать у них draw. Но поскольку в Rust
нет наследования, нужен другой способ структурировать библиотеку gui, чтобы
позволить пользователям создавать новые типы, совместимые с библиотекой.
Определение трейта для общего поведения
Чтобы реализовать поведение, которое должно быть у gui, определим трейт
с именем Draw, у которого будет один метод с именем draw. Затем можно определить
вектор, принимающий трейт-объект. Трейт-объект указывает как на экземпляр
типа, реализующего указанный трейт, так и на таблицу, используемую для поиска методов трейта
у этого типа во время выполнения. Трейт-объект создаётся путём указания некоторого
вида указателя, например ссылки или умного указателя Box<T>, затем ключевого слова
dyn и соответствующего трейта. (Причина, по которой трейт-объекты должны использовать указатель,
будет рассмотрена в разделе «Динамически размерные типы и трейт Sized» главы 20.) Трейт-объекты можно использовать
вместо обобщённого или конкретного типа. Везде, где используется трейт-объект,
система типов Rust гарантирует на этапе компиляции, что любое значение, используемое в
этом контексте, реализует трейт трейт-объекта. Следовательно, не
нужно знать все возможные типы на этапе компиляции.
Упоминалось, что в Rust воздерживаются от называния структур и перечислений
«объектами», чтобы отличать их от объектов других языков. В структуре или
перечислении данные в полях структуры и поведение в блоках impl
разделены, тогда как в других языках данные и поведение, объединённые в одно
понятие, часто называются объектом. Трейт-объекты отличаются от объектов в других
языках тем, что к трейт-объекту нельзя добавить данные. Трейт-объекты не так
широко полезны, как объекты в других языках: их конкретное назначение — позволять
абстрагирование над общим поведением.
В листинге 18-3 показано, как определить трейт с именем Draw с одним методом с именем
draw.
pub trait Draw {
fn draw(&self);
}
DrawЭтот синтаксис должен выглядеть знакомым из обсуждений того, как определять трейты
в главе 10. Далее следует новый синтаксис: листинг 18-4 определяет структуру с именем
Screen, содержащую вектор с именем components. Этот вектор имеет тип
Box<dyn Draw>, что является трейт-объектом; это заменитель любого типа внутри
Box, который реализует трейт Draw.
pub trait Draw {
fn draw(&self);
}
pub struct Screen {
pub components: Vec<Box<dyn Draw>>,
}
Screen с полем components, содержащим вектор трейт-объектов, реализующих трейт DrawДля структуры Screen определим метод с именем run, который будет вызывать метод
draw для каждого из её components, как показано в листинге 18-5.
pub trait Draw {
fn draw(&self);
}
pub struct Screen {
pub components: Vec<Box<dyn Draw>>,
}
impl Screen {
pub fn run(&self) {
for component in self.components.iter() {
component.draw();
}
}
}
run у Screen, вызывающий метод draw для каждого компонентаЭто работает иначе, чем определение структуры, использующей обобщённый параметр
типа с ограничениями трейта. Обобщённый параметр типа может быть заменён
только одним конкретным типом за раз, тогда как трейт-объекты позволяют нескольким
конкретным типам заполнять трейт-объект во время выполнения. Например, можно было бы
определить структуру Screen, используя обобщённый тип и ограничение трейта,
как в листинге 18-6.
pub trait Draw {
fn draw(&self);
}
pub struct Screen<T: Draw> {
pub components: Vec<T>,
}
impl<T> Screen<T>
where
T: Draw,
{
pub fn run(&self) {
for component in self.components.iter() {
component.draw();
}
}
}
Screen и её метода run с использованием обобщённых типов и ограничений трейтовЭто ограничивает нас экземпляром Screen, у которого список компонентов все
типа Button или все типа TextField. Если когда-либо будут только однородные
коллекции, предпочтительнее использовать обобщённые типы и ограничения трейтов, потому что
определения будут мономорфизированы на этапе компиляции для использования конкретных типов.
С другой стороны, при использовании метода с трейт-объектами один экземпляр Screen
может содержать Vec<T>, который содержит Box<Button> наряду с
Box<TextField>. Рассмотрим, как это работает, а затем обсудим
последствия для производительности во время выполнения.
Реализация трейта
Теперь добавим несколько типов, реализующих трейт Draw. Предоставим
тип Button. Опять же, фактическая реализация библиотеки GUI выходит за рамки
этой книги, поэтому метод draw не будет иметь полезной реализации в своём
теле. Чтобы представить, как могла бы выглядеть реализация, структура Button
могла бы иметь поля width, height и label, как показано в листинге 18-7.
pub trait Draw {
fn draw(&self);
}
pub struct Screen {
pub components: Vec<Box<dyn Draw>>,
}
impl Screen {
pub fn run(&self) {
for component in self.components.iter() {
component.draw();
}
}
}
pub struct Button {
pub width: u32,
pub height: u32,
pub label: String,
}
impl Draw for Button {
fn draw(&self) {
// код для фактического отрисовывания кнопки
}
}
Button, реализующая трейт DrawПоля width, height и label у Button будут отличаться от
полей других компонентов; например, тип TextField мог бы иметь те же
самые поля плюс поле placeholder. Каждый из типов, которые нужно нарисовать на
экране, будет реализовывать трейт Draw, но использовать разный код в
методе draw, чтобы определить, как нарисовать этот конкретный тип, как Button здесь
(без фактического кода GUI, как упоминалось). Тип Button, например,
мог бы иметь дополнительный блок impl, содержащий методы, связанные с тем, что
происходит при нажатии пользователем кнопки. Такие методы не будут применяться к
типам вроде TextField.
Если кто-то, использующий библиотеку, решит реализовать структуру SelectBox, имеющую
поля width, height и options, он также реализовал бы трейт Draw
для типа SelectBox, как показано в листинге 18-8.
use gui::Draw;
struct SelectBox {
width: u32,
height: u32,
options: Vec<String>,
}
impl Draw for SelectBox {
fn draw(&self) {
// код для фактического отрисовывания выпадающего списка
}
}
fn main() {}
gui и реализующий трейт Draw для структуры SelectBoxПользователь библиотеки теперь может написать свою функцию main для создания экземпляра Screen.
В экземпляр Screen можно добавить SelectBox и Button,
поместив каждый в Box<T>, чтобы получить трейт-объекты. Затем можно вызвать метод
run для экземпляра Screen, который вызовет draw для каждого из
компонентов. Листинг 18-9 показывает эту реализацию.
use gui::Draw;
struct SelectBox {
width: u32,
height: u32,
options: Vec<String>,
}
impl Draw for SelectBox {
fn draw(&self) {
// код для фактического отрисовывания выпадающего списка
}
}
use gui::{Button, Screen};
fn main() {
let screen = Screen {
components: vec![
Box::new(SelectBox {
width: 75,
height: 10,
options: vec![
String::from("Yes"),
String::from("Maybe"),
String::from("No"),
],
}),
Box::new(Button {
width: 50,
height: 10,
label: String::from("OK"),
}),
],
};
screen.run();
}
При написании библиотеки не было известно, что кто-то может добавить тип
SelectBox, но реализация Screen смогла работать с
новым типом и отрисовать его, потому что SelectBox реализует трейт Draw,
что означает, что он реализует метод draw.
Эта концепция — заботиться только о сообщениях, на которые
значение отвечает, а не о конкретном типе значения — похожа на концепцию утиной
типизации в динамически типизированных языках: если это ходит как утка и крякает как
утка, то это, должно быть, утка! В реализации run для Screen
в листинге 18-5 run не нужно знать, каков конкретный тип каждого
компонента. Он не проверяет, является ли компонент экземпляром Button
или SelectBox, он просто вызывает метод draw для компонента. Указав
Box<dyn Draw> в качестве типа значений в векторе components,
мы определили Screen так, чтобы ему нужны были значения, для которых можно вызвать метод draw.
Преимущество использования трейт-объектов и системы типов Rust для написания кода, похожего на код с утиной типизацией, состоит в том, что никогда не нужно проверять во время выполнения, реализует ли значение определённый метод, или беспокоиться о получении ошибок, если значение не реализует метод, но мы его всё равно вызываем. Rust не скомпилирует код, если значения не реализуют трейты, необходимые трейт-объектам.
Например, в листинге 18-10 показано, что произойдёт при попытке создать Screen
с компонентом String.
use gui::Screen;
fn main() {
let screen = Screen {
components: vec![Box::new(String::from("Hi"))],
};
screen.run();
}
Будет получена эта ошибка, потому что String не реализует трейт Draw:
$ cargo run
Compiling gui v0.1.0 (file:///projects/gui)
error[E0277]: the trait bound `String: Draw` is not satisfied
--> src/main.rs:5:26
|
5 | components: vec![Box::new(String::from("Hi"))],
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ the trait `Draw` is not implemented for `String`
|
help: the trait `Draw` is implemented for `Button`
--> src/lib.rs:23:1
|
23 | impl Draw for Button {
| ^^^^^^^^^^^^^^^^^^^^
= note: required for the cast from `Box<String>` to `Box<dyn Draw>`
For more information about this error, try `rustc --explain E0277`.
error: could not compile `gui` (bin "gui") due to 1 previous error
Эта ошибка сообщает, что либо в Screen передаётся что-то, что
не должно было передаваться, и поэтому следует передать другой тип, либо нужно реализовать
Draw для String, чтобы Screen мог вызвать draw для него.
Выполнение динамической диспетчеризации
Вспомним обсуждение «Производительность кода, использующего обобщения» в главе 10 о процессе мономорфизации, выполняемом компилятором для обобщённых типов: компилятор генерирует необобщённые реализации функций и методов для каждого конкретного типа, используемого вместо обобщённого параметра типа. Код, получающийся в результате мономорфизации, выполняет статическую диспетчеризацию, при которой компилятор знает, какой метод вызывается на этапе компиляции. Это противоположно динамической диспетчеризации, при которой компилятор не может определить на этапе компиляции, какой метод вызывается. В случаях динамической диспетчеризации компилятор генерирует код, который во время выполнения будет знать, какой метод вызывать.
Когда используются трейт-объекты, Rust должен использовать динамическую диспетчеризацию. Компилятор не знает всех типов, которые могут быть использованы с кодом, использующим трейт-объекты, поэтому он не знает, какой метод, реализованный для какого типа, вызывать. Вместо этого во время выполнения Rust использует указатели внутри трейт-объекта, чтобы определить, какой метод вызывать. Этот поиск влечёт за собой затраты времени выполнения, которых нет при статической диспетчеризации. Динамическая диспетчеризация также не позволяет компилятору выбирать встраивание кода метода, что, в свою очередь, препятствует некоторым оптимизациям, и в Rust есть некоторые правила о том, где можно и где нельзя использовать динамическую диспетчеризацию, называемые dyn-совместимостью. Эти правила выходят за рамки данного обсуждения, но о них можно прочитать подробнее в справочнике. Однако была получена дополнительная гибкость в коде, который был написан в листинге 18-5 и поддерживался в листинге 18-9, так что это компромисс, который следует учитывать.