Understanding Swift Programming: Swift 2 (2015)

PART 3: ADDITIONAL TOPICS

23. Variations in Closure Expression Syntax

In an earlier chapter (Chapter 18 on Closures and Closure Expressions) I discussed how closures, functions, and closure expressions were related and how closure expressions were used.

You saw the full closure expression syntax:

var d = { (a: Int, b: Int) -> Int in

var c = a + b

return c

}

var m = d(3, 4)

print (m) // Prints: 7

As well as the simplest:

var a = { print("Hello") }

a() // Prints: Hello

And this illustration that describes the syntax:

I said at that time that closures were very flexible in allowing a wide variety of syntax variations. The purpose of this chapter is to describe these variations and provide some hint about how the Swift compiler goes about accepting these variations.

Apple has put a lot of effort into a compiler that is quite intelligent in the way that it parses expressions for closures, and allows the programmer a lot of latitude.

This is mostly, but not necessarily entirely, a good thing. Even though it is possible to leave out much or even nearly all of the syntax for a particular closure, you should think about whether you should. Will the resulting code be readable? What makes perfect sense (and saves some typing) when you are doing a lot of coding with closures may not make much sense six months later when you have been working on something else for some time. Not to mention co-workers who may not have your level of skill in Swift who may end up working on your code.

The standard example—used in the Apple documentation—for describing the flexibility of Swift closure expression syntax is based on the Swift sorting function. This is an interesting example because it not only demonstrates how to get from the full closure syntax to the minimal form, but to an unusually freakish minimum of only a single character, a "<", telling the sort function what order it should sort things in.

Sorting An Array with a Closure Expression with Full Syntax

We begin with an array of strings that each represent the name of one of five states:

var states = ["Delaware","Alaska","Iowa","Florida","Connecticut"]

And we want to use a global Swift function known as sorted to sort them. The function sorted is a slightly more complex version of sort, which allows more control over how the sorting is done. The sort function just accepts the array to be sorted as its only input value. Thesorted function accepts the array to be sorted, plus a second input parameter that is designed for either a closure expression or a function.

The code to sort with a closure expression is:

var statesSorted = sorted(states,

{ (item1: String, item2: String) -> Bool in

return item1>item2

})

The global function sorted has two input parameters. The first is states, which is the array we just assigned that has names of states. The second argument is a closure expression. The closure expression is surrounded by the usual braces and begins with input parameters:

(item1: String, item2: String)

As we saw from the earlier chapter, it can get a little confusing when a function has what seems to be an "input parameter", but then that parameter turns out to be a closure or function, that itself has inputs and outputs. So this "input parameter" actually puts out values? Well, no. But the closure that gets supplied to the function sorted has inputs and outputs, and the function sorted does supply values to the closure.

The values that the function supplies to the closure are a pair of strings in a particular order. And what it wants in response is a simple Boolean value that indicates whether the strings have been provided in the correct order (true) or not (false).

Whenever the sorting function needs guidance about what order to sort (how it does this and how many times it does it depends on the sorting algorithms the function uses internally) it calls the closure expression with an ordered pair of strings (the names of the states, presumably) and then looks at the Boolean value of the output.

The closure expression has the expected return arrow (->), return type (Bool), and in keyword.

It also has a return statement that has the expression item1>item2. The > operator is actually the critical thing here—how it works in comparing whether one string is "greater than" another is what determines how the sorting is done.

When I ran this code I got the following:

"Iowa", "Florida", "Delaware", "Connecticut", "Alaska"

So assuming that we want alphabetical order, our sorting works but it is backwards. So we change the "greater than" character to a "less than" symbol:

var statesSorted = sorted(states,

{ (item1:String,item2:String) -> Bool in

return item1<item2

})

Which yielded:

"Alaska", "Connecticut", "Delaware", "Florida", "Iowa"

The desired result.

Successively Simplifying the Syntax

We can now go through a succession of simplifications of the syntax.

Input Parameter Types Not Required. In general, when providing a closure as a parameter in a function, it is not required to indicate the type. The function knows what type it will accept; the compiler can infer the type from what is returned (at least at this stage.) We can thus drop the input parameter types: