My understanding is that closures are reference types, so doing something like the following will result in both constants referring to the same instance of the closure:
let closureA = { print("I'm in a closure") }
let closureB = closureA
In Obj-C I believe there was a way to make a copy of a block.
Is there a way to make a copy of a closure in Swift?
The copying mechanism in ObjC is just for getting the block off the stack; once it’s off the stack, “copying” just retains the existing value. That detail is something that Swift hides from you.
Closure variables have value semantics. (But are presumably only copy‐on‐write like structures.)
var closure: (Int) -> Void = { print("\($0): I’m still the first closure.") }
closure(1) // 1: I’m still the first closure.
var newVariable = closure
newVariable(2) // 2: I’m still the first closure.
closure = { print("\($0): I’ve been mutated.") }
closure(3) // 3: I’ve been mutated.
newVariable(4) // 4: I’m still the first closure.
On second thought, that’s not really mutation but reassignment.
Since closures aren’t mutable in the first place, I’m not sure what difference it makes, or why you would need a copy instead of a reference. What is it you are trying to do?
Closures are meant to be blocks of functionality, they don't hold stored state or properties. So I'm also curious what the intention of OP is.
That's not true, they do hold state and that state isn't copied when you copy the closure itself. Check out this snippet:
func giveMeAClosureThatHoldsState() -> ( (Int) -> Int ) {
var state = 0
return { difference in
state += difference
return state
}
}
let closureWithState = giveMeAClosureThatHoldsState()
let closureCopy = closureWithState
let anotherClosureWithState = giveMeAClosureThatHoldsState()
print(closureWithState(1)) // prints 1
print(closureWithState(1)) // prints 2
print(closureCopy(1)) // prints 3
print(anotherClosureWithState(1)) // prints 1
As others have explained above, closures don't really copy.
Yet there is a closure feature which is somewhat related: the capture list.
The capture list allows a closure to copy the values of captured variables, and this makes a big difference when captured variables are mutable. Compare:
var value = 0
let closure1 = { return value }
let closure2 = { [value] in return value }
print("closure1: \(closure1())") // prints "closure1: 0"
print("closure2: \(closure2())") // prints "closure2: 0"
value = 42
print("closure1: \(closure1())") // prints "closure1: 42"
print("closure2: \(closure2())") // prints "closure2: 0"
See Documentation for more information.
I guess you meant to say "they do hold state and state is copied when you copy the closure itself" -> print(closureWithCopy(1)) results in "3" as opposed to "2" (which imo would mean the state isn't copied) ?
Here's what going on after each line. Notice how both closureWithState and closureCopy point to the same state, so calling closureWithState changes what closureCopy returns
let closureWithState = giveMeAClosureThatHoldsState()
// ┌─────────┐
// │state: 0 │
// └───▲─────┘
// │
// │
// │
// │
// │
// │
// closureWithState
let closureCopy = closureWithState
// ┌─────────┐
// │state: 0 │
// └───▲──▲──┘
// │ │
// │ │
// │ └────────────┐
// │ │
// │ │
// │ │
// closureWithState closureCopy
let anotherClosureWithState = giveMeAClosureThatHoldsState()
// ┌─────────┐ ┌─────────┐
// │state: 0 │ │state: 0 │
// └───▲──▲──┘ └──────▲──┘
// │ │ │
// │ │ │
// │ └────────────┐ │
// │ │ │
// │ │ │
// │ │ │
// closureWithState closureCopy anotherClosureWithState
print(closureWithState(1)) // prints 1
// ┌─────────┐ ┌─────────┐
// │state: 1 │ │state: 0 │
// └───▲──▲──┘ └──────▲──┘
// │ │ │
// │ │ │
// │ └────────────┐ │
// │ │ │
// │ │ │
// │ │ │
// closureWithState closureCopy anotherClosureWithState
print(closureWithState(1)) // prints 2
// ┌─────────┐ ┌─────────┐
// │state: 2 │ │state: 0 │
// └───▲──▲──┘ └──────▲──┘
// │ │ │
// │ │ │
// │ └────────────┐ │
// │ │ │
// │ │ │
// │ │ │
// closureWithState closureCopy anotherClosureWithState
print(closureCopy(1)) // prints 3
// ┌─────────┐ ┌─────────┐
// │state: 3 │ │state: 0 │
// └───▲──▲──┘ └──────▲──┘
// │ │ │
// │ │ │
// │ └────────────┐ │
// │ │ │
// │ │ │
// │ │ │
// closureWithState closureCopy anotherClosureWithState
print(anotherClosureWithState(1)) // prints 1
// ┌─────────┐ ┌─────────┐
// │state: 4 │ │state: 1 │
// └───▲──▲──┘ └──────▲──┘
// │ │ │
// │ │ │
// │ └────────────┐ │
// │ │ │
// │ │ │
// │ │ │
// closureWithState closureCopy anotherClosureWithState
let closureWithState = giveMeAClosureThatHoldsState()
// ┌─────────┐
// │state: 0 │
// └───▲─────┘
// │
// │
// │
// │
// │
// │
// closureWithState
let closureCopy = closureWithState
// ┌─────────┐ ┌─────────┐
// │state: 0 │ │state: 0 │
// └───▲─────┘ └──────▲──┘
// │ │
// │ │
// │ │
// │ │
// │ │
// │ │
// closureWithState closureCopy
let anotherClosureWithState = giveMeAClosureThatHoldsState()
// ┌─────────┐ ┌─────────┐ ┌─────────┐
// │state: 0 │ │state: 0 │ │state: 0 │
// └───▲─────┘ └──────▲──┘ └──────▲──┘
// │ │ │
// │ │ │
// │ │ │
// │ │ │
// │ │ │
// │ │ │
// closureWithState closureCopy anotherClosureWithState
print(closureWithState(1)) // prints 1
// ┌─────────┐ ┌─────────┐ ┌─────────┐
// │state: 1 │ │state: 0 │ │state: 0 │
// └───▲─────┘ └──────▲──┘ └──────▲──┘
// │ │ │
// │ │ │
// │ │ │
// │ │ │
// │ │ │
// │ │ │
// closureWithState closureCopy anotherClosureWithState
print(closureWithState(1)) // prints 2
// ┌─────────┐ ┌─────────┐ ┌─────────┐
// │state: 2 │ │state: 0 │ │state: 0 │
// └───▲─────┘ └──────▲──┘ └──────▲──┘
// │ │ │
// │ │ │
// │ │ │
// │ │ │
// │ │ │
// │ │ │
// closureWithState closureCopy anotherClosureWithState
print(closureCopy(1)) // ❗should print 1, because it copied state when it was still zero❗
// ┌─────────┐ ┌─────────┐ ┌─────────┐
// │state: 2 │ │state: 1 │ │state: 0 │
// └───▲─────┘ └──────▲──┘ └──────▲──┘
// │ │ │
// │ │ │
// │ │ │
// │ │ │
// │ │ │
// │ │ │
// closureWithState closureCopy anotherClosureWithState
print(anotherClosureWithState(1)) // prints 1, because it was created with it's own state
// ┌─────────┐ ┌─────────┐ ┌─────────┐
// │state: 2 │ │state: 1 │ │state: 1 │
// └───▲─────┘ └──────▲──┘ └──────▲──┘
// │ │ │
// │ │ │
// │ │ │
// │ │ │
// │ │ │
// │ │ │
// closureWithState closureCopy anotherClosureWithState