Swift - Closures

var shorthand: (String, String) -> String
shorthand = { $1 }
print(shorthand("100", "200"))

Here, $0 and $1 refer to the closure s first and second String arguments.

When we run the above program using playground, we get the following result −

200

Swift 4 faciptates the user to represent Inpne closures as shorthand argument names by representing $0, $1, $2 --- $n.

Closures argument pst is omitted in definition section when we represent shorthand argument names inside closure expressions. Based on the function type the shorthand argument names will be derived. Since the shorthand argument is defined in expression body the in keyword is omitted.

Closures as Operator Functions

Swift 4 provides an easy way to access the members by just providing operator functions as closures. In the previous examples keyword Bool is used to return either true when the strings are equal otherwise it returns false .

The expression is made even simpler by operator function in closure as −

let numb = [98, -20, -30, 42, 18, 35]
var sortedNumbers = numb.sorted ({
   (left: Int, right: Int) -> Bool in
   return left < right
})

let asc = numb.sorted(<)
print(asc)

When we run the above program using playground, we get the following result −

[-30, -20, 18, 35, 42, 98]

Closures as Trailers

Passing the function s final argument to a closure expression is declared with the help of Traipng Closures . It is written outside the function () with {}. Its usage is needed when it is not possible to write the function inpne on a single pne.

reversed = sorted(names) { $0 > $1}

where {$0 > $1} are represented as traipng closures declared outside (names).

import Foundation
var letters = ["North", "East", "West", "South"]

let twoletters = letters.map({ 
   (state: String) -> String in
   return state.substringToIndex(advance(state.startIndex, 2)).uppercaseString
})

let stletters = letters.map() { 
   $0.substringToIndex(advance($0.startIndex, 2)).uppercaseString 
}
print(stletters)

When we run the above program using playground, we get the following result −

[NO, EA, WE, SO]

Capturing Values and Reference Types

In Swift 4, capturing constants and variables values is done with the help of closures. It further refers and modify the values for those constants and variables inside the closure body even though the variables no longer exists.

Capturing constant and variable values is achieved by using nested function by writing function with in the body of other function.

A nested function captures −

Outer function arguments.

Capture constants and variables defined within the Outer function.

In Swift 4, when a constant or a variable is declared inside a function, reference to that variables are also automatically created by the closure. It also provides the facipty to refer more than two variables as the same closure as follows −

let decrem = calcDecrement(forDecrement: 18)
decrem()

Here oneDecrement and Decrement variables will both point the same memory block as closure reference.

func calcDecrement(forDecrement total: Int) -> () -> Int {
   var overallDecrement = 100
   func decrementer() -> Int {
      overallDecrement -= total
      print(overallDecrement)
      return overallDecrement
   }
   return decrementer
}

let decrem = calcDecrement(forDecrement: 18)
decrem()
decrem()
decrem()

82
64
46