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

По умолчанию каждый параметр типа в Rust неявно ограничен трейтом Sized: компилятор предполагает, что значение этого типа имеет размер, известный во время компиляции. Ограничение ?Sized снимает именно это неявное требование и позволяет подставлять типы, размер которых неизвестен заранее, например str или dyn Trait.

Сама ссылка остаётся типом известного размера: &T имеет фиксированное представление, даже если T является динамически размерным. Поэтому ?Sized обычно требуется параметру T, а не ссылке на него.

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

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

Однако некоторые типы по своей природе не имеют размера, известного на этапе компиляции. К ним относятся срезы вроде str и dyn Trait. Такие значения нельзя хранить непосредственно как обычное локальное значение, но их можно использовать через указатель с метаданными, например &str, Box<dyn Trait> или &dyn Trait.

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

Рассмотрим обобщённую функцию, которая принимает ссылку на значение. Если написать её параметр типа без дополнительных ограничений, Rust потребует T: Sized. Это исключит вызовы для str и dyn Trait, хотя сама ссылка на такое значение полностью допустима.

Неверное понимание приводит либо к неожиданным ошибкам компиляции, либо к избыточному ограничению API. Простое добавление ?Sized не делает любое использование типа безопасным: значение динамически размерного типа по-прежнему нельзя передавать и возвращать по значению.

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

Запись T: ?Sized означает: «для T не требовать неявный bound Sized». Это не означает, что T обязательно динамически размерный; конкретным T всё ещё может оказаться обычный тип, например String.

Без ?Sized функция фактически имеет ограничение T: Sized:

fn borrow<T: ?Sized>(value: &T) -> &T {
    value
}

fn main() {
    let text: &str = "Rust";
    let view = borrow(text);
    let owned = String::from("Rust");
    let _ = borrow(&owned);
}

В вызове borrow(text) параметр T выводится как str. Тип str не реализует Sized, но аргумент &str имеет фиксированный размер и потому может быть передан функции. В вызове с String T — обычный размерный тип; тот же API поддерживает оба случая.

Указатель на DST обычно содержит адрес и метаданные. Для &str метаданные — длина среза, для &dyn Trait — информация, необходимая для динамической диспетчеризации. Сам T может быть не Sized, но &T остаётся размерным типом.

Ограничение ?Sized нельзя произвольно применять к любому трейту: в обычном Rust оно предназначено для снятия неявного ограничения Sized. Кроме того, функция fn take<T: ?Sized>(value: T) не сможет принимать str по значению, потому что размер такого параметра неизвестен; для него нужен указатель или другой косвенный контейнер.

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

В библиотеке создают вспомогательную функцию, возвращающую ту же ссылку, которую она получила. Изначально параметр объявляют как T, после чего пользователи не могут передать ссылку на строковый срез str или на объект трейта.

Вариант с ограничением T: Sized проще для компилятора, но неоправданно сужает API. Вариант с отдельными функциями для String, str и каждого конкретного трейта устраняет ошибку, но дублирует код и плохо масштабируется.

Выбранный вариант — T: ?Sized при аргументе &T. Он сохраняет единый обобщённый API, не требует размещать DST по значению и позволяет компилятору корректно работать с метаданными ссылок. При этом ограничения, требующие конкретного размера, оставляют на уровне отдельных операций.

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

Вопрос: Делает ли ?Sized сам параметр типа динамически размерным?

Ответ: Нет. ?Sized только разрешает подставить размерный или динамически размерный тип. Если вызывающий передаст String, параметром останется String; если передаст str через ссылку, параметром будет str.
Вопрос: Почему &T может быть допустимым, когда T не реализует Sized?

Ответ: Размер ссылки определяется не размером объекта, а её собственным представлением. Для обычной ссылки это адрес, а для ссылки на DST — адрес вместе с метаданными. Поэтому &str и &dyn Trait имеют известный размер, хотя объекты, на которые они указывают, могут иметь размер, определяемый только во время выполнения.
Вопрос: Всегда ли нужно писать ?Sized для функции, принимающей ссылку на тип?

Ответ: Нет, только если функция должна принимать ссылки на динамически размерные типы. Если API намеренно работает лишь с размерными типами или внутри функции нужны операции, требующие Sized, неявного ограничения достаточно. ?Sized расширяет применимость обобщения, но иногда усложняет дальнейшие ограничения и не позволяет использовать T там, где требуется значение фиксированного размера.