Best way to avoid capturing a copy of the value in closure - swift

Question

struct Foo {
var i = 0 { didSet { println("Current i: \(i)") } }
func delayedPrint() {
dispatch_async(dispatch_get_main_queue(), { _ in
println("Closure i: \(self.i)")
})
}
mutating func foo() {
delayedPrint()
i++
}
}
Now the output of
var a = Foo()
a.foo()
is
Current i: 1
Closure i: 0 // I want current value here.
I'm wondering what is the best way here to avoid capturing a copy of an ivar.
EDIT 1
Yes, moving to class was the first and only thing I've thought of but... this one fooled me to think it can be done somehow with struct... Why it works?
mutating func foo() {
delayedPrint()
dispatch_async(dispatch_get_main_queue(), { _ in
println("From foo: \(self.i)")
})
delayedPrint()
i++
}
Output:
Current i: 1
Closure i: 0
From foo: 1
Closure i: 0

Answer 1

I think you have to use class instead of structure here, because structs are passed by copy and classes by reference

Answer 2

I'm wondering what is the best way here to avoid capturing a copy of an ivar.
That is a misconception. You cannot "capture an ivar" in this way. What you are capturing is self! That is exactly why Swift forces you to say self, so that you understand this fact. Thus, it makes a difference what kind of thing self is. And that is why it matters whether self is a struct or a class. The class instance is mutable in place; the struct instance is not, so a copy is taken at the time of capture and that copy persists independently.
However, you can capture a simple Int (i.e. not an ivar), and when you do, you get the result you expect:
var i = 0
struct Foo {
func delayedPrint() {
dispatch_async(dispatch_get_main_queue(), {
println(i) // 1
})
}
func foo() {
delayedPrint()
i++
}
}
Now let's talk about the second puzzle that you pose. Here's a rewrite, to clarify what the puzzle is:
func delay(delay:Double, closure:()->()) {
dispatch_after(
dispatch_time(
DISPATCH_TIME_NOW,
Int64(delay * Double(NSEC_PER_SEC))
),
dispatch_get_main_queue(), closure)
}
struct Foo {
var i = 0
mutating func foo() {
delay(0.5) {
println("From foo: \(self.i)") // 1
}
bar(2)
i++
}
func bar(d:Double) {
delay(d) {
println("from bar: \(self.i)") // 0
}
}
}
I'll test it like this:
var a = Foo()
a.foo()
a.bar(1)
The console shows:
From foo: 1 [after half a second]
from bar: 1 [after 1 second]
from bar: 0 [after 2 seconds]
So how can bar be called the second time 1 second later, yet show a value of self.i that is earlier? And why does foo behave differently?
The answer has to do with the fact that everything is happening inside functions - including the definitions of the anonymous functions. The code has to run at some point. Until then, the anonymous function is not defined.
First let's consider a.bar(1). This causes bar to run and to define the anonymous function which will capture self. But this happens after we have called foo and incremented i. Thus, the self captured at this time has an incremented i.
Next let's consider what happens when foo calls bar. It does this before incrementing i. So now bar runs and the anonymous function is defined, and captures self with i still set at 0. The fact that this result arrives into the console two seconds later is irrelevant; what is important is when the capture took place.
Finally we come to the surprising case of the anonymous function inside foo. Clearly, the presence of the i++ inside foo make all the difference. Why? Well, when foo runs, it defines an anonymous function that captures self. But this self has also been captured inside foo itself for the purposes of saying i++ — which is really self.i++. Thus, the change on self performed by i++ is seen by this anonymous function as well, because they are looking at the same self.
In other words, I'm suggesting that you have hit the Mysterious Edge Case of the anonymous function defined within a function that itself mutates self. (I don't know if I think this a bug or not; I'm going to submit it to dev forum and see what they think.)

Answer 3

In order to complement #nikolayn perfect answer, here is a sample that can run in the console and that demonstrates how this can be accomplished with a class instead of a struct (and is also free of data races):
(variables are defined explicit so that you can easily debug)
import Foundation
import Cocoa
let queue = dispatch_queue_create("sync_queue", nil)!
class Foo {
var i = 0 { didSet { println("Current i: \(i)") } }
let sem = dispatch_semaphore_create(0);
func delayedPrint() {
let i_copy = i
let t = dispatch_time(DISPATCH_TIME_NOW, Int64(1 * Double(NSEC_PER_SEC)))
dispatch_after(t, queue) { _ in
let _i = self.i
let _i_copy = i_copy
println("Closure i: \(_i)")
println("Closure i_copy: \(_i_copy)")
dispatch_semaphore_signal(self.sem)
}
}
func foo() {
delayedPrint()
dispatch_async(queue) {
self.i++
}
}
func wait() {
dispatch_semaphore_wait(sem, DISPATCH_TIME_FOREVER)
}
}
var a = Foo()
a.foo()
a.wait()