Программирование Swift

При обращении к статическому требованию протокола через generic-параметр, откуда берётся конкретная реализация?

Объясните различие между existential-протоколом с зафиксированным primary associated type и generic-параметром с тем же ограничением: что сохраняется статически?

Практическая ситуация: если обобщённый контейнер условно соответствует протоколу при соответствии его элемента, при каких условиях вложенный такой же контейнер тоже получает это соответствие?

В коде обобщённая функция принимает неизвестный конкретный тип. За счёт какого требования протокола вызов T(copying: value) допустим?

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)
}

К чему приводит добавление в extension соответствия типа из чужой библиотеки протоколу, которым владеет текущий модуль?

При передаче значения any-протокола в generic-функцию каким образом Swift связывает его скрытый конкретный тип с generic-параметром?

Через existential-значение протокола вызывается реализация метода из расширения или одноимённый метод конкретного типа, если этот метод не объявлен требованием протокола?

Ситуация: тип объявляет соответствие протоколу только в extension. Почему generic-функция всё равно принимает его как параметр с ограничением этим протоколом?

Что даёт объявление primary associated type при использовании протокола как existential-типа?

Почему новое обязательное требование нельзя добавить в extension уже объявленного протокола?

В generic-функции параметр ограничен составным протоколом: можно ли считать associated types из этих протоколов одним и тем же типом без явного ограничения равенства?

Из-за чего метод в ограниченном расширении generic-типа недоступен в коде, где соответствующее ограничение не доказано?

В коде допущена ошибка. Объясните её причину и покажите корректное место для объявления наследования протоколов.

protocol Readable { }
protocol Storable { }

extension Readable: Storable { }

В ситуации, когда generic-параметр должен быть экземпляром конкретного базового класса и соответствовать протоколу, как Swift применяет такое комбинированное ограничение?

Представьте generic-функцию, принимающую тип, который должен соответствовать двум протоколам одновременно. Какой доступ к требованиям этих протоколов получает её параметр?

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

Сравните any P.Type и (any P).Type: какой из этих типов представляет метатип конкретного типа, соответствующего протоколу, а какой — метатип самого existential-типа?

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

Как классовое ограничение протокола меняет допустимые типы и возможности generic-кода?

Как Swift выбирает реализацию требования протокола, если в его расширении есть default implementation, а соответствующий тип объявляет собственную?