Trouble with Grand Central Dispatch using Swift - ios

Question

I have the following function that doesn't behave as I would have expected.
func dispatchTrouble(startValue:Float, endValue:Float, duration:Float)
{
//100 increment steps per second
let incrementSteps = duration * 100
for(var step = 0.0 as Float; step < incrementSteps; step++)
{
var delayInSeconds = step * (duration / incrementSteps)
let answer = Float(NSEC_PER_SEC) * delayInSeconds
let popTime = dispatch_time(DISPATCH_TIME_NOW, Int64(answer))
println(step)
//Using GCD to perform this on the main thread.
dispatch_after(popTime, dispatch_get_main_queue()){
println(step)
let fraction = step / incrementSteps
let incrementedValue = startValue + (endValue - startValue) * fraction
println(incrementedValue)
}
}
}
I expected the println(incrementedValue) statement to display a value that incremented from startValue to endValue and to finish in the number of seconds passed in duration.
However the behavior I get is that the code in the dispatch_after closure only prints the final value, it never prints the increments.
The delay occurs as expected, but the values are all calculated as if the for-loop had already completed. The first println(step) does show step incrementing, but the second one only shows the final value.
I clearly have a misunderstanding of how this should work. I expected that the code in the closure would hold the values that existed at the time the dispatch_after method was called, but it acts like it uses whatever the value is at the time it actually executes instead.
How can I capture the values at each iteration of the for-loop and execute the code in the closure using that?

Answer 1

All the closures you send to GDC are pointing to the same step variable. That means that every time one of them executes, it has the value it had when the loop ended.
Try changing your code to this:
func dispatchTrouble(startValue:Float, endValue:Float, duration:Float)
{
//100 increment steps per second
let incrementSteps = duration * 100
for(var step = 0.0 as Float; step < incrementSteps; step++)
{
var delayInSeconds = step * (duration / incrementSteps)
let answer = Float(NSEC_PER_SEC) * delayInSeconds
let popTime = dispatch_time(DISPATCH_TIME_NOW, Int64(answer))
println(step)
let stepCopy = step
//Using GCD to perform this on the main thread.
dispatch_after(popTime, dispatch_get_main_queue()){
println(stepCopy)
let fraction = stepCopy / incrementSteps
let incrementedValue = startValue + (endValue - startValue) * fraction
println(incrementedValue)
}
}
}
It'll work like that. The closure is doing a retain on step, as explained on the swift reference.

Answer 2

Unlike Objective-C blocks which capture values, Swift closures capture variables. That means where an Objective-C block would have captured 100 different values of the "step" variable, the Swift closure captures the variable itself and prints its value at the time the closure is called.
The best way to fix this is to add a capture list.
dispatch_after(popTime, dispatch_get_main_queue()){
[let stepcopy = step] () -> Void in
println(stepcopy)
let fraction = stepcopy / incrementSteps
let incrementedValue = startValue + (endValue - startValue) * fraction
println(incrementedValue)
}
So a closure starts with {, followed optionally by the capture list in [ brackets], followed optionally by (arguments) -> result in, followed by the code.
BTW by using Float instead of Double you reduce the precision to about 7 digits instead of 15, for no good reason whatsoever.