The_Swift_Programming_Language

Linking Multiple Levels of Chaining

You can link together multiple levels of optional chaining to drill down to properties, methods, and subscripts deeper within a model. However, multiple levels of optional chaining do not add more levels of optionality to the returned value.

To put it another way:

If the type you are trying to retrieve is not optional, it will become optional because of the optional chaining.

If the type you are trying to retrieve is already optional, it will not become more optional because of the chaining.

Therefore:

If you try to retrieve an Int value through optional chaining, an Int? is always returned, no matter how many levels of chaining are used.

Similarly, if you try to retrieve an Int? value through optional chaining, an Int? is always returned, no matter how many levels of chaining are used.

The example below tries to access the street property of the address property of the residence property of john. There are two levels of optional chaining in use here, to chain through the residence and address properties, both of which are of optional type:

The value of john.residence currently contains a valid Residence instance. However, the value

of john.residence.address is currently nil. Because of this, the call to john.residence?.address?.street

fails.

Note that in the example above, you are trying to retrieve the value of the street property. The type of this property is String?. The return value of john.residence?.address?.street is therefore also String?, even though two levels of optional chaining are applied in addition to the underlying optional type of the property.

If you set an actual Address instance as the value for john.street.address, and set an an

actual value for the address’s street property, you can access the value of property through the multi-level optional chaining:

/ prints "John's street name is Laurel Street."

Note the use of an exclamation mark during the assignment of an address instance to john.residence.address. The john.residence property has an optional type, and so you need to unwrap its actual value with an exclamation mark before accessing the residence’s address property.

Chaining on Methods With Optional Return Values

The previous example shows how to retrieve the value of a property of optional type through optional chaining. You can also use optional chaining to call a method that returns a value of optional type, and to chain on that method’s return value if needed.

The example below calls the Address class’s buildingIdentifier method through optional chaining. This method returns a value of type String?. As described above, the ultimate return type of this method call after optional chaining is also String?:

If you want to perform further optional chaining on this method’s return value, place the optional chaining question mark after the method’s parentheses:

1 if let upper = john.residence?.address?.buildingIdentifier()?.uppercaseString {

Type Casting

Type casting is a way to check the type of an instance, and/or to treat that instance as if it is a different superclass or subclass from somewhere else in its own class hierarchy.

Type casting in Swift is implemented with the is and as operators. These two operators provide a simple and expressive way to check the type of a value or cast a value to a different type.

You can also use type casting to check whether a type conforms to a protocol, as described in Checking for Protocol Conformance.

Defining a Class Hierarchy for Type Casting

You can use type casting with a hierarchy of classes and subclasses to check the type of a particular class instance and to cast that instance to another class within the same hierarchy. The three code snippets below define a hierarchy of classes and an array containing instances of those classes, for use in an example of type casting.

The first snippet defines a new base class called MediaItem. This class provides basic functionality for any kind of item that appears in a digital media library. Specifically, it declares a name property of type String, and an init name initializer. (It is assumed that all media items, including all movies and songs, will have a name.)

The next snippet defines two subclasses of MediaItem. The first subclass, Movie, encapsulates additional information about a movie or film. It adds a director property on top of the base MediaItem class, with a corresponding initializer. The second subclass, Song, adds an artist property and initializer on top of the base class:

3init(name: String, director: String) {

4self.director = director

5super.init(name: name)

6}

7 }

8

9 class Song: MediaItem { var artist: String

init(name: String, artist: String) { self.artist = artist super.init(name: name)

}

The final snippet creates a constant array called library, which contains two Movie instances and three Song instances. The type of the library array is inferred by initializing it with the contents of an array literal. Swift’s type checker is able to deduce that Movie and have a common superclass of MediaItem, and so it infers a type of MediaItem[] for the array:

The items stored in library are still Movie and Song instances behind the scenes. However, if you iterate over the contents of this array, the items you receive back are typed as MediaItem, and not as Movie or Song. In order to work with them as their native type, you need to check their type, or downcast them to a different type, as described below.

Checking Type

Because this array is known to contain only Movie instances, you can downcast and unwrap directly to a non-optional Movie with the forced version of the type cast operator (as):

For an even shorter form of this loop, downcast the someObjects array to a type of Movie[] instead of downcasting each item:

Any

Here’s an example of using Any to work with a mix of different types, including nonclass types. The example creates an array called things, which can store values of type

Any:

1 var things = Any[]()

2

The things array contains two Int values, two Double values, a String value, a tuple of type (Double, Double), and the movie “Ghostbusters”, directed by Ivan Reitman.

You can use the is and as operators in a switch statement’s cases to discover the specific type of a constant or variable that is known only to be of type Any or AnyObject. The example below iterates over the items in the things array and queries the type of each item with a switch statement. Several of the switch statement’s cases bind their matched value to a constant of the specified type to enable its value to be printed:

1 for thing in things {

2switch thing {

3case 0 as Int:

4println("zero as an Int")

5case 0 as Double:

6println("zero as a Double")

7case let someInt as Int:

8println("an integer value of \(someInt)")