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

После входа экземпляра класса в deinit когда ARC освобождает его сильные stored-свойства?

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

final class Token {
    let id: String
    init(_ id: String) { self.id = id }
    deinit { print("deinit", id) }
}

final class Box {
    var token: Token? {
        didSet { print("didSet", oldValue?.id ?? "nil") }
    }
}

let box = Box()
box.token = Token("A")
box.token = Token("B")

Почему deinit не подходит как единственный механизм своевременного освобождения внешнего ресурса?

Какую гарантию даёт withExtendedLifetime, которой обычная локальная ссылка ARC не обязана обеспечивать?

Что удерживает escaping-замыкание, если оно захватывает локальную weak-ссылку без явного списка захвата?

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

Как сохранённая ссылка на экземплярный метод влияет на время жизни его объекта?

Разберите механизм временного преобразования non-escaping-замыкания в escaping: может ли такой вызов продлить жизнь захваченного объекта после завершения withoutActuallyEscaping?

func accept(_ action: @escaping () -> Void) {
    action()
}

func run(_ action: () -> Void) {
    withoutActuallyEscaping(action) { temporary in
        accept(temporary)
    }
}

final class Probe {
    func touch() { print("touch") }
    deinit { print("deinit") }
}

func test() {
    let probe = Probe()
    run { probe.touch() }
}

test()

Что меняет объявление сильной ссылки на экземпляр класса через let: сам объект или только возможность переназначить ссылку?

Вложенное escaping-замыкание обращается к self внутри внешнего замыкания с [weak self]. Что определяет, станет ли self сильным захватом во внутреннем замыкании?

При досрочном выходе из функции через throw когда ARC освобождает сильные локальные ссылки?

При очистке массива экземпляров классов через removeAll(keepingCapacity:), когда экземпляры могут быть уничтожены?

Вызывается ли deinit у экземпляра класса, если его инициализатор завершился ошибкой?

Может ли структура сама по себе образовать цикл сильных ссылок, если хранит замыкание?

При передаче экземпляра Swift-класса в Objective-C API кто гарантирует его жизнь до завершения вызова?

Сохраняет ли путь к свойству (key path) экземпляр класса, для которого он предназначен?

Оцените владение объектом: достаточно ли сохранить его адрес в UnsafeMutableRawPointer, чтобы ARC удерживал объект?

Может ли deinit приостановить уничтожение объекта до завершения асинхронной операции?

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

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

final class Session {
    deinit { print("deinit") }
}

var session: Session? = Session()
let identifier = ObjectIdentifier(session!)
session = nil
print(identifier)