Краткий ответ

Метод с ограничением Self: Sized нельзя вызвать через trait object, например через &dyn Action или Box<dyn Action>. Такой метод исключается из интерфейса динамической диспетчеризации, но сам трейт при этом может оставаться совместимым с dyn и использоваться через trait object для остальных методов.

Для конкретного типа или обобщённого параметра T, который по умолчанию считается Sized, этот метод остаётся доступным. Ограничение Self: Sized служит способом явно отделить методы, требующие конкретного размера типа, от методов, которые должны вызываться динамически.

Исторический контекст

В Rust один трейт может использоваться двумя способами: через статическую диспетчеризацию для конкретного типа и через динамическую диспетчеризацию посредством trait object. Trait object хранит указатель на значение и таблицу виртуальных методов, поэтому в такую таблицу можно включить только методы с заранее определимым способом вызова.

Проблема возникает, когда трейт содержит метод, который нельзя корректно представить в vtable: например, метод возвращает Self, принимает обобщённый параметр или зависит от точного размера реализующего типа. Ограничение Self: Sized позволяет оставить такой метод в трейте, но исключить его из dyn-интерфейса.

Постановка проблемы

Предположим, библиотека предоставляет единый трейт для разных обработчиков. Часть API должна работать с неизвестным заранее типом через dyn Action, а вспомогательный метод должен создавать значение конкретного типа или возвращать сам Self.

Если оставить такой метод без ограничения, весь трейт может стать несовместимым с dyn. Если добавить Self: Sized, trait object сохранит возможность использовать безопасные методы, но вызов ограниченного метода через него станет невозможен. Это компромисс между универсальностью интерфейса и возможностью динамической диспетчеризации.

Подробное решение

Self: Sized означает, что конкретный тип, реализующий метод, должен иметь известный размер. Trait object, напротив, является динамически размещаемым типом: его конкретный размер неизвестен на этапе компиляции и обычно представляется широким указателем.

Минимальный пример:

trait Action {
    fn run(&self);

    fn into_name(self) -> String
    where
        Self: Sized;
}

fn use_dynamic(action: &dyn Action) {
    action.run();
    // action.into_name(); // ошибка: Self: Sized не выполнен
}

Метод run может попасть в vtable, поскольку вызывается через ссылку на trait object и не требует знания конкретного типа. Метод into_name туда не включается: его можно вызвать только там, где Self гарантированно является sized-типом, например для конкретного значения или обычного generic-параметра.

Важно отличать ограничение метода от ограничения самого трейта. Если объявить трейт как trait Action: Sized, то trait object для него вообще создать нельзя. Если же Self: Sized стоит только у отдельного метода, остальные методы трейта могут использоваться через dyn Action.

Ограничение не превращает метод в динамический: оно не добавляет его в vtable и не обеспечивает автоматический fallback. Вызов через Box<dyn Action> также не поможет, потому что после разыменования внутри всё равно находится trait object, а не известный конкретный тип.

Практическое следствие для API: методы, предназначенные для trait object, обычно принимают ссылки или другие dyn-совместимые формы и не требуют знания Self. Методы преобразования в конкретный тип, конструкторы и методы с возвращаемым Self можно пометить Self: Sized, если они нужны только при статической диспетчеризации.

Ситуация из практики

В системе плагинов обработчики хранятся в коллекции как Box<dyn Action>. Основной метод run должен вызываться для любого плагина во время выполнения, а метод into_name используется только при статически известном типе плагина для построения диагностической информации.

Рассматривались два варианта. Первый — разделить API на два трейта: один сделать полностью dyn-совместимым, а второй оставить для статических операций. Это наиболее явно выражает границы возможностей, но увеличивает число трейтов и иногда требует дополнительных bound.

Второй — оставить оба метода в одном трейте и ограничить статический метод через Self: Sized. Этот вариант выбран, если операции логически относятся к одному контракту, а динамическим пользователям нужна только его основная часть. В результате плагины можно хранить и запускать через dyn Action, а статические вызовы сохраняют полную функциональность без искусственного ограничения всего трейта.

Что кандидаты часто упускают

1. Можно ли вызвать такой метод через Box<dyn Action>, если сам объект владеющий?

Нет. Владение объектом не делает его конкретным sized-типом. Тип Box<dyn Action> имеет известный размер, но вызываемый через него метод получает значение, динамический тип которого остаётся неизвестным; условие Self: Sized относится к реализующему типу, а не к оболочке Box.

2. Что изменится, если написать Self: Sized у самого трейта, а не у метода?

Трейт перестанет быть пригодным для trait object: dyn Action создать нельзя. Ограничение на уровне трейта требует, чтобы любой реализующий тип был sized, тогда как trait object специально допускает неизвестный размер конкретной реализации. Ограничение только на метод гораздо менее жёсткое и сохраняет dyn-доступность остальных методов.

3. Почему метод, возвращающий Self, часто требует Self: Sized при использовании через dyn?

У trait object нет одного заранее известного конкретного типа, который можно было бы указать как размер и форму возвращаемого значения. Поэтому метод, возвращающий Self, обычно несовместим с динамической диспетчеризацией. Добавление Self: Sized исключает метод из dyn-интерфейса и позволяет использовать его при статической диспетчеризации, где конкретный тип Self известен компилятору.