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

Ограничение associated type == Self требует, чтобы соответствующий тип был ровно тем же конкретным типом, который реализует протокол. Соответствие типа с другим, даже тесно связанным, типом становится недопустимым.

Это не просто ограничение возможностей generic-кода: оно сужает множество возможных реализаций протокола и фиксирует связь associated type с реализующим типом.

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

Associated types появились как способ описывать тип, который выбирается каждой реализацией протокола отдельно. Протокол может задавать операции над таким типом, не превращая сам протокол в generic-шаблон с параметром, который должен указываться при каждом использовании.

Равенство с Self нужно, когда associated type не должен быть независимым: он обязан совпадать с типом конкретного conforming-типа. Это позволяет выразить рекурсивные или самоссылочные модели без ручного дублирования требований.

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

Без равенства с Self каждая реализация могла бы выбрать любой тип, удовлетворяющий остальным ограничениям associated type. Например, контейнер мог бы сообщить, что его элементом является другой тип, а generic-код не смог бы считать контейнер и его элемент одним и тем же типом.

Если такая идентичность важна, отсутствие ограничения приводит к более слабым гарантиям: приходится добавлять дополнительные same-type constraints в каждой generic-функции. Если же ограничение объявлено в самом протоколе, компилятор проверяет его при каждом соответствии.

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

В условии A == Self значение A подставляется как конкретный тип conforming-типа. Для структуры Document это означает A == Document, а не просто A: SomeProtocol.

protocol SelfDescribing {
    associatedtype Description where Description == Self
    static func makeDescription() -> Description
}

struct Document: SelfDescribing {
    static func makeDescription() -> Document {
        Document()
    }
}

В этом примере Document обязан использовать Document как Description. Реализация с Description == String не удовлетворила бы протоколу, даже если String имел бы все необходимые операции.

Главное практическое следствие — generic-код, получивший T: SelfDescribing, может использовать равенство T.Description == T как уже доказанный факт. Дополнительное ограничение в generic-сигнатуре для этого не требуется.

Такое ограничение уменьшает гибкость API. Нельзя использовать один тип как реализацию протокола с несколькими разными связанными типами, если они должны отличаться от Self. Поэтому его следует применять только тогда, когда идентичность действительно является инвариантом модели.

Нужно отличать это от обычного ограничения вида A: SomeProtocol: в последнем случае A может быть любым конкретным типом, соответствующим SomeProtocol, а при A == Self множество вариантов сводится к одному типу — текущему conforming-типу.

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

В библиотеке описывается объект, который умеет создавать свою копию через associated type. Рассматривались два варианта: оставить associated type независимым или связать его с Self.

Независимый associated type был бы полезен, если объект может создавать результат другого типа, например модель преобразуется в DTO. Но тогда generic-коду нужно отдельно доказывать связь между исходным и результирующим типами.

Для операции, которая по смыслу всегда возвращает объект того же типа, выбран вариант с равенством associated type == Self. Это исключает ошибочные реализации, упрощает generic-ограничения и делает контракт очевидным. Цена решения — невозможность использовать тот же протокол для преобразований в другой тип.

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

1. Делает ли такое равенство associated type просто псевдонимом Self во всех контекстах?

Нет. Это ограничение протокола, а не переименование Self. Associated type остаётся частью контракта и может использоваться в требованиях протокола, но компилятор знает, что для каждой конкретной реализации он равен Self.

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

2. Достаточно ли того, что выбранный associated type соответствует тому же протоколу, что и Self?

Нет. Соответствие одному протоколу не означает равенство типов. Тип Other может реализовать те же требования, что и Self, но всё равно не удовлетворять условию Associated == Self.

Same-type constraint проверяет идентичность типов, а не их взаимозаменяемость по набору протокольных требований. Это более сильная гарантия и одновременно более жёсткое ограничение для реализации.

3. Что изменится, если равенство с Self убрать из протокола и добавить только в extension?

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

Такой вариант подходит для специализированного API, но не для инварианта, который обязаны соблюдать все conforming-типы. Если равенство необходимо самому контракту, его следует объявлять в требованиях протокола, а не прятать в extension.