Strong reference cycle for closures in Swift - swift

Question

I was going through the documentation (chapter on “Automatic Reference Counting” section “Strong Reference Cycles for Closures”) and I can't seem to figure out cases, when defining a class, in which I should keep a strong reference to self (the instance of that class) in a closure to a property.
Capture Lists seem always the best solution to avoid memory leaks, and I really can't think of any scenarios in which I should keep a strong reference cycle.
Here are the examples that the documentation gives:
class HTMLElement {
let name: String
let text: String?
// Without Capture List
#lazy var asHTML: () -> String = {
if let text = self.text {
return "<\(self.name)>\(text)</\(self.name)>"
} else {
return "<\(self.name) />"
}
}
init(name: String, text: String? = nil) {
self.name = name
self.text = text
}
deinit {
println("\(name) is being deinitialized")
}
}
class HTMLElement {
let name: String
let text: String?
// With Capture List
#lazy var asHTML: () -> String = {
[unowned self] in
if let text = self.text {
return "<\(self.name)>\(text)</\(self.name)>"
} else {
return "<\(self.name) />"
}
}
init(name: String, text: String? = nil) {
self.name = name
self.text = text
}
deinit {
println("\(name) is being deinitialized")
}
}

Answer 1

You need to keep a strong reference to self if you’re creating a closure to be executed by an object or function whose lifetime may not match self’s.
For example:
class A {
func do() {
dispatch_async(dispatch_get_global_queue(0, 0)) {
println("I printed \(self) some time in the future.")
}
}
}
var a : A? = A()
a.do()
a = nil // <<<
At the arrow the main function body will release its last reference to the newly created instance of A, but the dispatch queue needs to keep a hold on it until the closure is done executing.