Выбор между enum и trait: expression problem в Rust
Бэкграунд
На работе я пишу Ouroboros, один из многочисленных плагинов для Picodata. Он непрерывно переносит изменения данных из одного кластера в другой или в Kafka.
Многое в коде зависит от того, откуда и куда отправляются данные, и в разных его частях это выражено по-разному. Когда в кластере-источнике Picodata меняют схему (скажем, добавляют колонку), строки, прочитанные под старой схемой, должны попасть в приёмник раньше, чем туда придёт само изменение. Для этого есть барьер: он держит изменение, пока все читатели не догонят его. Для источника Tarantool изменения схемы не реплицируются, и барьера нет. Сейчас барьер описан перечислением:
enum SchemaBarrier {
Tarantool,
Picodata(PicodataBarrier),
}
Раз перечисление хранится, рано или поздно с ним придётся работать: сделать match и вызвать какой-то код в каждом из вариантов или определить для перечисления метод.
Здесь это метод. Например, остановка барьера:
impl SchemaBarrier {
fn stop(&mut self) {
match self {
Self::Tarantool => {}
Self::Picodata(b) => b.stop(),
}
}
}
У одного варианта за веткой целый механизм, у другого пустое место. Источников всего два, Tarantool и Picodata, и других не будет, так что набор вариантов здесь закрыт.
Возьмём другой пример. В репликационном потоке Tarantool приходят «пакеты», которые сигнализируют подписчику, что на мастере произошла какая-то операция. Некоторые из них Ouroboros не нужны. Отсюда фильтр, который решает, пропустить пакет к Writer’у (компоненту, который пишет в приёмник) или отбросить. Фильтр реализован трейтом с одним методом:
#[async_trait]
trait Filter {
async fn apply(&self, packet: Packet) -> Option<Packet>;
}
Фильтры собираются в цепочку Vec<Box<dyn Filter>>, и каждый пакет проходит через неё. Тот же фильтр можно было бы выразить перечислением, и тогда цепочка стала бы Vec<Filter> без Box:
enum Filter {
Space(SpaceFilter),
Bucket(BucketFilter),
Shard(ShardFilter),
}
impl Filter {
async fn apply(&self, packet: Packet) -> Option<Packet> {
match self {
Self::Space(f) => f.apply(packet).await,
Self::Bucket(f) => f.apply(packet).await,
Self::Shard(f) => f.apply(packet).await,
}
}
}
Раз способов как минимум два, возникает вопрос, какой в каком случае предпочесть.
Общая модель
Если отвлечься от Ouroboros, есть два способа выразить в Rust поведение, которое зависит от типа. Первый: enum, в котором на каждый тип свой вариант, и метод, который через match передаёт вызов одноимённому методу варианта. Второй: трейт, у которого на каждый тип своя реализация. Слева enum, справа трейт с тем же поведением.
enum Writer {
Tarantool(Tarantool),
Kafka(Kafka),
}
impl Writer {
fn write(&self, b: &Batch) {
match self {
Self::Tarantool(w) => w.write(b),
Self::Kafka(w) => w.write(b),
}
}
}
let w = Writer::Kafka(kafka);
w.write(&batch);
trait Writer {
fn write(&self, b: &Batch);
}
impl Writer for Tarantool {
fn write(&self, b: &Batch) { /* … */ }
}
impl Writer for Kafka {
fn write(&self, b: &Batch) { /* … */ }
}
let w: Box<dyn Writer> = Box::new(kafka);
w.write(&batch);
Заметьте:
- вызывающий код в обоих случаях выглядит одинаково
- оба способа позволяют каждому типу хранить любые свои данные
При этом есть и отличия:
- у
enumсписок типов записан в одном месте, и компилятор знает его целиком, а реализацию трейта может добавить кто угодно, в том числе другой крейт - размер
enumизвестен при компиляции, и значение лежит прямо в переменной, а трейт-объект хранится за указателем, обычно в куче черезBox - у
enumнужная ветка выбирается черезmatch, у трейт-объекта через таблицу виртуальных методов во время выполнения
В общем виде: есть набор типов и набор операций над ними. Код должен выполнить каждую операцию для каждого типа, то есть заполнить таблицу, где по строкам типы, а по столбцам операции.
операция f |
операция g |
новая операция | |
|---|---|---|---|
тип A |
есть | есть | ? |
тип B |
есть | есть | ? |
| новый тип | ? | ? | ? |
Отсюда вопрос:
Как выбрать между enum и трейтом, если со временем добавляются и новые типы, и новые операции над ними?
Сначала посмотрим, что об этом говорят на форумах, а потом сверим эти мнения с классической литературой.
Народная мудрость
По форумам удобно сориентироваться в теме и найти более авторитетные источники.
В 2017 году на users.rust-lang.org спросили, не вредны ли enum вообще. Известный евангелист Rust Стив Клабник ответил так:
enumнужны для закрытых множеств, а трейт-объекты для открытых. То есть если вы знаете все варианты, беритеenum. Если нет, берите трейт-объект.Steve Klabnik, users.rust-lang.org, 2017
Правило простое, но вызывает вопросы: оно смотрит только на то, закрыт ли набор вариантов, и ничего не говорит о наборе операций. В простых случаях оно работает:
- У
Result<T, E>иOption<T>ровно два варианта по определению, и других не появится, поэтому этоenum. std::io::Writeреализуют все, кому нужно куда-то писать байты: файлы, сокеты, буферы в памяти, сторонние библиотеки. Набор реализаций открыт, поэтому это трейт.
Но часто не очевидно даже то, закрыт ли набор. Все фильтры в Ouroboros пишем мы сами, и в любой момент их список известен, так что набор вроде бы закрыт. При этом новые фильтры появляются по мере надобности, и в этом смысле набор открыт.
Об операциях в том же треде написал пользователь HadrienG. Он разобрал два вида изменений. В примерах ниже Tarantool, Kafka и Picodata в версии с трейтом это обёртки над соединением: struct Tarantool(Conn), struct Kafka(Producer), struct Picodata(Client).
Первое: что будет, если добавить новую операцию, например stop. С enum это новый метод с match, остальной код не меняется. С трейтом новый метод придётся дописать в каждую реализацию, в том числе в чужом коде, если трейт публичный. Выделено то, что добавилось:
enum Writer {
Tarantool(Conn),
Kafka(Producer),
}
impl Writer {
fn write(&self, b: &Batch) {
match self {
Self::Tarantool(c) => c.insert(b),
Self::Kafka(p) => p.send(b),
}
}
fn stop(&mut self) {
match self {
Self::Tarantool(c) => c.close(),
Self::Kafka(p) => p.flush(),
}
}
}
trait Writer {
fn write(&self, b: &Batch);
fn stop(&mut self);
}
impl Writer for Tarantool {
fn write(&self, b: &Batch) {
self.0.insert(b)
}
fn stop(&mut self) {
self.0.close()
}
}
impl Writer for Kafka {
fn write(&self, b: &Batch) {
self.0.send(b)
}
fn stop(&mut self) {
self.0.flush()
}
}
Второе: что будет, если добавить новый тип, например Picodata. С трейтом это новый impl, остальной код не меняется. С enum придётся пройти по каждому match:
enum Writer {
Tarantool(Conn),
Kafka(Producer),
Picodata(Client),
}
impl Writer {
fn write(&self, b: &Batch) {
match self {
Self::Tarantool(c) => c.insert(b),
Self::Kafka(p) => p.send(b),
Self::Picodata(c) => c.sql(b),
}
}
fn stop(&mut self) {
match self {
Self::Tarantool(c) => c.close(),
Self::Kafka(p) => p.flush(),
Self::Picodata(c) => c.close(),
}
}
}
trait Writer {
fn write(&self, b: &Batch);
fn stop(&mut self);
}
// impl для Tarantool и Kafka
// остаются как были
impl Writer for Picodata {
fn write(&self, b: &Batch) {
self.0.sql(b)
}
fn stop(&mut self) {
self.0.close()
}
}
Его вывод:
Выбор между
enumи трейт-объектами в объектно-ориентированном программировании на самом деле довольно прост: трейты упрощают добавление новых реализаций, аenumупрощают добавление новых методов интерфейса. Что выбрать, зависит от того, что, по-вашему, будет меняться чаще в итоговой программе.Если вы выбрали
enum, а позже понадобилось добавить вариант, придётся менять каждое сопоставление с образцом в коде. Если вы выбрали трейт, а позже понадобилось добавить метод, придётся просмотреть и, возможно, изменить каждую реализацию трейта в вашем коде, а если трейт публичный, то и в чужом. В обоих случаях вы будете страдать.HadrienG, users.rust-lang.org, 2017
Но у выбора есть и другие стороны, кроме цены изменений.
Во-первых, enum не прячет свои варианты. В том же треде пользователь withoutboats пишет, что любой, у кого есть значение enum, может разобрать его и добраться до конкретного варианта. Трейт-объект показывает наружу только методы трейта.
pub enum Writer {
Tarantool(Conn),
Kafka(Producer),
}
// в другом модуле
if let Writer::Kafka(p) = &w {
p.flush();
}
pub trait Writer {
fn write(&self, b: &Batch);
}
// в другом модуле
w.write(&batch);
Слева чужой код опирается на то, что в варианте Kafka лежит Producer, и сломается, если это поменять. Справа доступно только то, что объявлено в трейте.
Во-вторых, enum и трейт по-разному группируют код. Об этом пишет пользователь nivenkos на Reddit в 2020 году: он как раз переводил проект с enum на трейт-объекты. Если обобщить его наблюдение, трейты группируют код по реализациям, а enum по операциям. С трейтом всё про Kafka собрано в одном impl, зато операция stop разбросана по всем реализациям. С enum наоборот: stop целиком лежит в одной функции, а код Kafka разбросан по веткам всех match.
enum Writer {
Tarantool(Conn),
Kafka(Producer),
}
impl Writer {
fn write(&self, b: &Batch) {
match self {
Self::Tarantool(c) => c.insert(b),
Self::Kafka(p) => p.send(b),
}
}
fn stop(&mut self) {
match self {
Self::Tarantool(c) => c.close(),
Self::Kafka(p) => p.flush(),
}
}
}
trait Writer {
fn write(&self, b: &Batch);
fn stop(&mut self);
}
impl Writer for Tarantool {
fn write(&self, b: &Batch) {
self.0.insert(b)
}
fn stop(&mut self) {
self.0.close()
}
}
impl Writer for Kafka {
fn write(&self, b: &Batch) {
self.0.send(b)
}
fn stop(&mut self) {
self.0.flush()
}
}
В-третьих, самый неочевидный ответ дал пользователь sfackler. Автор треда боялся, что одно изменение заставит переписать сотни match, а sfackler ответил, что ради этого enum и берут:
enumберут тогда, когда хотят, чтобы вас заставили обработать новый вариант в каждом месте, где он используется.sfackler, users.rust-lang.org, 2017
Чуть выше в том же сообщении sfackler пишет, что трейт-объекты хороши, когда вызывающему коду всё равно, какая реализация перед ним. Если же решение принимает сам вызывающий код, нужен enum. Например, вызывающий код решает, можно ли подключить приёмник Kafka к источнику Picodata. Когда появится новый приёмник, компилятор заставит ответить на этот вопрос и для него, а с трейтом об этом легко забыть.
Если собрать всё вместе:
- HadrienG: смотрите, что будет расти, типы или операции.
enumупрощает новые операции, трейт упрощает новые типы. - sfackler:
enumберут, когда хотят, чтобы компилятор заставил обработать новый вариант в каждом месте. - nivenkos: трейт группирует код по реализациям,
enumпо операциям. - withoutboats:
enumможно разобрать снаружи, трейт показывает только свои методы.
Все эти ответы о таблице типов и операций, с которой мы начали: как добавлять в неё и строки, и столбцы. У этой задачи есть название, expression problem, и в литературе её обсуждают намного дольше, чем существует Rust.
Expression problem
В 2025 году на lobste.rs обсуждали статью «The expression problem and Rust», и один из ответов звучит так:
Да, expression problem становится проблемой только тогда, когда вы используете код библиотеки, но не можете его изменить. Если весь код лежит в вашей системе контроля версий, expression problem можно «решить» с помощью
enumс методами. Чтобы добавить данные, добавляете ещё один вариант вenumи обновляете методы. Чтобы добавить метод, просто добавляете метод. Если весь код ваш и править чужие библиотеки не нужно, нет и expression problem.justinpombrio, lobste.rs, 2025
Постановка задачи
Название придумал Филип Вадлер в 1998 году, в письме в рассылку о дженериках для Java:
Название Expression Problem новое, а сама задача старая. Цель в том, чтобы определить тип данных через варианты так, чтобы в него можно было добавлять новые варианты и новые функции над ним, не перекомпилируя существующий код и сохраняя статическую типобезопасность (например, без приведений типов).
Philip Wadler, The Expression Problem, 1998
Там же он описывает нашу таблицу: варианты типа это строки, функции это столбцы. В функциональном языке строки зафиксированы объявлением типа, а столбцы добавлять легко. В объектно-ориентированном наоборот: зафиксированы методы класса, а подклассы добавлять легко. Задача в том, чтобы легко добавлялось и то, и другое.
В Rust enum соответствует функциональному подходу, а трейт объектно-ориентированному. Rust Book пишет об enum так:
Это вполне хорошее решение, когда взаимозаменяемые элементы образуют фиксированный набор типов, известный на этапе компиляции. Однако иногда мы хотим, чтобы пользователь нашей библиотеки мог расширять набор типов, допустимых в конкретной ситуации.
Что из этого следует для Rust
Вадлер сформулировал задачу как тест для языков программирования: может ли система типов выразить такую расширяемость. Кроме самих строк и столбцов он поставил два условия: не перекомпилировать существующий код и сохранить статическую типобезопасность.
Первое условие: расширять таблицу, не трогая уже написанный код. Пока весь код ваш, это ничего не стоит: добавил вариант, поправил все match, пересобрал. Поэтому justinpombrio и говорит, что проблемы нет. Она появляется с чужими библиотеками. По enum serde_json::Value можно написать свою функцию с match, но нельзя добавить в него вариант. Трейт std::fmt::Display можно реализовать для своего типа, но нельзя добавить в него метод.
Второе условие: о пропущенной клетке должен сообщать компилятор. В Rust обычно так и есть: если match разбирает не все варианты, код не соберётся. Но если в match есть ветка _, которая ловит все остальные варианты, то новый вариант молча попадёт в неё, и компилятор ничего не скажет. Например, при разборе ошибок ввода-вывода по std::io::ErrorKind, перечислению видов ошибок из стандартной библиотеки:
match err.kind() {
ErrorKind::NotFound => create_file(),
ErrorKind::PermissionDenied => request_access(),
_ => return Err(err),
}
Поэтому Маттиас Ценгер и Мартин Одерски в работе 2005 года рассматривают только решения без таких веток: по их словам, ветки по умолчанию «превращают ошибки типов, которые проявились бы статически, в исключения во время выполнения».
Иногда без такой ветки не обойтись, и ErrorKind как раз такой случай. Операционные системы возвращают много видов ошибок, и стандартная библиотека со временем добавляет новые варианты. Но если в публичный enum добавить вариант, у всех пользователей перестанут собираться match, где разобраны все варианты без _. Стандартная библиотека обещает не ломать чужой код, поэтому ErrorKind помечен #[non_exhaustive]: атрибут означает, что вариантов может стать больше, и компилятор требует ветку _ в каждом match за пределами библиотеки. Раз эта ветка есть всегда, новый вариант ничего не ломает.
С точки зрения expression problem это компромисс. Автор ErrorKind может добавлять строки, не ломая чужой код, то есть выполняет первое условие Вадлера. Второе при этом нарушается, и о новом варианте компилятор пользователям не сообщит.
Решения
Есть решения, которые позволяют расширять таблицу в обе стороны, например шаблон «Посетитель» (Visitor) и решения на Scala у Ценгера и Одерски, другие есть в источниках. Все они заметно сложнее, чем match или impl. В статье, которую обсуждали на lobste.rs, такое решение собрано на Rust, и вывод там такой:
Так что, честно говоря, может быть, просто не стоит этого делать.
purplesyringa, The expression problem and Rust, 2025
Вывод
Честно говоря, мне не удалось сформулировать итоговое правило, но ясно одно.
Каждый раз, когда вы собираетесь абстрагировать поведение через трейт или enum-обёртку, стоит прикинуть, как выглядела бы альтернатива.
Источники
Обсуждения:
- Could enums be considered an anti-pattern?, users.rust-lang.org, 2017. Тред с ответами Клабника, HadrienG, sfackler и withoutboats.
- Enum or trait object, r/rust, 2020. Обсуждение статьи Possible Rust «Enum or Trait Object», где nivenkos пишет о группировке кода.
- The expression problem and Rust, lobste.rs, 2025. Обсуждение статьи purplesyringa.
Статьи и документация:
- purplesyringa, The expression problem and Rust, 2025. Попытка решить expression problem в Rust целиком и рассуждение о том, почему, возможно, этого не стоит делать.
- Andrew Lilley Brinker, Enum or Trait Object, Possible Rust, 2020. Короткое руководство: когда
enumиспользуется внутри библиотеки, а когда набор типов должны расширять её пользователи. - The Rust Programming Language, 18.2. Трейт-объекты и когда хватает
enum. - The Rust Reference:
non_exhaustive.
Литература:
- Philip Wadler, The Expression Problem, 1998. Письмо, в котором задача получила название.
- Matthias Zenger, Martin Odersky, Independently Extensible Solutions to the Expression Problem, 2005. Уточнённые требования и решения на Scala.
- William R. Cook, Object-Oriented Programming Versus Abstract Data Types, 1990. Та же таблица как матрица конструкторов и операций.
- Harold Abelson, Gerald Jay Sussman, Structure and Interpretation of Computer Programs, 2.4. Диспетчеризация по типу, программирование, управляемое данными, и передача сообщений; упражнение 2.76.
- Wouter Swierstra, Data types à la carte, 2008. Решение на Haskell.
- Oleg Kiselyov, Typed Tagless Final Interpreters. Подход finally tagless.
- Bruno C. d. S. Oliveira, William R. Cook, Extensibility for the Masses: Practical Extensibility with Object Algebras, 2012. Object algebras.