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

Гарантирует ли Swift порядок вычисления аргументов функции, если они имеют побочные эффекты?

При реализации Hashable какое отношение между равенством значений и результатом hash(into:) обязательно сохранить?

Какой предел представления мешает структуре хранить экземпляр собственного типа напрямую?

В каких условиях Swift различает перегруженные функции только по возвращаемому типу?

В приложении несколько потоков одновременно впервые обращаются к статическому хранимому свойству Swift. Как Swift гарантирует его инициализацию?

Определите, какую ветку выполнит Swift после fallthrough при таком значении x.

let x = 1

switch x {
case 1:
    print("one")
    fallthrough
case 2:
    print("two")
default:
    print("other")
}

Что именно требует компилятор от двух аргументов, связанных одним generic-параметром в этом вызове?

func pair<T>(_ first: T, _ second: T) -> (T, T) {
    (first, second)
}

let integer = 1
let decimal = 2.0
let result = pair(integer, integer)
// let error = pair(integer, decimal)

В сценарии с перечислением, поддерживающим Equatable, как метки связанных значений влияют на сравнение его экземпляров?

Представьте вызов функции, принимающей замыкание: откуда Swift берёт типы его неаннотированных параметров?

Разберите ограничение: почему Swift не позволяет объявлять deinit в структуре?

При анализе функции Swift видит локальную переменную, которой присваивают значение внутри цикла: по какому принципу он решает, разрешено ли её чтение после цикла?

Объясните механизм представления 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 объясняет этот результат?