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

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

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

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

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

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

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

Слишком слабое ограничение не позволяет вызвать нужные операции: компилятор видит только гарантированный контракт. Слишком сильное ограничение конкретным типом уменьшает повторное использование функции и может скрыть ошибку проектирования протокола.

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

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

При ограничении параметра протоколом компилятор гарантирует наличие только требований этого протокола. Члены, объявленные в неограниченном расширении протокола, также могут быть доступны, но члены ограниченного расширения требуют выполнения соответствующего дополнительного условия.

При равенстве параметра конкретному типу компилятор знает точную реализацию. Поэтому можно использовать специфичные члены типа, но вызов становится допустимым только для этого типа; другой тип, даже соответствующий тому же протоколу, не подойдёт.

protocol Describable {
    var title: String { get }
}

struct Note: Describable {
    let title: String
    let priority: Int
}

func titleOf<T: Describable>(_ value: T) -> String {
    value.title
}

func priorityOf<T>(_ value: T) -> Int where T == Note {
    value.priority
}

let a = titleOf(Note(title: "Task", priority: 1))
let b = priorityOf(Note(title: "Task", priority: 1))

Функция titleOf принимает любой тип, соответствующий Describable, и не знает о priority. Функция priorityOf формально остаётся generic, но ограничение T == Note делает её применимой только к Note и открывает доступ к его свойству priority.

На практике сначала следует искать общий протокол. Переход к конкретному типу оправдан, если алгоритм действительно использует уникальные детали этого типа или если требуется намеренно ограничить API. Иначе такое ограничение создаёт лишнюю связанность и затрудняет тестирование и повторное использование.

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

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

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

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

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

Делает ли ограничение протоколом все методы конкретного типа доступными внутри generic-функции?

Нет. Компилятор проверяет тело функции для любого допустимого типа, поэтому он разрешает только операции, гарантированные ограничением. Даже если в конкретном вызове передан тип с дополнительным методом, generic-функция не может обращаться к нему без дополнительного ограничения.

Почему ограничение конкретным типом может быть хуже перегрузки?

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

Можно ли заменить ограничение конкретным типом новым протоколом?

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