‏defer مع الأخطاء وعمليات الإرجاع المبكر

func check(_ value: Int) {
    defer { print("cleanup ran") }
    if value < 0 {
        print("negative, returning early")
        return
    }
    print("value is", value)
}
check(-5)

func classify(_ n: Int) {
    defer { print("done classifying") }
    if n == 0 { print("zero"); return }
    if n > 0 { print("positive"); return }
    print("negative")
}
classify(0)

enum MyError: Error { case bad }
func risky(_ fail: Bool) throws {
    defer { print("cleanup on the way out") }
    if fail { throw MyError.bad }
    print("no failure")
}
try? risky(true)

enum E: Error { case oops }
func op(_ flag: Bool) throws -> Int {
    defer { print("op finishing") }
    if flag { throw E.oops }
    return 42
}
let r = try? op(false)
print(r ?? -1)

enum E: Error { case fail }
func load(_ broken: Bool) throws {
    print("open")
    defer { print("close") }
    if broken { throw E.fail }
    print("read")
}
do {
    try load(true)
} catch {
    print("caught:", error)
}

func process(_ items: [Int]) {
    print("start")
    defer { print("finished") }
    guard !items.isEmpty else {
        print("nothing to do")
        return
    }
    print("processing", items.count, "items")
}
process([])

enum E: Error { case stop }
func loop() throws {
    for i in 1...3 {
        defer { print("end", i) }
        if i == 2 { throw E.stop }
        print("body", i)
    }
}
try? loop()

func multi(_ skip: Bool) {
    defer { print("A") }
    defer { print("B") }
    if skip { return }
    print("body")
}
multi(true)

enum E: Error { case bad }
func attempt(_ fail: Bool) throws {
    var success = false
    defer { print("attempt success:", success) }
    if fail { throw E.bad }
    success = true
}
try? attempt(true)

enum E: Error { case fail }
func transaction(_ fail: Bool) throws {
    var inProgress = true
    defer { inProgress = false; print("inProgress:", inProgress) }
    if fail { throw E.fail }
    print("committed")
}
try? transaction(true)

enum E: Error { case x }
func safe(_ fail: Bool) throws {
    print("acquire")
    defer { print("release") }
    if fail { throw E.x }
    print("use")
}
try? safe(true)

func f(_ skip: Bool) {
    defer { print("cleanup") }
    if skip { return }
    print("work")
}
f(true)