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

В чём механизм восходящего приведения экземпляра подкласса к базовому классу через as и почему оно не может завершиться ошибкой во время выполнения?

На границе вызова функции параметр имеет тип Optional<String>, а передаваемый аргумент — String: каким преобразованием Swift принимает аргумент без явного оборачивания?

При передаче значения структуры через inout является ли параметр постоянной ссылкой на исходное хранилище?

При объявлении функции с возвращаемым типом some Protocol что скрывается от вызывающего кода и чем это отличается от any Protocol?

На объект оставили только слабую ссылку. Какое значение напечатает код после выхода из области видимости и почему?

final class Token {}

final class Store {
    weak var token: Token?
}

let store = Store()
do {
    let token = Token()
    store.token = token
    print(store.token != nil)
}
print(store.token == nil)

За счёт чего optional binding одновременно проверяет nil и меняет тип связанной переменной?

Что именно гарантирует ограничение протокола AnyObject и чего оно не меняет в семантике типа?

Что мешает Swift вывести параметр типа при передаче nil в обобщённую функцию без контекста?

При наличии двух перегрузок Swift для аргумента типа String — принимающей String и принимающей String? — какая будет вызвана и почему?

В этом фрагменте определите, почему условие с диапазоном совпадает со значением и какой текст напечатает код:

let statusCode = 404

if case 400..<500 = statusCode {
    print("ошибка клиента")
} else {
    print("другой результат")
}

Как оператор равенства сравнивает два Optional и от чего зависит возможность такого сравнения?

При успешном условительном приведении объекта к типу протокола какой тип получает связанная переменная и что при этом происходит с конкретным типом объекта?

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

Вызов функции получает значение nil. Определите, на какой операции завершится выполнение и почему:

func greet(_ name: String) -> String {
    "Привет, \(name)!"
}

let name: String! = nil
let message = greet(name)
print(message)

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

Как шаблон перечисления проверяет case и извлекает его связанное значение?

Разберите вызов изменяющего метода через existential-значение. Какое число напечатает код и почему изменение сохраняется?

Объясните механизм: почему значение типа any протокола с associatedtype нельзя использовать через имя его ассоциированного типа?

Что произойдёт при попытке использовать Optional как логическое условие в Swift без явного извлечения?

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

struct Address {
    let city: String
}

struct User {
    let address: Address?
}

let user: User? = User(address: nil)
let city = user?.address?.city
print(city as Any)

Объясните, как optional chaining влияет на результат.