Продвинутые трейты
Мы впервые рассмотрели трейты в разделе «Определение общего поведения с помощью трейтов» главы 10, но не обсуждали более продвинутые детали. Теперь, когда вы знаете больше о Rust, мы можем углубиться в суть.
Определение трейтов с ассоциированными типами
Ассоциированные типы связывают заполнитель типа с трейтом так, что определения методов трейта могут использовать эти типы-заполнители в своих сигнатурах. Реализующий трейт укажет конкретный тип, который будет использоваться вместо типа-заполнителя для конкретной реализации. Таким образом, мы можем определить трейт, который использует некоторые типы, не зная точно, что это за типы, до тех пор, пока трейт не будет реализован.
Мы описали большинство продвинутых возможностей в этой главе как редко используемые. Ассоциированные типы находятся где-то посередине: они используются реже, чем возможности, объяснённые в остальной части книги, но чаще, чем многие другие возможности, обсуждаемые в этой главе.
Одним из примеров трейта с ассоциированным типом является трейт Iterator, который предоставляет стандартная библиотека. Ассоциированный тип называется Item и обозначает тип значений, по которым итерирует тип, реализующий трейт Iterator. Определение трейта Iterator выглядит как показано в листинге 20-13.
pub trait Iterator {
type Item;
fn next(&mut self) -> Option<Self::Item>;
}
Iterator, который имеет ассоциированный тип ItemТип Item — это заполнитель, и определение метода next показывает, что он будет возвращать значения типа Option<Self::Item>. Реализующие трейт Iterator укажут конкретный тип для Item, и метод next вернёт Option, содержащий значение этого конкретного типа.
Ассоциированные типы могут показаться похожими на обобщения, поскольку последние позволяют нам определять функцию, не указывая, с какими типами она может работать. Чтобы изучить разницу между этими двумя концепциями, мы рассмотрим реализацию трейта Iterator для типа с именем Counter, который указывает, что тип Item — u32:
struct Counter {
count: u32,
}
impl Counter {
fn new() -> Counter {
Counter { count: 0 }
}
}
impl Iterator for Counter {
type Item = u32;
fn next(&mut self) -> Option<Self::Item> {
// --snip--
if self.count < 5 {
self.count += 1;
Some(self.count)
} else {
None
}
}
}
Этот синтаксис кажется сопоставимым с синтаксисом обобщений. Итак, почему бы просто не определить трейт Iterator с обобщениями, как показано в листинге 20-14?
pub trait Iterator<T> {
fn next(&mut self) -> Option<T>;
}
Iterator с использованием обобщенийРазница в том, что при использовании обобщений, как в листинге 20-14, мы должны аннотировать типы в каждой реализации; поскольку мы также можем реализовать Iterator<String> for Counter или любой другой тип, у нас может быть несколько реализаций Iterator для Counter. Другими словами, когда трейт имеет обобщённый параметр, он может быть реализован для типа несколько раз, изменяя конкретные типы обобщённых параметров типа каждый раз. Когда мы используем метод next для Counter, нам пришлось бы предоставить аннотации типов, чтобы указать, какую реализацию Iterator мы хотим использовать.
С ассоциированными типами нам не нужно аннотировать типы, потому что мы не можем реализовать трейт для типа несколько раз. В листинге 20-13 с определением, использующим ассоциированные типы, мы можем выбрать, каким будет тип Item, только один раз, потому что может быть только одна impl Iterator for Counter. Нам не нужно указывать, что мы хотим итератор значений u32, везде, где мы вызываем next для Counter.
Ассоциированные типы также становятся частью контракта трейта: реализующие трейт должны предоставить тип, который будет заменять заполнитель ассоциированного типа. Ассоциированные типы часто имеют имя, описывающее, как будет использоваться тип, и документирование ассоциированного типа в документации API является хорошей практикой.
Использование параметров обобщённого типа по умолчанию и перегрузки операторов
Когда мы используем параметры обобщённого типа, мы можем указать конкретный тип по умолчанию для обобщённого типа. Это устраняет необходимость для реализующих трейт указывать конкретный тип, если тип по умолчанию подходит. Вы указываете тип по умолчанию при объявлении обобщённого типа с синтаксисом <PlaceholderType=ConcreteType>.
Отличным примером ситуации, где эта техника полезна, является перегрузка операторов, в которой вы настраиваете поведение оператора (такого как +) в определённых ситуациях.
Rust не позволяет вам создавать собственные операторы или перегружать произвольные операторы. Но вы можете перегружать операции и соответствующие трейты, перечисленные в std::ops, реализуя трейты, связанные с оператором. Например, в листинге 20-15 мы перегружаем оператор +, чтобы складывать два экземпляра Point. Мы делаем это, реализуя трейт Add для структуры Point.
use std::ops::Add;
#[derive(Debug, Copy, Clone, PartialEq)]
struct Point {
x: i32,
y: i32,
}
impl Add for Point {
type Output = Point;
fn add(self, other: Point) -> Point {
Point {
x: self.x + other.x,
y: self.y + other.y,
}
}
}
fn main() {
assert_eq!(
Point { x: 1, y: 0 } + Point { x: 2, y: 3 },
Point { x: 3, y: 3 }
);
}
Add для перегрузки оператора + для экземпляров PointМетод add складывает значения x двух экземпляров Point и значения y двух экземпляров Point, чтобы создать новый Point. Трейт Add имеет ассоциированный тип с именем Output, который определяет тип, возвращаемый методом add.
Обобщённый тип по умолчанию в этом коде находится внутри трейта Add. Вот его определение:
#![allow(unused)]
fn main() {
trait Add<Rhs=Self> {
type Output;
fn add(self, rhs: Rhs) -> Self::Output;
}
}
Этот код должен выглядеть в целом знакомым: трейт с одним методом и ассоциированным типом. Новая часть — Rhs=Self: этот синтаксис называется параметрами типа по умолчанию. Обобщённый параметр типа Rhs (сокращение от «right-hand side» — правая сторона) определяет тип параметра rhs в методе add. Если мы не указываем конкретный тип для Rhs при реализации трейта Add, тип Rhs будет по умолчанию равен Self, который будет типом, для которого мы реализуем Add.
Когда мы реализовали Add для Point, мы использовали значение по умолчанию для Rhs, потому что хотели складывать два экземпляра Point. Давайте рассмотрим пример реализации трейта Add, где мы хотим настроить тип Rhs вместо использования значения по умолчанию.
У нас есть две структуры, Millimeters и Meters, содержащие значения в разных единицах измерения. Это тонкое обёртывание существующего типа в другую структуру известно как паттерн newtype, который мы описываем более подробно в разделе «Реализация внешних трейтов с помощью паттерна newtype». Мы хотим складывать значения в миллиметрах со значениями в метрах и иметь реализацию Add, которая правильно выполняет преобразование. Мы можем реализовать Add для Millimeters с Meters в качестве Rhs, как показано в листинге 20-16.
use std::ops::Add;
struct Millimeters(u32);
struct Meters(u32);
impl Add<Meters> for Millimeters {
type Output = Millimeters;
fn add(self, other: Meters) -> Millimeters {
Millimeters(self.0 + (other.0 * 1000))
}
}
Add для Millimeters для сложения Millimeters и MetersЧтобы складывать Millimeters и Meters, мы указываем impl Add<Meters>, чтобы установить значение параметра типа Rhs вместо использования значения по умолчанию Self.
Вы будете использовать параметры типа по умолчанию двумя основными способами:
- Чтобы расширить тип без нарушения существующего кода
- Чтобы разрешить настройку в конкретных случаях, которые большинству пользователей не понадобятся
Трейт Add из стандартной библиотеки является примером второй цели: обычно вы складываете два однотипных значения, но трейт Add предоставляет возможность настройки за пределами этого. Использование параметра типа по умолчанию в определении трейта Add означает, что вам не нужно указывать дополнительный параметр в большинстве случаев. Другими словами, немного шаблонного кода реализации не требуется, что облегчает использование трейта.
Первая цель похожа на вторую, но в обратном порядке: если вы хотите добавить параметр типа к существующему трейту, вы можете дать ему значение по умолчанию, чтобы разрешить расширение функциональности трейта без нарушения существующего кода реализации.
Устранение неоднозначности между методами с одинаковыми именами
Ничто в Rust не мешает трейту иметь метод с тем же именем, что и метод другого трейта, и Rust не мешает вам реализовать оба трейта для одного типа. Также возможно реализовать метод непосредственно для типа с тем же именем, что и методы из трейтов.
При вызове методов с одинаковыми именами вам нужно указать Rust, какой из них вы хотите использовать. Рассмотрим код в листинге 20-17, где мы определили два трейта, Pilot и Wizard, оба с методом fly. Затем мы реализуем оба трейта для типа Human, у которого уже есть метод с именем fly, реализованный непосредственно для него. Каждый метод fly делает что-то разное.
trait Pilot {
fn fly(&self);
}
trait Wizard {
fn fly(&self);
}
struct Human;
impl Pilot for Human {
fn fly(&self) {
println!("This is your captain speaking.");
}
}
impl Wizard for Human {
fn fly(&self) {
println!("Up!");
}
}
impl Human {
fn fly(&self) {
println!("*waving arms furiously*");
}
}
fn main() {}
fly и реализованы для типа Human, а метод fly реализован непосредственно для Human.Когда мы вызываем fly для экземпляра Human, компилятор по умолчанию вызывает метод, реализованный непосредственно для типа, как показано в листинге 20-18.
trait Pilot {
fn fly(&self);
}
trait Wizard {
fn fly(&self);
}
struct Human;
impl Pilot for Human {
fn fly(&self) {
println!("This is your captain speaking.");
}
}
impl Wizard for Human {
fn fly(&self) {
println!("Up!");
}
}
impl Human {
fn fly(&self) {
println!("*waving arms furiously*");
}
}
fn main() {
let person = Human;
person.fly();
}
fly для экземпляра HumanЗапуск этого кода напечатает *waving arms furiously*, показывая, что Rust вызвал метод fly, реализованный непосредственно для Human.
Чтобы вызвать методы fly из трейта Pilot или трейта Wizard, нам нужно использовать более явный синтаксис, чтобы указать, какой метод fly мы имеем в виду. Листинг 20-19 демонстрирует этот синтаксис.
trait Pilot {
fn fly(&self);
}
trait Wizard {
fn fly(&self);
}
struct Human;
impl Pilot for Human {
fn fly(&self) {
println!("This is your captain speaking.");
}
}
impl Wizard for Human {
fn fly(&self) {
println!("Up!");
}
}
impl Human {
fn fly(&self) {
println!("*waving arms furiously*");
}
}
fn main() {
let person = Human;
Pilot::fly(&person);
Wizard::fly(&person);
person.fly();
}
fly из какого трейта мы хотим вызватьУказание имени трейта перед именем метода проясняет для Rust, какую реализацию fly мы хотим вызвать. Мы также могли бы написать Human::fly(&person), что эквивалентно person.fly(), который мы использовали в листинге 20-19, но это немного длиннее писать, если нам не нужно устранять неоднозначность.
Запуск этого кода печатает следующее:
$ cargo run
Compiling traits-example v0.1.0 (file:///projects/traits-example)
Finished `dev` profile [unoptimized + debuginfo] target(s) in 0.46s
Running `target/debug/traits-example`
This is your captain speaking.
Up!
*waving arms furiously*
Поскольку метод fly принимает параметр self, если бы у нас было два типа, которые оба реализуют один трейт, Rust мог бы определить, какую реализацию трейта использовать, основываясь на типе self.
Однако ассоциированные функции, которые не являются методами, не имеют параметра self. Когда есть несколько типов или трейтов, которые определяют функции, не являющиеся методами, с одинаковым именем функции, Rust не всегда знает, какой тип вы имеете в виду, если вы не используете полный синтаксис. Например, в листинге 20-20 мы создаём трейт для приюта для животных, который хочет назвать всех щенков Спот. Мы создаём трейт Animal с ассоциированной функцией, не являющейся методом, baby_name. Трейт Animal реализован для структуры Dog, для которой мы также напрямую предоставляем ассоциированную функцию, не являющуюся методом, baby_name.
trait Animal {
fn baby_name() -> String;
}
struct Dog;
impl Dog {
fn baby_name() -> String {
String::from("Spot")
}
}
impl Animal for Dog {
fn baby_name() -> String {
String::from("puppy")
}
}
fn main() {
println!("A baby dog is called a {}", Dog::baby_name());
}
Мы реализуем код для именования всех щенков Спот в ассоциированной функции baby_name, которая определена для Dog. Тип Dog также реализует трейт Animal, который описывает характеристики, присущие всем животным. Щенков называют puppies, и это выражено в реализации трейта Animal для Dog в функции baby_name, ассоциированной с трейтом Animal.
В main мы вызываем функцию Dog::baby_name, которая напрямую вызывает ассоциированную функцию, определённую для Dog. Этот код печатает следующее:
$ cargo run
Compiling traits-example v0.1.0 (file:///projects/traits-example)
Finished `dev` profile [unoptimized + debuginfo] target(s) in 0.54s
Running `target/debug/traits-example`
A baby dog is called a Spot
Этот вывод не то, что мы хотели. Мы хотим вызвать функцию baby_name, которая является частью трейта Animal, который мы реализовали для Dog, чтобы код напечатал A baby dog is called a puppy. Техника указания имени трейта, которую мы использовали в листинге 20-19, здесь не помогает; если мы изменим main на код в листинге 20-21, мы получим ошибку компиляции.
trait Animal {
fn baby_name() -> String;
}
struct Dog;
impl Dog {
fn baby_name() -> String {
String::from("Spot")
}
}
impl Animal for Dog {
fn baby_name() -> String {
String::from("puppy")
}
}
fn main() {
println!("A baby dog is called a {}", Animal::baby_name());
}
baby_name из трейта Animal, но Rust не знает, какую реализацию использоватьПоскольку Animal::baby_name не имеет параметра self, и могут быть другие типы, реализующие трейт Animal, Rust не может определить, какую реализацию Animal::baby_name мы хотим. Мы получим эту ошибку компилятора:
$ cargo run
Compiling traits-example v0.1.0 (file:///projects/traits-example)
error[E0790]: cannot call associated function on trait without specifying the corresponding `impl` type
--> src/main.rs:20:43
|
2 | fn baby_name() -> String;
| ------------------------- `Animal::baby_name` defined here
...
20 | println!("A baby dog is called a {}", Animal::baby_name());
| ^^^^^^^^^^^^^^^^^^^ cannot call associated function of trait
|
help: use the fully-qualified path to the only available implementation
|
20 | println!("A baby dog is called a {}", <Dog as Animal>::baby_name());
| +++++++ +
For more information about this error, try `rustc --explain E0790`.
error: could not compile `traits-example` (bin "traits-example") due to 1 previous error
Чтобы устранить неоднозначность и сказать Rust, что мы хотим использовать реализацию Animal для Dog, а не реализацию Animal для какого-то другого типа, нам нужно использовать полный синтаксис. Листинг 20-22 демонстрирует, как использовать полный синтаксис.
trait Animal {
fn baby_name() -> String;
}
struct Dog;
impl Dog {
fn baby_name() -> String {
String::from("Spot")
}
}
impl Animal for Dog {
fn baby_name() -> String {
String::from("puppy")
}
}
fn main() {
println!("A baby dog is called a {}", <Dog as Animal>::baby_name());
}
baby_name из трейта Animal, реализованную для DogМы предоставляем Rust аннотацию типа внутри угловых скобок, которая указывает, что мы хотим вызвать метод baby_name из трейта Animal, реализованный для Dog, говоря, что мы хотим рассматривать тип Dog как Animal для этого вызова функции. Этот код теперь напечатает то, что мы хотим:
$ cargo run
Compiling traits-example v0.1.0 (file:///projects/traits-example)
Finished `dev` profile [unoptimized + debuginfo] target(s) in 0.48s
Running `target/debug/traits-example`
A baby dog is called a puppy
В общем, полный синтаксис определяется следующим образом:
<Type as Trait>::function(receiver_if_method, next_arg, ...);
Для ассоциированных функций, не являющихся методами, не было бы receiver: там был бы только список других аргументов. Вы можете использовать полный синтаксис везде, где вызываете функции или методы. Однако вам разрешено опускать любую часть этого синтаксиса, которую Rust может вывести из другой информации в программе. Вам нужно использовать этот более подробный синтаксис только в случаях, когда есть несколько реализаций с одинаковым именем, и Rust нужна помощь, чтобы определить, какую реализацию вы хотите вызвать.
Использование супертрейтов
Иногда вы можете написать определение трейта, которое зависит от другого трейта: чтобы тип реализовал первый трейт, вы хотите потребовать, чтобы этот тип также реализовывал второй трейт. Вы сделали бы это, чтобы определение вашего трейта могло использовать ассоциированные элементы второго трейта. Трейт, на который опирается определение вашего трейта, называется супертрейтом вашего трейта.
Например, допустим, мы хотим создать трейт OutlinePrint с методом outline_print, который печатает заданное значение, отформатированное так, чтобы оно было обрамлено звёздочками. То есть, для структуры Point, которая реализует трейт Display стандартной библиотеки, дающий (x, y), когда мы вызываем outline_print для экземпляра Point, у которого 1 для x и 3 для y, он должен напечатать следующее:
**********
* *
* (1, 3) *
* *
**********
В реализации метода outline_print мы хотим использовать функциональность трейта Display. Поэтому нам нужно указать, что трейт OutlinePrint будет работать только для типов, которые также реализуют Display и предоставляют функциональность, необходимую OutlinePrint. Мы можем сделать это в определении трейта, указав OutlinePrint: Display. Эта техника похожа на добавление ограничения трейта к трейту. Листинг 20-23 показывает реализацию трейта OutlinePrint.
use std::fmt;
trait OutlinePrint: fmt::Display {
fn outline_print(&self) {
let output = self.to_string();
let len = output.len();
println!("{}", "*".repeat(len + 4));
println!("*{}*", " ".repeat(len + 2));
println!("* {output} *");
println!("*{}*", " ".repeat(len + 2));
println!("{}", "*".repeat(len + 4));
}
}
fn main() {}
OutlinePrint, который требует функциональность из DisplayПоскольку мы указали, что OutlinePrint требует трейт Display, мы можем использовать функцию to_string, которая автоматически реализуется для любого типа, реализующего Display. Если бы мы попытались использовать to_string без добавления двоеточия и указания трейта Display после имени трейта, мы получили бы ошибку, говорящую, что метод с именем to_string не найден для типа &Self в текущей области видимости.
Давайте посмотрим, что произойдёт, когда мы попытаемся реализовать OutlinePrint для типа, который не реализует Display, такого как структура Point:
use std::fmt;
trait OutlinePrint: fmt::Display {
fn outline_print(&self) {
let output = self.to_string();
let len = output.len();
println!("{}", "*".repeat(len + 4));
println!("*{}*", " ".repeat(len + 2));
println!("* {output} *");
println!("*{}*", " ".repeat(len + 2));
println!("{}", "*".repeat(len + 4));
}
}
struct Point {
x: i32,
y: i32,
}
impl OutlinePrint for Point {}
fn main() {
let p = Point { x: 1, y: 3 };
p.outline_print();
}
Мы получаем ошибку, говорящую, что Display требуется, но не реализован:
$ cargo run
Compiling traits-example v0.1.0 (file:///projects/traits-example)
error[E0277]: `Point` doesn't implement `std::fmt::Display`
--> src/main.rs:20:23
|
20 | impl OutlinePrint for Point {}
| ^^^^^ unsatisfied trait bound
|
help: the trait `std::fmt::Display` is not implemented for `Point`
--> src/main.rs:15:1
|
15 | struct Point {
| ^^^^^^^^^^^^
note: required by a bound in `OutlinePrint`
--> src/main.rs:3:21
|
3 | trait OutlinePrint: fmt::Display {
| ^^^^^^^^^^^^ required by this bound in `OutlinePrint`
error[E0277]: `Point` doesn't implement `std::fmt::Display`
--> src/main.rs:24:7
|
24 | p.outline_print();
| ^^^^^^^^^^^^^ unsatisfied trait bound
|
help: the trait `std::fmt::Display` is not implemented for `Point`
--> src/main.rs:15:1
|
15 | struct Point {
| ^^^^^^^^^^^^
note: required by a bound in `OutlinePrint::outline_print`
--> src/main.rs:3:21
|
3 | trait OutlinePrint: fmt::Display {
| ^^^^^^^^^^^^ required by this bound in `OutlinePrint::outline_print`
4 | fn outline_print(&self) {
| ------------- required by a bound in this associated function
For more information about this error, try `rustc --explain E0277`.
error: could not compile `traits-example` (bin "traits-example") due to 2 previous errors
Чтобы исправить это, мы реализуем Display для Point и удовлетворяем ограничению, которое требует OutlinePrint, вот так:
trait OutlinePrint: fmt::Display {
fn outline_print(&self) {
let output = self.to_string();
let len = output.len();
println!("{}", "*".repeat(len + 4));
println!("*{}*", " ".repeat(len + 2));
println!("* {output} *");
println!("*{}*", " ".repeat(len + 2));
println!("{}", "*".repeat(len + 4));
}
}
struct Point {
x: i32,
y: i32,
}
impl OutlinePrint for Point {}
use std::fmt;
impl fmt::Display for Point {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "({}, {})", self.x, self.y)
}
}
fn main() {
let p = Point { x: 1, y: 3 };
p.outline_print();
}
Затем реализация трейта OutlinePrint для Point успешно скомпилируется, и мы сможем вызвать outline_print для экземпляра Point, чтобы отобразить его в обрамлении из звёздочек.
Реализация внешних трейтов с помощью паттерна newtype
В разделе «Реализация трейта для типа» главы 10 мы упоминали правило сиротства, которое гласит, что нам разрешено реализовывать трейт для типа, только если либо трейт, либо тип, либо оба локальны для нашего крейта. Можно обойти это ограничение с помощью паттерна newtype, который включает создание нового типа в кортежной структуре. (Мы рассматривали кортежные структуры в разделе «Создание разных типов с помощью кортежных структур» главы 5.) Кортежная структура будет иметь одно поле и будет тонкой обёрткой вокруг типа, для которого мы хотим реализовать трейт. Затем тип-обёртка локальный для нашего крейта, и мы можем реализовать трейт для обёртки. Newtype — это термин, происходящий из языка программирования Haskell. Использование этого паттерна не влечёт за собой накладных расходов во время выполнения, а тип-обёртка устраняется во время компиляции.
В качестве примера допустим, мы хотим реализовать Display для Vec<T>, что правило сиротства не позволяет нам сделать напрямую, потому что трейт Display и тип Vec<T> определены вне нашего крейта. Мы можем создать структуру Wrapper, которая содержит экземпляр Vec<T>; затем мы можем реализовать Display для Wrapper и использовать значение Vec<T>, как показано в листинге 20-24.
use std::fmt;
struct Wrapper(Vec<String>);
impl fmt::Display for Wrapper {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "[{}]", self.0.join(", "))
}
}
fn main() {
let w = Wrapper(vec![String::from("hello"), String::from("world")]);
println!("w = {w}");
}
Wrapper вокруг Vec<String> для реализации DisplayРеализация Display использует self.0 для доступа к внутреннему Vec<T>, потому что Wrapper — это кортежная структура, а Vec<T> — это элемент с индексом 0 в кортеже. Затем мы можем использовать функциональность трейта Display для Wrapper.
Недостаток использования этой техники заключается в том, что Wrapper — это новый тип, поэтому у него нет методов значения, которое он содержит. Нам пришлось бы реализовать все методы Vec<T> непосредственно для Wrapper, чтобы методы делегировали self.0, что позволило бы нам обращаться с Wrapper точно так же, как с Vec<T>. Если мы хотим, чтобы новый тип имел каждый метод, который есть у внутреннего типа, реализация трейта Deref для Wrapper для возврата внутреннего типа была бы решением (мы обсуждали реализацию трейта Deref в разделе «Обращение с умными указателями как с обычными ссылками» главы 15). Если мы не хотели, чтобы тип Wrapper имел все методы внутреннего типа — например, чтобы ограничить поведение типа Wrapper — нам пришлось бы реализовать только те методы, которые мы действительно хотим, вручную.
Этот паттерн newtype также полезен, даже когда трейты не задействованы. Давайте переключим внимание и рассмотрим некоторые продвинутые способы взаимодействия с системой типов Rust.