Optionals и система типов

Если одно замыкание присвоить двум переменным, создаёт ли это независимые копии захваченного изменяемого состояния?

После уничтожения объекта обращение к unowned-ссылке завершается чем и почему?

Предскажите результат и объясните, как is учитывает Optional в этом коде:

let value: Int? = 42

print(value is Int)
print(value is Int?)

В тернарном выражении одна ветка возвращает String, а другая — nil: какой тип получает результат и почему?

Как правило эксклюзивного доступа Swift влияет на одновременное чтение и изменение одной переменной?

Объясните механизм: почему Swift разрешает передать массив Int как массив Any, но обратное приведение не считается безопасным?

Представьте вызов перегруженной функции с аргументом типа Any: определяется ли перегрузка по фактическому типу объекта?

При сопоставлении кортежа в Swift что определяет успешность pattern matching?

Почему при приведении значения Any, содержащего типизированный nil, к Optional<Int> результат может иметь внешний some и внутренний nil?

Объясните механизм представления Optional в Swift: какие состояния он моделирует и почему вложенные Optional не следует считать одним и тем же состоянием отсутствия?

Что происходит с конкретным типом при передаче значения any Protocol в обобщённую функцию?

Сравните динамический тип объекта и тип переменной: что напечатает код и почему type(of:) даёт такой результат?

class Animal {}
final class Cat: Animal {}

let animal: Animal = Cat()
print(type(of: animal) == Cat.self)
print(type(of: animal) == Animal.self)

Объясните механизм: почему функцию, принимающую String, нельзя безопасно передать туда, где ожидается функция, принимающая String??

Допустимо ли присвоить Optional подкласса переменной Optional базового класса, и каким механизмом Swift это обеспечивает?

Рассмотрите ситуацию: определите, какой текст напечатает код и почему выполнение продолжится после первого совпавшего case.

let code = 1

switch code {
case 1:
    print("один")
    fallthrough
case 2:
    print("два")
default:
    print("другое")
}

Что гарантирует оператор нулевого слияния Swift относительно вычисления правого операнда?

Определите, что напечатает код, и объясните механизм изменения значения через optional chaining:

struct Counter {
    var value = 0

    mutating func increment() {
        value += 1
    }
}

var counter: Counter? = Counter()
counter?.increment()
print(counter?.value ?? -1)

counter = nil
counter?.increment()
print(counter?.value ?? -1)

Почему первый вызов изменяет значение, а второй безопасно ничего не делает?

Рассмотрите массив экземпляров классов: после присваивания его другой переменной изменение свойства элемента отражается в обоих массивах. Какой механизм Swift объясняет этот результат?

Каким образом перегрузка оператора ~= позволяет пользовательскому типу участвовать в сопоставлении с образцом в Swift?

Тип реализует метод с сигнатурой протокола и совпадающей реализацией по умолчанию, но не объявляет соответствие этому протоколу. Успешно ли условительное приведение такого значения к протоколу?