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

T описывает обычное значение или экземпляр типа, а T.Type — значение, представляющее сам тип T. Поэтому экземпляр T можно привести к T, но он не является метатипом T.Type; метатипом будет, например, значение T.self.

Условительное приведение к T.Type проверяет, что исходное значение уже содержит метатип, а не экземпляр. Оно не извлекает тип экземпляра и не превращает объект в значение метатипа.

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

Статическая типизация требует различать данные и описание их типа. В прикладном коде обычно работают с экземплярами, но фабрики, реестры типов, сериализаторы и механизмы отражения иногда должны передавать сам тип как значение.

Для этого Swift предоставляет метатипы. Они позволяют сохранить ссылку на тип, сравнивать типы, вызывать статические операции или передавать тип в обобщённые механизмы, не создавая экземпляр заранее.

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

Если смешать T и T.Type, можно ошибочно ожидать, что приведение экземпляра к метатипу определит его фактический тип. В результате условие приведения будет ложным, хотя объект действительно имеет тип T.

Обратная ошибка тоже опасна: значение T.self не является экземпляром T. У него нет свойств и методов экземпляра, потому что оно представляет описание типа, а не объект этого типа.

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

T — это тип экземпляров. Например, объект, созданный из класса Cat, имеет тип Cat или совместимый с ним тип-экзистенциал.

T.Type — метатип. Выражение Cat.self имеет тип Cat.Type и содержит значение, представляющее тип Cat. Аналогично, type(of: object) возвращает метатип динамического типа объекта.

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

final class Cat {}

let instance: Any = Cat()
let metatype: Any = Cat.self

print(instance is Cat)       // true
print(instance is Cat.Type)  // false
print(metatype is Cat.Type)  // true

В первой проверке Swift проверяет экземпляр Cat. Во второй исходное значение содержит объект, а не метатип, поэтому проверка завершается неуспешно. В третьей проверяется значение Cat.self, которое действительно является метатипом Cat.Type.

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

Важно отличать T.Type от Any.Type. Any.Type может описывать метатип любого Swift-типа: структуры, класса, перечисления или протокола. Это не означает, что значение является экземпляром типа Any; речь идёт именно о типе, описывающем другие типы.

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

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

Можно хранить метатипы T.Type. Плюс такого подхода — тип передаётся явно, а создание можно отложить. Минус — одного метатипа недостаточно, если для конструктора нужны параметры или если типы не имеют общего безопасного интерфейса создания.

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

Если компоненты имеют общий протокол и стандартный способ создания, разумно хранить метатипы, ограниченные этим протоколом, либо фабрики с тем же ограничением. Так сохраняется проверка типов на этапе компиляции и исключается ошибочная попытка привести экземпляр к T.Type.

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

1. Что возвращает type(of:) для объекта, объявленного через базовый тип?

type(of:) возвращает метатип динамического типа объекта, а не статического типа переменной. Если переменная имеет статический тип Animal, но содержит экземпляр Cat, результат будет метатипом динамического типа Cat.

Это отличается от Animal.self: первое значение определяется фактическим объектом во время выполнения, второе безусловно представляет тип Animal.

2. Создаёт ли Cat.self экземпляр класса Cat?

Нет. Cat.self создаёт или возвращает значение метатипа Cat.Type, но не вызывает инициализатор и не выделяет объект Cat.

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

3. Почему Any.Type нельзя трактовать как конкретный T.Type без проверки?

Any.Type допускает метатип любого типа, поэтому компилятор не знает, что внутри находится именно T.Type. Перед использованием конкретного типа требуется условительное или иное обоснованное приведение.

Успешное приведение означает, что значение действительно представляет нужный метатип. Оно не меняет исходный тип экземпляра и не создаёт новый объект; меняется только статический способ обращения к уже существующему значению метатипа.