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

Swift выполняет optional injection: значение типа String автоматически поднимается до String? и становится присутствующим значением Optional. Обратное преобразование не выполняется автоматически: String? нельзя передать туда, где требуется гарантированный String, пока Optional явно не извлечён.

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

Optionals введены для явного представления отсутствующего значения в системе типов. Такой подход заменяет неявные null-значения, которые могут привести к ошибке далеко от места их возникновения, на тип, требующий обработки двух состояний: значение присутствует или отсутствует.

Автоматическое добавление уровня Optional сделано удобным для API: функция может объявить, что отсутствие значения допустимо, не заставляя каждый вызов вручную оборачивать обычные значения.

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

Параметр String? допускает два состояния, поэтому обычная строка безопасно соответствует этому контракту. Но параметр String обещает вызываемому коду, что строки точно существует; передача туда String? нарушила бы это обещание.

Неверное ожидание автоматического извлечения приводит либо к ошибке компиляции, либо к опасному принудительному извлечению. Если Optional равен nil, принудительное извлечение завершит выполнение аварийно во время работы программы.

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

При передаче String в String? Swift применяет promotion: создаётся Optional в состоянии .some(строка). Это не означает, что исходная строка стала изменяемой ссылкой или что произошло копирование объекта; меняется тип представления значения, добавляя информацию о возможном отсутствии.

func show(_ value: String?) {
    print(value ?? "нет значения")
}

let text = "Swift"
show(text)       // Swift

let optional: String? = "Swift"
// showRequired(optional) // ошибка: Optional<String> не является String

Для обратного перехода нужно явно выбрать стратегию обработки: if let, guard let, оператор ??, optional chaining или, только при доказанной гарантии, принудительное извлечение !. Компилятор не выбирает стратегию за разработчика, потому что каждая из них по-разному обрабатывает nil.

Важная деталь — optional injection может добавлять уровень Optional в контексте ожидаемого типа. Это не равно извлечению и не гарантирует, что произвольное значение Optional будет автоматически распаковано перед вызовом функции.

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

В слое аналитики функция принимает необязательный идентификатор пользователя, поскольку событие может быть анонимным. Передача обычного идентификатора удобна: он автоматически становится String?, а отсутствие идентификатора передаётся как nil.

Можно было бы объявить две перегрузки — одну для String, другую для String?. Это усложняет разрешение перегрузок и поддержку API. Можно было бы требовать от каждого вызывающего кода ручного оборачивания строки, но это добавляет шум без дополнительной проверки.

Поэтому выбирают один параметр String?: обычные строки принимаются через optional injection, а Optional-значения обрабатываются внутри функции явно. В результате контракт API остаётся честным, а риск аварийного извлечения сосредоточен в одном месте.

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

Создаёт ли optional injection отдельный объект или гарантирует ли выделение памяти?

Нет. Optional — это значение типа, которое концептуально содержит состояние .some или .none и, в состоянии .some, полезное значение. Детали физического представления и оптимизации зависят от типа и реализации; полагаться на обязательное выделение отдельного объекта нельзя.

Для value-типа String это не превращает строку в ссылочный объект. Для ссылочного типа Optional содержит ссылку в состоянии .some, но сам механизм добавления Optional не меняет value/reference semantics исходного объекта.
Почему Swift не извлекает String? автоматически при передаче в параметр String?

Потому что извлечение может завершиться отсутствием значения. Автоматический выбор поведения при nil был бы неоднозначным: вернуть значение по умолчанию, пропустить вызов, выбросить ошибку или аварийно завершить программу.

Явное извлечение заставляет разработчика выбрать нужную семантику. Например, ?? задаёт значение по умолчанию, а guard let позволяет завершить текущую ветку с контролируемым выходом.
Что меняется при передаче уже существующего String? в параметр String???

В контексте, где ожидается String??, существующий String? может быть помещён внутрь ещё одного Optional. Внешний уровень тогда описывает наличие самого внутреннего Optional, а внутренний — наличие строки.

Поэтому возможны разные состояния: внешний Optional отсутствует, внешний присутствует, но внутренний равен nil, либо оба уровня присутствуют и содержат строку. Это не обычное извлечение, а добавление уровня вложенности; различать такие состояния нужно только если API действительно придаёт им разный смысл.