Определение общего поведения с помощью трейтов
Трейт определяет функциональность, которой обладает определённый тип и которую он может разделять с другими типами. Мы можем использовать трейты для абстрактного определения общего поведения. Мы можем использовать ограничения трейтов, чтобы указать, что обобщённый тип может быть любым типом, обладающим определённым поведением.
Примечание: Трейты похожи на возможность, которую в других языках часто называют интерфейсами, хотя и с некоторыми различиями.
Определение трейта
Поведение типа состоит из методов, которые мы можем вызывать для этого типа. Различные типы разделяют одно и то же поведение, если мы можем вызывать одни и те же методы для всех этих типов. Определения трейтов — это способ сгруппировать сигнатуры методов вместе, чтобы определить набор поведений, необходимых для достижения некоторой цели.
Например, допустим, у нас есть несколько структур, которые содержат различные виды и
объёмы текста: структура NewsArticle, которая содержит новостную статью, поданную в
определённом месте, и SocialPost, которая может иметь не более 280 символов
вместе с метаданными, указывающими, была ли это новая публикация, репост или
ответ на другую публикацию.
Мы хотим создать библиотечный крейт медиа-агрегатора с именем aggregator, который может
отображать сводки данных, которые могут храниться в экземпляре NewsArticle или
SocialPost. Для этого нам нужна сводка от каждого типа, и мы
запросим эту сводку, вызвав метод summarize для экземпляра. Листинг
10-12 показывает определение публичного трейта Summary, который выражает это
поведение.
pub trait Summary {
fn summarize(&self) -> String;
}
Summary, который состоит из поведения, предоставляемого методом summarizeЗдесь мы объявляем трейт с помощью ключевого слова trait, а затем имени трейта,
которое в данном случае — Summary. Мы также объявляем трейт как pub, чтобы
крейты, зависящие от этого крейта, тоже могли использовать этот трейт, как мы увидим в
нескольких примерах. Внутри фигурных скобок мы объявляем сигнатуры методов,
которые описывают поведения типов, реализующих этот трейт, что в
данном случае — fn summarize(&self) -> String.
После сигнатуры метода вместо предоставления реализации внутри фигурных
скобок мы используем точку с запятой. Каждый тип, реализующий этот трейт, должен предоставить
своё собственное поведение для тела метода. Компилятор обеспечит,
что любой тип, имеющий трейт Summary, будет иметь метод summarize,
определённый точно с этой сигнатурой.
Трейт может иметь несколько методов в своём теле: сигнатуры методов перечисляются по одной на строку, и каждая строка заканчивается точкой с запятой.
Реализация трейта для типа
Теперь, когда мы определили желаемые сигнатуры методов трейта Summary,
мы можем реализовать его для типов в нашем медиа-агрегаторе. Листинг 10-13 показывает
реализацию трейта Summary для структуры NewsArticle, которая использует
заголовок, автора и местоположение для создания возвращаемого значения
summarize. Для структуры SocialPost мы определяем summarize как имя пользователя,
за которым следует весь текст публикации, предполагая, что содержимое публикации
уже ограничено 280 символами.
pub trait Summary {
fn summarize(&self) -> String;
}
pub struct NewsArticle {
pub headline: String,
pub location: String,
pub author: String,
pub content: String,
}
impl Summary for NewsArticle {
fn summarize(&self) -> String {
format!("{}, by {} ({})", self.headline, self.author, self.location)
}
}
pub struct SocialPost {
pub username: String,
pub content: String,
pub reply: bool,
pub repost: bool,
}
impl Summary for SocialPost {
fn summarize(&self) -> String {
format!("{}: {}", self.username, self.content)
}
}
Summary для типов NewsArticle и SocialPostРеализация трейта для типа похожа на реализацию обычных методов. Разница
в том, что после impl мы помещаем имя трейта, который хотим реализовать,
затем используем ключевое слово for, а затем указываем имя типа, для которого хотим
реализовать трейт. Внутри блока impl мы помещаем сигнатуры методов,
которые были определены в определении трейта. Вместо добавления точки с запятой после каждой
сигнатуры мы используем фигурные скобки и заполняем тело метода конкретным
поведением, которое мы хотим, чтобы методы трейта имели для конкретного типа.
Теперь, когда библиотека реализовала трейт Summary для NewsArticle и
SocialPost, пользователи крейта могут вызывать методы трейта для экземпляров
NewsArticle и SocialPost так же, как мы вызываем обычные методы. Единственное
различие в том, что пользователь должен ввести трейт в область видимости, а также
типы. Вот пример того, как бинарный крейт мог бы использовать наш библиотечный крейт aggregator:
use aggregator::{SocialPost, Summary};
fn main() {
let post = SocialPost {
username: String::from("horse_ebooks"),
content: String::from(
"of course, as you probably already know, people",
),
reply: false,
repost: false,
};
println!("1 new post: {}", post.summarize());
}
Этот код печатает 1 new post: horse_ebooks: of course, as you probably already know, people.
Другие крейты, которые зависят от крейта aggregator, также могут ввести трейт Summary
в область видимости, чтобы реализовать Summary для своих собственных типов. Одно ограничение, о котором следует
отметить, состоит в том, что мы можем реализовать трейт для типа, только если либо трейт, либо
тип, либо оба являются локальными для нашего крейта. Например, мы можем реализовать стандартные
библиотечные трейты, такие как Display, для пользовательского типа, такого как SocialPost, в рамках нашей
функциональности крейта aggregator, потому что тип SocialPost является локальным для нашего
крейта aggregator. Мы также можем реализовать Summary для Vec<T> в нашем
крейте aggregator, потому что трейт Summary является локальным для нашего крейта
aggregator.
Но мы не можем реализовать внешние трейты для внешних типов. Например, мы не можем
реализовать трейт Display для Vec<T> в нашем крейте aggregator,
потому что и Display, и Vec<T> определены в стандартной библиотеке и
не являются локальными для нашего крейта aggregator. Это ограничение является частью свойства,
называемого согласованностью, и более конкретно правилом сироты, названным так потому,
что родительский тип отсутствует. Это правило гарантирует, что код других людей
не может сломать ваш код, и наоборот. Без этого правила два крейта могли бы
реализовать один и тот же трейт для одного и того же типа, и Rust не знал бы, какую
реализацию использовать.
Использование реализаций по умолчанию
Иногда полезно иметь поведение по умолчанию для некоторых или всех методов в трейте вместо того, чтобы требовать реализации для всех методов для каждого типа. Тогда, реализуя трейт для конкретного типа, мы можем сохранить или переопределить поведение по умолчанию каждого метода.
В листинге 10-14 мы указываем строку по умолчанию для метода summarize трейта
Summary вместо того, чтобы только определять сигнатуру метода, как мы делали в
листинге 10-12.
pub trait Summary {
fn summarize(&self) -> String {
String::from("(Read more...)")
}
}
pub struct NewsArticle {
pub headline: String,
pub location: String,
pub author: String,
pub content: String,
}
impl Summary for NewsArticle {}
pub struct SocialPost {
pub username: String,
pub content: String,
pub reply: bool,
pub repost: bool,
}
impl Summary for SocialPost {
fn summarize(&self) -> String {
format!("{}: {}", self.username, self.content)
}
}
Summary с реализацией метода summarize по умолчаниюЧтобы использовать реализацию по умолчанию для суммирования экземпляров NewsArticle, мы
указываем пустой блок impl с impl Summary for NewsArticle {}.
Хотя мы больше не определяем метод summarize для NewsArticle
напрямую, мы предоставили реализацию по умолчанию и указали, что
NewsArticle реализует трейт Summary. В результате мы по-прежнему можем вызывать
метод summarize для экземпляра NewsArticle, вот так:
use aggregator::{self, NewsArticle, Summary};
fn main() {
let article = NewsArticle {
headline: String::from("Penguins win the Stanley Cup Championship!"),
location: String::from("Pittsburgh, PA, USA"),
author: String::from("Iceburgh"),
content: String::from(
"The Pittsburgh Penguins once again are the best \
hockey team in the NHL.",
),
};
println!("New article available! {}", article.summarize());
}
Этот код печатает New article available! (Read more...).
Создание реализации по умолчанию не требует от нас изменения чего-либо в
реализации Summary для SocialPost в листинге 10-13. Причина в
том, что синтаксис для переопределения реализации по умолчанию такой же, как
синтаксис для реализации метода трейта, который не имеет реализации
по умолчанию.
Реализации по умолчанию могут вызывать другие методы в том же трейте, даже если эти
другие методы не имеют реализации по умолчанию. Таким образом, трейт может
предоставлять много полезной функциональности и требовать от реализующих только указания
небольшой её части. Например, мы могли бы определить трейт Summary так, чтобы он имел
метод summarize_author, реализация которого требуется, а затем определить
метод summarize, который имеет реализацию по умолчанию, вызывающую
метод summarize_author:
pub trait Summary {
fn summarize_author(&self) -> String;
fn summarize(&self) -> String {
format!("(Read more from {}...)", self.summarize_author())
}
}
pub struct SocialPost {
pub username: String,
pub content: String,
pub reply: bool,
pub repost: bool,
}
impl Summary for SocialPost {
fn summarize_author(&self) -> String {
format!("@{}", self.username)
}
}
Чтобы использовать эту версию Summary, нам нужно только определить summarize_author,
когда мы реализуем трейт для типа:
pub trait Summary {
fn summarize_author(&self) -> String;
fn summarize(&self) -> String {
format!("(Read more from {}...)", self.summarize_author())
}
}
pub struct SocialPost {
pub username: String,
pub content: String,
pub reply: bool,
pub repost: bool,
}
impl Summary for SocialPost {
fn summarize_author(&self) -> String {
format!("@{}", self.username)
}
}
После того как мы определили summarize_author, мы можем вызывать summarize для экземпляров
структуры SocialPost, и реализация summarize по умолчанию вызовет
определение summarize_author, которое мы предоставили. Поскольку мы реализовали
summarize_author, трейт Summary дал нам поведение
метода summarize, не требуя от нас писать дополнительный код. Вот как
это выглядит:
use aggregator::{self, SocialPost, Summary};
fn main() {
let post = SocialPost {
username: String::from("horse_ebooks"),
content: String::from(
"of course, as you probably already know, people",
),
reply: false,
repost: false,
};
println!("1 new post: {}", post.summarize());
}
Этот код печатает 1 new post: (Read more from @horse_ebooks...).
Обратите внимание, что невозможно вызвать реализацию по умолчанию из переопределяющей реализации того же метода.
Использование трейтов в качестве параметров
Теперь, когда вы знаете, как определять и реализовывать трейты, мы можем исследовать, как использовать
трейты для определения функций, принимающих множество различных типов. Мы будем использовать трейт
Summary, который мы реализовали для типов NewsArticle и SocialPost в
листинге 10-13, чтобы определить функцию notify, которая вызывает метод summarize
для своего параметра item, который имеет некоторый тип, реализующий трейт Summary.
Для этого мы используем синтаксис impl Trait, вот так:
pub trait Summary {
fn summarize(&self) -> String;
}
pub struct NewsArticle {
pub headline: String,
pub location: String,
pub author: String,
pub content: String,
}
impl Summary for NewsArticle {
fn summarize(&self) -> String {
format!("{}, by {} ({})", self.headline, self.author, self.location)
}
}
pub struct SocialPost {
pub username: String,
pub content: String,
pub reply: bool,
pub repost: bool,
}
impl Summary for SocialPost {
fn summarize(&self) -> String {
format!("{}: {}", self.username, self.content)
}
}
pub fn notify(item: &impl Summary) {
println!("Breaking news! {}", item.summarize());
}
Вместо конкретного типа для параметра item мы указываем ключевое слово impl
и имя трейта. Этот параметр принимает любой тип, реализующий
указанный трейт. В теле notify мы можем вызывать любые методы для item,
которые происходят из трейта Summary, такие как summarize. Мы можем вызывать notify
и передавать любой экземпляр NewsArticle или SocialPost. Код, который вызывает
функцию с любым другим типом, таким как String или i32, не скомпилируется,
потому что эти типы не реализуют Summary.
Синтаксис ограничения трейта
Синтаксис impl Trait работает для простых случаев, но на самом деле это синтаксический
сахар для более длинной формы, известной как ограничение трейта; она выглядит так:
pub fn notify<T: Summary>(item: &T) {
println!("Breaking news! {}", item.summarize());
}
Эта более длинная форма эквивалентна примеру из предыдущего раздела, но более многословна. Мы размещаем ограничения трейта с объявлением обобщённого типа параметра после двоеточия и внутри угловых скобок.
Синтаксис impl Trait удобен и делает код более лаконичным в простых
случаях, в то время как более полный синтаксис ограничения трейта может выражать большую сложность в других
случаях. Например, у нас может быть два параметра, реализующих Summary. Сделать
это с синтаксисом impl Trait выглядит так:
pub fn notify(item1: &impl Summary, item2: &impl Summary) {
Использовать impl Trait уместно, если мы хотим, чтобы эта функция позволяла item1 и
item2 иметь разные типы (при условии, что оба типа реализуют Summary). Если
мы хотим заставить оба параметра иметь один и тот же тип, однако, мы должны использовать
ограничение трейта, вот так:
pub fn notify<T: Summary>(item1: &T, item2: &T) {
Обобщённый тип T, указанный как тип параметров item1 и item2,
ограничивает функцию так, что конкретный тип значения,
передаваемого в качестве аргумента для item1 и item2, должен быть одинаковым.
Множественные ограничения трейтов с синтаксисом +
Мы также можем указать более одного ограничения трейта. Допустим, мы хотели, чтобы notify использовал
форматирование отображения, а также summarize для item: мы указываем в определении
notify, что item должен реализовывать как Display, так и Summary. Мы можем
сделать это с помощью синтаксиса +:
pub fn notify(item: &(impl Summary + Display)) {
Синтаксис + также допустим с ограничениями трейтов для обобщённых типов:
pub fn notify<T: Summary + Display>(item: &T) {
С указанными двумя ограничениями трейтов тело notify может вызывать summarize
и использовать {} для форматирования item.
Более ясные ограничения трейтов с помощью предложений where
Использование слишком большого количества ограничений трейтов имеет свои недостатки. Каждый обобщённый тип имеет свои собственные
ограничения трейтов, поэтому функции с несколькими обобщёнными параметрами типа могут содержать много
информации об ограничениях трейтов между именем функции и её списком параметров,
что делает сигнатуру функции трудной для чтения. По этой причине Rust имеет альтернативный
синтаксис для указания ограничений трейтов внутри предложения where после сигнатуры
функции. Так, вместо того чтобы писать это:
fn some_function<T: Display + Clone, U: Clone + Debug>(t: &T, u: &U) -> i32 {
мы можем использовать предложение where, вот так:
fn some_function<T, U>(t: &T, u: &U) -> i32
where
T: Display + Clone,
U: Clone + Debug,
{
unimplemented!()
}
Сигнатура этой функции менее загромождена: имя функции, список параметров и тип возвращаемого значения находятся близко друг к другу, как в функции без множества ограничений трейтов.
Возврат типов, реализующих трейты
Мы также можем использовать синтаксис impl Trait в позиции возвращаемого типа, чтобы вернуть
значение некоторого типа, реализующего трейт, как показано здесь:
pub trait Summary {
fn summarize(&self) -> String;
}
pub struct NewsArticle {
pub headline: String,
pub location: String,
pub author: String,
pub content: String,
}
impl Summary for NewsArticle {
fn summarize(&self) -> String {
format!("{}, by {} ({})", self.headline, self.author, self.location)
}
}
pub struct SocialPost {
pub username: String,
pub content: String,
pub reply: bool,
pub repost: bool,
}
impl Summary for SocialPost {
fn summarize(&self) -> String {
format!("{}: {}", self.username, self.content)
}
}
fn returns_summarizable() -> impl Summary {
SocialPost {
username: String::from("horse_ebooks"),
content: String::from(
"of course, as you probably already know, people",
),
reply: false,
repost: false,
}
}
Используя impl Summary для типа возвращаемого значения, мы указываем, что
функция returns_summarizable возвращает некоторый тип, реализующий трейт Summary,
не называя конкретный тип. В этом случае returns_summarizable
возвращает SocialPost, но код, вызывающий эту функцию, не нуждается в знании
этого.
Возможность указать тип возвращаемого значения только по трейту, который он реализует,
особенно полезна в контексте замыканий и итераторов, которые мы рассматриваем в
тринадцатой главе. Замыкания и итераторы создают типы, которые знает только компилятор, или
типы, которые очень длинны для указания. Синтаксис impl Trait позволяет вам лаконично
указать, что функция возвращает некоторый тип, реализующий трейт Iterator,
без необходимости выписывать очень длинный тип.
Однако вы можете использовать impl Trait только в том случае, если возвращаете один тип. Например,
этот код, который возвращает либо NewsArticle, либо SocialPost с
типом возвращаемого значения, указанным как impl Summary, не сработает:
pub trait Summary {
fn summarize(&self) -> String;
}
pub struct NewsArticle {
pub headline: String,
pub location: String,
pub author: String,
pub content: String,
}
impl Summary for NewsArticle {
fn summarize(&self) -> String {
format!("{}, by {} ({})", self.headline, self.author, self.location)
}
}
pub struct SocialPost {
pub username: String,
pub content: String,
pub reply: bool,
pub repost: bool,
}
impl Summary for SocialPost {
fn summarize(&self) -> String {
format!("{}: {}", self.username, self.content)
}
}
fn returns_summarizable(switch: bool) -> impl Summary {
if switch {
NewsArticle {
headline: String::from(
"Penguins win the Stanley Cup Championship!",
),
location: String::from("Pittsburgh, PA, USA"),
author: String::from("Iceburgh"),
content: String::from(
"The Pittsburgh Penguins once again are the best \
hockey team in the NHL.",
),
}
} else {
SocialPost {
username: String::from("horse_ebooks"),
content: String::from(
"of course, as you probably already know, people",
),
reply: false,
repost: false,
}
}
}
Возврат либо NewsArticle, либо SocialPost не разрешён из-за
ограничений на то, как синтаксис impl Trait реализован в компиляторе.
Мы рассмотрим, как написать функцию с таким поведением, в разделе «Использование трейт-объектов для абстрагирования над общим поведением»
в восемнадцатой главе.
Использование ограничений трейтов для условной реализации методов
Используя ограничение трейта с блоком impl, который использует обобщённые параметры типа,
мы можем условно реализовать методы для типов, реализующих указанные
трейты. Например, тип Pair<T> в листинге 10-15 всегда реализует
функцию new для возврата нового экземпляра Pair<T> (напомним из раздела «Синтаксис
методов» в пятой главе, что Self — это псевдоним типа
для типа блока impl, которым в данном случае является Pair<T>). Но
в следующем блоке impl Pair<T> реализует метод cmp_display, только если
его внутренний тип T реализует трейт PartialOrd, который позволяет сравнивать,
и трейт Display, который позволяет печатать.
use std::fmt::Display;
struct Pair<T> {
x: T,
y: T,
}
impl<T> Pair<T> {
fn new(x: T, y: T) -> Self {
Self { x, y }
}
}
impl<T: Display + PartialOrd> Pair<T> {
fn cmp_display(&self) {
if self.x >= self.y {
println!("The largest member is x = {}", self.x);
} else {
println!("The largest member is y = {}", self.y);
}
}
}
Мы также можем условно реализовать трейт для любого типа, который реализует
другой трейт. Реализации трейта для любого типа, удовлетворяющего ограничениям
трейта, называются универсальными реализациями и широко используются в
стандартной библиотеке Rust. Например, стандартная библиотека реализует
трейт ToString для любого типа, реализующего трейт Display. Блок impl
в стандартной библиотеке выглядит примерно так:
impl<T: Display> ToString for T {
// --snip--
}
Поскольку в стандартной библиотеке есть эта универсальная реализация, мы можем вызывать
метод to_string, определённый трейтом ToString, для любого типа, реализующего
трейт Display. Например, мы можем превратить целые числа в соответствующие
значения String вот так, потому что целые числа реализуют Display:
#![allow(unused)]
fn main() {
let s = 3.to_string();
}
Универсальные реализации появляются в документации для трейта в разделе «Implementors» (Реализующие типы).
Трейты и ограничения трейтов позволяют нам писать код, который использует обобщённые параметры типа для уменьшения дублирования, но также указывает компилятору, что мы хотим, чтобы обобщённый тип имел определённое поведение. Затем компилятор может использовать информацию об ограничениях трейта, чтобы проверить, что все конкретные типы, используемые с нашим кодом, предоставляют правильное поведение. В динамически типизированных языках мы получили бы ошибку во время выполнения, если бы вызвали метод для типа, который не определяет этот метод. Но Rust переносит эти ошибки на время компиляции, так что мы вынуждены исправить проблемы ещё до того, как наш код сможет запуститься. Кроме того, нам не нужно писать код, который проверяет поведение во время выполнения, потому что мы уже проверили его во время компиляции. Это повышает производительность без необходимости отказываться от гибкости обобщённых типов.