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

Вызов допустим, потому что init(copying: Self) объявлен обязательным требованием протокола. Ограничение T: Copyable гарантирует, что у метатипа T существует этот инициализатор, а Self связывается именно с конкретным типом T.

Generic-коду не нужно знать структуру T: он использует только контракт протокола. Любой тип, соответствующий Copyable, обязан предоставить совместимый инициализатор.

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

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

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

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

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

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

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

В объявлении init(copying: Self) Self означает конкретный тип, который реализует протокол. Когда T соответствует Copyable, требование специализируется как init(copying: T) -> T.

Поэтому выражение T(copying: value) корректно: T используется как метатип, то есть как значение, через которое вызывается инициализатор. Ограничение T: Copyable предоставляет компилятору доказательство существования этого инициализатора.

protocol Copyable {
    init(copying: Self)
}

struct Note: Copyable {
    let value: Int

    init(copying other: Note) {
        value = other.value
    }
}

func clone<T: Copyable>(_ value: T) -> T {
    T(copying: value)
}

let copy = clone(Note(value: 7))

Инициализатор в протоколе является обязательным требованием соответствия. Реализация Note.init(copying:) принимает именно Note, что соответствует Self после подстановки конкретного типа.

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

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

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

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

Можно было бы написать отдельную generic-функцию с замыканием-фабрикой. Такой вариант гибок, но требует передавать конструктор при каждом вызове и не гарантирует единый контракт копирования.

Можно было бы использовать конкретный базовый класс. Это обеспечило бы общий инициализатор, но ограничило бы модели наследованием и не подошло бы структурам.

Выбранный вариант — протокол с init(copying: Self). Он сохраняет типобезопасность, работает со структурами и классами и позволяет generic-коду вызвать конструктор без знания конкретного типа. Цена решения — каждый соответствующий тип обязан явно определить согласованную семантику копирования.

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

Почему здесь нельзя заменить Self на any Copyable?

Self сохраняет точный тип аргумента и результата. Если бы инициализатор принимал existential any Copyable, контракт описывал бы передачу произвольного значения протокола, а не обязательно значения того же конкретного типа. Это ослабило бы связь, которую использует clone.
Обязан ли каждый соответствующий тип объявлять инициализатор вручную?

Нет, если компилятор может синтезировать требуемый инициализатор или если он предоставлен допустимой реализацией по умолчанию. Но соответствие всё равно невозможно без доступного инициализатора, удовлетворяющего точной сигнатуре требования.
Можно ли вызвать этот инициализатор через значение типа any Copyable?

Не всегда. Existential скрывает конкретный тип, а требования, использующие Self, могут зависеть от этого скрытого типа. В generic-коде T является одним зафиксированным конкретным типом, поэтому связь Self == T известна; у обычного existential такая связь не выражена напрямую.