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

Да. При записи ссылки вида &'a T Rust подразумевает ограничение T: 'a: тип T должен быть пригоден для использования в течение всего времени жизни 'a. Однако это не означает, что конкретное значение T принудительно живёт 'a; ограничение относится к содержащимся в типе ссылкам и другим заимствованным данным.

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

Время жизни в Rust нужно проверять на уровне типов, чтобы безопасно работать не только с прямыми ссылками, но и с составными типами, которые могут содержать вложенные заимствования. Без связи T: 'a обобщённая ссылка могла бы указывать на значение, внутри которого есть ссылка, уже ставшая недействительной.

Поэтому Rust использует неявные ограничения времени жизни. Если тип ссылки сам требует, чтобы T был действителен не короче 'a, это требование выводится из корректности типа ссылки, а не обязательно записывается разработчиком явно.

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

Рассмотрим ссылку &'a T. Внешняя ссылка должна оставаться корректной в течение 'a, но T может быть не простым владеющим типом. Например, T способен быть структурой или кортежем, содержащим ссылки на другие данные.

Если внутренние ссылки в T живут меньше 'a, то после их завершения значение типа T нельзя безопасно рассматривать через &'a T. Риск возникает даже тогда, когда сам объект T физически продолжает существовать.

Важно различать два утверждения:

T: 'a означает, что все заимствованные данные внутри T живут не меньше 'a;
это не означает, что экземпляр значения T будет автоматически храниться или использоваться 'a.

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

Для ссылки &'a T компилятор проверяет не только срок действия самой ссылки, но и пригодность типа T для этого срока. В обобщённой функции ограничение T: 'a часто можно не писать явно, потому что оно следует из параметра &'a T.

fn require<'a, T: 'a>(_: &'a T) {}

fn inferred<'a, T>(value: &'a T) {
    require(value);
}

Функция inferred корректна: из параметра value: &'a T Rust выводит необходимое условие T: 'a. Явная запись ограничения в inferred обычно не требуется.

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

Ограничение не продлевает никакие данные. Если внутренняя ссылка в T недостаточно долговечна, компилятор отклонит использование &'a T; аннотация времени жизни не превращает короткое заимствование в длинное.

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

Представим обобщённый API, который временно читает значение через ссылку и допускает типы с внутренними заимствованиями. Один вариант — явно записать T: 'a во всех связанных сигнатурах. Это делает контракт заметнее, но увеличивает шум и может дублировать ограничение, уже выведенное из &'a T.

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

Практически выбирают второй вариант, если условие действительно выводится из &'a T. Явное T: 'a добавляют, когда оно является самостоятельной частью контракта — например, когда T используется в другом поле, связанном с 'a, или когда явная запись улучшает читаемость сложной сигнатуры. Результат в обоих случаях одинаков: компилятор не допускает внутренние заимствования в T, которые короче 'a.

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

Означает ли T: 'a, что объект типа T должен быть уничтожен после 'a?

Нет. Ограничение относится к корректности типа относительно заимствованных данных, а не к времени хранения значения. Владеющий T может существовать дольше 'a; после окончания 'a просто прекращается конкретное использование ссылки, связанной с этим сроком.
Продлевает ли T: 'a срок жизни ссылок, находящихся внутри T?

Нет. Это проверочное условие, а не операция продления времени жизни. Если внутри T находится ссылка с более коротким сроком, значение нельзя использовать там, где требуется T: 'a; компилятор отклонит такую передачу.
Почему для String ограничение String: 'a обычно не вызывает практических затруднений?

Потому что String владеет буфером и не содержит параметра времени жизни, от которого зависела бы его типовая корректность. Ограничение означает, что сам тип пригоден для такого контекста, но не требует удерживать отдельную внешнюю строку. Для типа, содержащего ссылку, например структуры с полем &'b str, проверка уже учитывает связь между 'b и 'a.