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

Оператор === сравнивает идентичность экземпляров классов, а Optional сам является перечислением-обёрткой, то есть value type. Поэтому два значения T? нельзя сравнить через === напрямую: сначала нужно обработать nil и извлечь ссылки на объекты.

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

В Swift разделены два вида сравнения: равенство значений через == и идентичность объектов через ===. Это позволяет структурам и перечислениям сравниваться по содержимому, а экземплярам классов — по принадлежности к одному объекту в памяти.

Optional появился как типобезопасная замена неявным указателям и представляет два состояния: наличие значения и его отсутствие. Даже если внутри находится ссылка на класс, внешним типом остаётся Optional, а не сам класс.

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

Рассмотрим две переменные типа User?. Они могут содержать ссылки на один объект, ссылки на разные объекты с одинаковым состоянием или nil. Эти ситуации нельзя корректно различить одним универсальным сравнением.

Попытка применить === к самим Optional приводит к ошибке типов: оператор ожидает class-bound операнды, а получает значения перечислимого типа Optional. Автоматическое извлечение Optional для оператора идентичности Swift не выполняет.

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

Нужно сначала определить состояние Optional, затем сравнить извлечённые ссылки. Если оба значения содержат объект, применяется ===; если оба равны nil, это означает отсутствие объектов, а не идентичность экземпляров.

final class User {
    let id: Int
    init(id: Int) { self.id = id }
}

let user = User(id: 1)
let first: User? = user
let second: User? = user

if let first, let second {
    print(first === second) // true
}

=== не вызывает == и не сравнивает свойства объектов. Для двух разных экземпляров с одинаковыми данными результат будет false; для двух ссылок на один экземпляр — true.

Если требуется сравнить именно состояние пользователей, класс должен поддерживать Equatable, после чего используется ==. Это другая семантика: равенство может быть истинным для разных экземпляров.

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

В кэше хранят Optional-ссылку на загруженный объект. Нужно понять, является ли новый объект тем же экземпляром, который уже используется экраном.

Вариант с == подходит только при наличии корректной бизнес-семантики равенства и может считать одинаковыми два независимых объекта. Принудительное извлечение через ! опасно: при nil приложение аварийно завершится.

Выбранное решение — безопасно сопоставить оба Optional с some, извлечь ссылки и применить ===. Если оба значения nil, обрабатывать это отдельно как отсутствие объекта. Такой подход явно разделяет отсутствие значения, идентичность экземпляра и равенство состояния.

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

Можно ли сравнить два Optional ссылочного типа через == без Equatable у класса?

Нет, если сам класс не удовлетворяет требованиям для такого сравнения. Optional получает возможность сравнения через == при условии, что его Wrapped поддерживает Equatable. Наличие ссылочного типа само по себе не делает сравнение состояний доступным.
Будет ли === истинным для двух разных объектов с одинаковыми свойствами?

Нет. === проверяет, указывают ли ссылки на один и тот же экземпляр. Совпадение значений свойств не имеет значения; для сравнения содержимого используется == с явно определёнными правилами равенства.
Что означает ситуация, когда оба Optional равны nil при проверке идентичности?

Она означает, что оба значения не содержат объекта. nil не является экземпляром класса, поэтому корректнее обрабатывать этот случай отдельной веткой, а не трактовать его как результат сравнения идентичности двух объектов.