A function parameter type along with its return type defines the type of the function. For instance, the function type for the following coding example is (Int, Double) -> String:

func functionName(firstParam: Int, secondParam: Double) -> String 

We will be able to use function types in the way we use other types. The following code example presents a function type:

var simpleMathOperator: (Double, Double) -> Double 

Here, simpleMathOperator is a variable of a function of the (Double, Double) -> Double type.

We could define typealias for the function type as follows:

typealias SimpleOperator = (Double, Double) -> Double 

We can use this typealias in the simpleMathOperator definition as follows:

var simpleMathOperator: SimpleOperator 

We can define functions with the same type and assign them to our simpleMathOperator. The type of functions in the following code snippet is (Double, Double) -> Double, which is in fact SimpleOperator:

func addTwoNumbers(a: Double, b: Double) -> Double { return a + b } 
 
func subtractTwoNumbers(a: Double, b: Double) -> Double { return a - b } 
 
func divideTwoNumbers(a: Double, b: Double) -> Double { return a / b } 
 
func multiplyTwoNumbers(a: Double, b: Double) -> Double { return a * b } 

Therefore, we are able to assign these functions to simpleMathOperator as follows:

simpleMathOperator = multiplyTwoNumbers 

This means that simpleMathOperator refers to the multiplyTwoNumbers function:

let result = simpleMathOperator(3.0, 4.0) // result is 12

As the other three functions also have the same function type, we will be able to assign them to the same variable:

simpleMathOperator = addTwoNumbers 
let result = simpleMathOperator(3.5, 5.5) // result is 9 

We can use SimpleOperator as a parameter type of other functions:

func calculateResult(mathOperator: SimpleOperator, a: Double, b: Double)
  -> Double {
    return mathOperator(a, b)
}

print("The result is (calculateResult(mathOperator: simpleMathOperator,
  a: 3.5, b: 5.5))") // prints "The result is 9.0"

Here, the calculateResult function has three parameters. The mathOperator parameter is a type of function type. The a and b parameters are Double. When we call this function, we pass a simpleMathOperator function and two Double values for a and b.

It is important to know that we pass only a reference to simpleMathOperator and this is not going to execute it. In the function body, we use this function and call it with a and b.

We can use SimpleOperator as a return type of a function:

func choosePlusMinus(isPlus: Bool) -> SimpleOperator {
    return isPlus ? addTwoNumbers : subtractTwoNumbers
}

let chosenOperator = choosePlusMinus(isPlus: true)
print("The result is (chosenOperator(3.5, 5.5))") // prints "The result
  is 9.0"

Here, the choosePlusMinus function has a Bool parameter; in its body, it checks for this parameter and returns addTwoNumbers or subtractTwoNumbers that have the same type, SimpleOperator.

It is important to understand that calling choosePlusMinus(true) does not execute the returned function and in fact only returns the reference to addTwoNumbers. We save this reference in chosenOperator. The chosenOperator variable becomes the following:

func addTwoNumbers(a: Double, b: Double) -> Double { return a + b } 

When we call chosenOperator(3.5, 5.5), we pass these two numbers to the addTwoNumbers function and execute it.

The capability to define function types makes functions first-class citizens in Swift. Function types are used for first-class and higher-order functions. These capabilities empower us to apply functional programming paradigms in Swift.