RUEN

← на главную

Выбор между 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);

Заметьте:

При этом есть и отличия:

В общем виде: есть набор типов и набор операций над ними. Код должен выполнить каждую операцию для каждого типа, то есть заполнить таблицу, где по строкам типы, а по столбцам операции.

операция f операция g новая операция
тип A есть есть ?
тип B есть есть ?
новый тип ? ? ?

Отсюда вопрос:

Как выбрать между enum и трейтом, если со временем добавляются и новые типы, и новые операции над ними?

Сначала посмотрим, что об этом говорят на форумах, а потом сверим эти мнения с классической литературой.

Народная мудрость

По форумам удобно сориентироваться в теме и найти более авторитетные источники.

В 2017 году на users.rust-lang.org спросили, не вредны ли enum вообще. Известный евангелист Rust Стив Клабник ответил так:

enum нужны для закрытых множеств, а трейт-объекты для открытых. То есть если вы знаете все варианты, берите enum. Если нет, берите трейт-объект.

Steve Klabnik, users.rust-lang.org, 2017

Правило простое, но вызывает вопросы: оно смотрит только на то, закрыт ли набор вариантов, и ничего не говорит о наборе операций. В простых случаях оно работает:

  1. У Result<T, E> и Option<T> ровно два варианта по определению, и других не появится, поэтому это enum.
  2. 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. Когда появится новый приёмник, компилятор заставит ответить на этот вопрос и для него, а с трейтом об этом легко забыть.

Если собрать всё вместе:

Все эти ответы о таблице типов и операций, с которой мы начали: как добавлять в неё и строки, и столбцы. У этой задачи есть название, 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 так:

Это вполне хорошее решение, когда взаимозаменяемые элементы образуют фиксированный набор типов, известный на этапе компиляции. Однако иногда мы хотим, чтобы пользователь нашей библиотеки мог расширять набор типов, допустимых в конкретной ситуации.

The Rust Programming Language, 18.2

Что из этого следует для 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-обёртку, стоит прикинуть, как выглядела бы альтернатива.

Источники

Обсуждения:

Статьи и документация:

Литература: