Swift Language Guide - Closure
Syntax
{ (parameters) -> return type in
statemetns
}
func mySort<T>(inout values: [T], compare: (T, T) -> Bool) {
for var i = 0; i < countElements(values); i++ {
for var j = i + 1; j < countElements(values); j++ {
if compare(values[i], values[j]) {
(values[i], values[j]) = (values[j], values[i])
}
}
}
}
func myDump<T>(values: [T]) {
for elm in values {
print("\(elm) ")
}
println()
}
var a = [3, 2, 8, 5, 9, 7, 12, 4]
myDump(a)
mySort(&a, { (v1: Int, v2: Int) -> Bool in
println("(\(v1), \(v2))")
return v1 > v2
})
myDump(a)
Inferring Type From Context
func mySort<T>(inout values: [T], compare: (T, T) -> Bool) {
for var i = 0; i < countElements(values); i++ {
for var j = i + 1; j < countElements(values); j++ {
if compare(values[i], values[j]) {
(values[i], values[j]) = (values[j], values[i])
}
}
}
}
func myDump<T>(values: [T]) {
for elm in values {
print("\(elm) ")
}
println()
}
var a = [3, 2, 8, 5, 9, 7, 12, 4]
myDump(a)
mySort(&a, { v1, v2 in
println("(\(v1), \(v2))")
return v1 > v2
})
myDump(a)
Implicit Returns from Single-Expression Closure
func mySort<T>(inout values: [T], compare: (T, T) -> Bool) {
for var i = 0; i < countElements(values); i++ {
for var j = i + 1; j < countElements(values); j++ {
if compare(values[i], values[j]) {
(values[i], values[j]) = (values[j], values[i])
}
}
}
}
func myDump<T>(values: [T]) {
for elm in values {
print("\(elm) ")
}
println()
}
var a = [3, 2, 8, 5, 9, 7, 12, 4]
myDump(a)
mySort(&a, { v1, v2 in v1 > v2 } )
myDump(a)
Shorthand Argument Names
func mySort<T>(inout values: [T], compare: (T, T) -> Bool) {
for var i = 0; i < countElements(values); i++ {
for var j = i + 1; j < countElements(values); j++ {
if compare(values[i], values[j]) {
(values[i], values[j]) = (values[j], values[i])
}
}
}
}
func myDump<T>(values: [T]) {
for elm in values {
print("\(elm) ")
}
println()
}
var a = [3, 2, 8, 5, 9, 7, 12, 4]
myDump(a)
mySort(&a, { $0 > $1 })
myDump(a)
Operator Functions (Extreme Shorthand)
func mySort<T>(inout values: [T], compare: (T, T) -> Bool) {
for var i = 0; i < countElements(values); i++ {
for var j = i + 1; j < countElements(values); j++ {
if compare(values[i], values[j]) {
(values[i], values[j]) = (values[j], values[i])
}
}
}
}
func myDump<T>(values: [T]) {
for elm in values {
print("\(elm) ")
}
println()
}
var a = [3, 2, 8, 5, 9, 7, 12, 4]
myDump(a)
mySort(&a, >)
myDump(a)
Closure on Assignment
let a: Int = { () -> Int in
return 10
}()
let b: Int = { (x: Int) -> Int in
return x + 20
}(20)
println(b)
let c: Int = {
return $0 + 20
}(20)
println(c)
let d: Int = { $0 + 20 }(20)
println(20)
Trailing Closures
The closure expression MUST be the function's FINAL argument.
func mySort<T>(inout values: [T], compare: (T, T) -> Bool) {
for var i = 0; i < countElements(values); i++ {
for var j = i + 1; j < countElements(values); j++ {
if compare(values[i], values[j]) {
(values[i], values[j]) = (values[j], values[i])
}
}
}
}
func myDump<T>(values: [T]) {
for elm in values {
print("\(elm) ")
}
println()
}
var a = [3, 2, 8, 5, 9, 7, 12, 4]
myDump(a)
mySort(&a) {
$0 > $1
}
myDump(a)
Capturing Values
var globalTotal = 0
func test(amount: Int) -> () -> (sub: Int, total: Int) {
var subTotal = 0
return { () -> (Int, Int) in
globalTotal += amount
subTotal += amount
return (subTotal, globalTotal)
}
}
let test10 = test(10)
var result = test10()
println("(\(result.sub), \(result.total))") <-- (10, 10)
result = test10()
println("(\(result.sub), \(result.total))") <-- (20, 20)
let test7 = test(7)
result = test7()
println("(\(result.sub), \(result.total))") <-- (7, 27)
result = test7()
println("(\(result.sub), \(result.total))") <-- (14, 34)
let testAnother10 = test(10)
result = testAnother10()
println("(\(result.sub), \(result.total))") <-- (10, 44)
Closure Are Reference Type
Assigning a closure to constans or variables is assigning its REFERENCE to them.
var globalTotal = 0
func test(amount: Int) -> () -> (sub: Int, total: Int) {
var subTotal = 0
return { () -> (Int, Int) in
globalTotal += amount
subTotal += amount
return (subTotal, globalTotal)
}
}
let testTen = test(10)
var rs = testTen()
println("(\(rs.sub), \(rs.total))") <-- (10, 10)
let testTenAnother = testTen <-- Assign reference to testTenAnother
rs = testTenAnother()
println("(\(rs.sub), \(rs.total))") <-- (20, 20)
