the-swift-rogramming-language

called incrementor. The nested incrementor function captures two values, runningTotal and amount, from its surrounding context. After capturing these values, incrementor is returned by makeIncrementor as a closure that increments runningTotal by amount each time it is called.

func makeIncrementor(forIncrement amount: Int) -> () -> Int { var runningTotal = 0

func incrementor() -> Int { runningTotal += amount return runningTotal

}

return incrementor

}

The return type of makeIncrementor is () -> Int. This means that it returns a function, rather than a simple value. The function it returns has no parameters, and returns an Int value each time it is called. To learn how functions can return other functions, see Function Types as Return Types.

The makeIncrementor function defines an integer variable called runningTotal, to store the current running total of the incrementor that will be returned. This variable is initialized with a value of 0.

The makeIncrementor function has a single Int parameter with an external name of forIncrement, and a local name of amount. The argument value passed to this parameter specifies how much runningTotal should be incremented by each time the returned incrementor function is called.

makeIncrementor defines a nested function called incrementor, which performs the actual incrementing. This function simply adds amount to runningTotal, and returns the result.

When considered in isolation, the nested incrementor function might seem unusual:

func incrementor() -> Int {

runningTotal += amount

return runningTotal

}

The incrementor function doesn’t have any parameters, and yet it refers to runningTotal and amount from within its function body. It does this by capturing the existing values of runningTotal and amount from its surrounding function and using them within its own function

body.

Because it does not modify amount, incrementor actually captures and stores a copy of the value stored in amount. This value is stored along with the new incrementor function.

However, because it modifies the runningTotal variable each time it is called, incrementor captures a reference to the current runningTotal variable, and not just a copy of its initial value. Capturing a reference ensures sure that runningTotal does not disappear when the call to makeIncrementor ends, and ensures that runningTotal will continue to be available the next time that the incrementor function is called.

N O T E

Swift determines what should be captured by reference and what should be copied by value. You don’t need to annotate amount or runningTotal to say that they can be used within the nested incrementor function. Swift also handles all memory management involved in disposing of runningTotal when it is no longer needed by the incrementor function.

Here’s an example of makeIncrementor in action:

let incrementByTen = makeIncrementor(forIncrement: 10)

This example sets a constant called incrementByTen to refer to an incrementor function that adds 10 to its runningTotal variable each time it is called. Calling the function multiple times shows this behavior in action:

incrementByTen()

//returns a value of 10 incrementByTen()

//returns a value of 20 incrementByTen()

//returns a value of 30

If you create another incrementor, it will have its own stored reference to a new, separate runningTotal variable. In the example below, incrementBySeven captures a reference to a new runningTotal variable, and this variable is unconnected to the one captured by

incrementByTen:

let incrementBySeven = makeIncrementor(forIncrement: 7) incrementBySeven()

//returns a value of 7 incrementByTen()

//returns a value of 40

N O T E

If you assign a closure to a property of a class instance, and the closure captures that instance by referring to the instance or its members, you will create a strong reference cycle between the closure and the instance. Swift uses capture lists to break these strong reference cycles. For more information, see Strong Reference Cycles for Closures.

Closures Are Reference Types

In the example above, incrementBySeven and incrementByTen are constants, but the closures these constants refer to are still able to increment the runningTotal variables that they have captured. This is because functions and closures are reference types.

Whenever you assign a function or a closure to a constant or a variable, you are actually setting that constant or variable to be a reference to the function or closure. In the example above, it is the choice of closure that incrementByTen refers to that is constant, and not the contents of the closure itself.

This also means that if you assign a closure to two different constants or variables, both of those constants or variables will refer to the same closure:

let alsoIncrementByTen = incrementByTen

alsoIncrementByTen()

// returns a value of 50

case North

case South

case East

case West

}

The values defined in an enumeration (such as North, South, East, and West) are the member values (or members) of that enumeration. The case keyword indicates that a new line of member values is about to be defined.

N O T E

Unlike C and Objective-C, Swift enumeration members are not assigned a default integer value when they are created. In the CompassPoints example above, North, South, East and West do not implicitly equal 0, 1, 2 and 3. Instead, the different enumeration members are fully-fledged values in their own right, with an explicitly-defined type of CompassPoint.

Multiple member values can appear on a single line, separated by commas:

enum Planet {

case Mercury, Venus, Earth, Mars, Jupiter, Saturn, Uranus, Neptune

}

Each enumeration definition defines a brand new type. Like other types in Swift, their names (such as CompassPoint and Planet) should start with a capital letter. Give enumeration types singular rather than plural names, so that they read as self-evident:

var directionToHead = CompassPoint.West

The type of directionToHead is inferred when it is initialized with one of the possible values of CompassPoint. Once directionToHead is declared as a CompassPoint, you can set it to a different CompassPoint value using a shorter dot syntax:

directionToHead = .East

The type of directionToHead is already known, and so you can drop the type when setting its value. This makes for highly readable code when working with explicitly-typed enumeration values.

Matching Enumeration Values with a Switch Statement

You can match individual enumeration values with a switch statement:

directionToHead = .South switch directionToHead { case .North:

println("Lots of planets have a north") case .South:

println("Watch out for penguins") case .East:

println("Where the sun rises") case .West:

ntln("Where the skies are blue")

ts "Watch out for penguins"

You can read this code as:

“Consider the value of directionToHead. In the case where it equals .North, print "Lots of planets

have a north". In the case where it equals .South, print "Watch out for penguins".”

…and so on.

As described in Control Flow, a switch statement must be exhaustive when considering an enumeration’s members. If the case for .West is omitted, this code does not compile, because it does not consider the complete list of CompassPoint members. Requiring exhaustiveness ensures that enumeration members are not accidentally omitted.

When it is not appropriate to provide a case for every enumeration member, you can provide a default case to cover any members that are not addressed explicitly:

let somePlanet = Planet.Earth switch somePlanet {

case .Earth:

println("Mostly harmless") default:

println("Not a safe place for humans")

case .UPCA(let numberSystem, let identifier, let check):

println("UPC-A with value of \(numberSystem), \(identifier), \(check).") case .QRCode(let productCode):

println("QR code with value of \(productCode).")

}

// prints "QR code with value of ABCDEFGHIJKLMNOP."

If all of the associated values for a enumeration member are extracted as constants, or if all are extracted as variables, you can place a single var or let annotation before the member name, for brevity:

switch productBarcode {

case let .UPCA(numberSystem, identifier, check):

println("UPC-A with value of \(numberSystem), \(identifier), \(check).") case let .QRCode(productCode):

println("QR code with value of \(productCode).")

}

// prints "QR code with value of ABCDEFGHIJKLMNOP."

Raw Values

The barcode example in Associated Values shows how members of an enumeration can declare that they store associated values of different types. As an alternative to associated values, enumeration members can come prepopulated with default values (called raw values), which are all of the same type.

Here’s an example that stores raw ASCII values alongside named enumeration members:

enum ASCIIControlCharacter: Character { case Tab = "\t"

case LineFeed = "\n" case CarriageReturn = "\r"

}

Here, the raw values for an enumeration called ASCIIControlCharacter are defined to be of type

Character, and are set to some of the more common ASCII control characters. Character values are described in Strings and Characters.

Note that raw values are not the same as associated values. Raw values are set to prepopulated values when you first define the enumeration in your code, like the three ASCII codes above. The raw value for a particular enumeration member is always the same. Associated values are set when you create a new constant or variable based on one of the enumeration’s members, and can be different each time you do so.

Raw values can be strings, characters, or any of the integer or floating-point number types. Each raw value must be unique within its enumeration declaration. When integers are used for raw values, they auto-increment if no value is specified for some of the enumeration members.

The enumeration below is a refinement of the earlier Planet enumeration, with raw integer values to represent each planet’s order from the sun:

enum Planet: Int {

case Mercury = 1, Venus, Earth, Mars, Jupiter, Saturn, Uranus, Neptune

}

Auto-incrementation means that Planet.Venus has a raw value of 2, and so on.

Access the raw value of an enumeration member with its toRaw method:

let earthsOrder = Planet.Earth.toRaw()

// earthsOrder is 3

Use an enumeration’s fromRaw method to try to find an enumeration member with a particular raw value. This example identifies Uranus from its raw value of 7:

let possiblePlanet = Planet.fromRaw(7)

// possiblePlanet is of type Planet? and equals Planet.Uranus

Not all possible Int values will find a matching planet, however. Because of this, the fromRaw method returns an optional enumeration member. In the example above,

possiblePlanet is of type Planet?, or “optional Planet.”

If you try to find a Planet with a position of 9, the optional Planet value returned by fromRaw will be nil:

let positionToFind = 9

if let somePlanet = Planet.fromRaw(positionToFind) {