Integers

You have at your disposal various flavors of signed and unsigned integer types, each conveniently having a self-explanatory name: Uint8 stands for “unsigned 8-bit integer,” Int32 for “signed 32-bit integer,” for example. Unless you need a specific size for your integer data, most of the time it is prudent to use the Int and UInt type aliases, which have the same size as the platform’s native word. You can find the valid range for any integer type by calling its min and max properties—for example, let maxInt = Int.max.

When you work with integer literals you can use decimal, binary, octal, or hexadecimal notation, as Listing 19-2 demonstrates. All notations, except the decimal one, require a prefix: 0b for binary, 0o for octal, and 0x for hexadecimal.

Listing 19-2. Integer Literals in Different Notations

// Representations of the number 42 in different notations:
let decimalInt = 42              // no prefix required
let binaryInt = 0b101010         // uses the 0b prefix
let octalInt = 0o52              // uses the 0o prefix
let hexadecimalInt = 0x2A        // uses the 0x prefix

Floating-Point Types

With floating-point values you have a choice between Double, which takes 64 bits, and Float, which takes 32 bits. It is worth noting that as with a lot of things in Swift, you are expected to be explicit:

• A floating-point literal will be inferred to be of type Double, unless you explicitly cast it to Float.

• You can’t omit the zero in a floating-point literal. If you do, the compiler issues an error: .5 is not a valid floating point literal; it must be written '0.5'.

• You can’t mix numbers of different types in mathematical operations: Swift doesn’t do type coercion behind the scenes. This applies to all numeric types.

Listing 19-3 illustrates these points with a few examples.

Listing 19-3. You Need to Be Explicit with Swift Types

// Using .5 instead of 0.5 generates a compiler error:
let doubleNumber = 0.5

// floatNumber is inferred to be of type Double by default,
// unless you explicitly cast it to Float:
let floatNumber = 0.2 as Float

// This line does not compile,
// unless you explicitly convert floatNumber to Double:
let difference = doubleNumber - Double(floatNumber)

Booleans

The Boolean type in Swift is named Bool and the constant values it takes are true and false, just as in ActionScript. Unlike in ActionScript, however, other types can’t masquerade as Booleans—all in the name of being explicit, as we saw with the numeric types above. For example, the if statement in Listing 19-4 will not compile: the literal Int value provided in place of the condition will not be automatically coerced to Bool.

Listing 19-4. If Statements Take Only Bool Conditions

if 1 {
    print("Gotcha!")
}
// error: type 'Int' does not conform to protocol 'BooleanType'

Characters

Swift has a special type, called Character, which represents a single human-readable symbol. You can initialize a Character with a literal symbol in double quotes. Note, however, that such literals are of type String. So, in order to create a Character instance, you need to either provide a type explicitly or type cast the literal, as the example in Listing 19-5 shows.

Listing 19-5. Creating and Initializing a Character

There are a couple of details worth noting about Character instances in Swift:

• They don’t always take the same amount of memory.

• The same symbol can be represented in more than one way behind the scenes.

Why is that? Characters in Swift are Unicode-compliant and are represented by Extended Grapheme Clusters. These are clusters of Unicode codes, called Unicode Scalars, each of which stands for a character or for a character modifier. When you want to output a letter with the umlaut modifier, for example ä, you have a couple of options for how it will be stored in memory: it can be represented by a single Unicode Scalar that stands for a with umlaut (U+E4) or by a combination of the code for a (U+61) and the code for umlaut (U+308). Listing 19-6 shows how you can explicitly initialize a Character with an Extended Grapheme Cluster.

Listing 19-6. Initializing Characters with Extended Grapheme Clusters

let aWithUmlaut : Character = "u{E4}"
print(aWithUmlaut)
// output: ä

let aWithUmlautModifier : Character = "u{61}u{308}"
print(aWithUmlautModifier)
// output: ä

These two facts (characters’ sizes in memory can vary, and there can be more than one way of encoding the same symbol) are very important and have the following implications:

• When you compare two characters for equality, using the == or the != operator, the comparison is not done on the Unicode Scalars that they store but on the symbols that the Unicode Scalars result in. In other words, the two constants in Listing 19-6, aWithUmlaut and aWithUmlautModifier, will be considered equal, although they look different in memory.

• Finding out the length of a character array or a string is not a matter of dividing the number of bytes in the array or string by the size of a character. Instead an iteration is done over the whole array or string to find out and add up the variable sizes of its characters.

• The characters in a string can’t be indexed using numbers. That is, you can’t do myString[0] or myString.charAt(0) to get to the first character of the string. Instead, you need to iterate over the characters from the start or from the end of the string to get to the one you need to access.

Strings

Strings in Swift consist of zero or more Unicode-compliant characters. In the next subsection we will see how strings are instantiated, initialized, and modified and will mention some pitfalls it is a good idea to be aware of.

Initializing Strings

You can use a string literal enclosed in double quotes, or you can provide an array of Character instances, in order to initialize a String (see Listing 19-7).

Listing 19-7. Ways of Creating and Initializing a String

You can also use combinations of other String and Character variables or constants to create a new String. Listing 19-8 uses the String and Character constants from the previous example to show you a couple of different ways of concatenating strings and characters: using the + or the += operators and the append method of the String class.

Listing 19-8. Concatenating Strings

Note that helloDialog in the listing is declared as a variable, rather than a constant. This allows you to modify both its length and its contents.

You can compare strings with the equality (==) and the inequality (!=) operator or by using one of the flavors of the String class compare method. Bear in mind that string comparison is a potentially resource-heavy operation, as we discussed earlier in the section “Characters.”

The characters method of the String class gives you access to the characters of the String as an array. Listing 19-9 shows a situation you might find a bit surprising: you can call methods even on literals.

Listing 19-9. Enumerating the Characters in a String

for ch in "Strange syntax or what?!".characters {
    print(ch)
}

// output:
//S
//t
//r
//a
//n
//g
//e
//
//s
//y
//n
//t
//a
//x
//
//o
//r
//
//w
//h
//a
//t
//?
//!                                                                                            

// Get the UnicodeScalar for the symbol ä:
let aWithUmlautCode = UnicodeScalar("ä")

// Next, get the UnicodeScalar integer value
// and store its hexadecimal representation into a String:
let hexCode = String(aWithUmlautCode.value, radix: 16)

// Last, print it out, inserting a new line (
) in the middle of the sentence:
print("The Unicode Scalar for (aWithUmlautCode) is (hexCode), 

       or (aWithUmlautCode.value) in decimal notation.")

// output:
// The Unicode Scalar for ä is e4,
//  or 228 in decimal notation.                                                                                            

What Is an Optional Type?

Let us start revealing what optionals are by looking at how Swift deals with “normal” types. Consider the example in Listing 19-11, which declares an integer and attempts to print it out.

Listing 19-11. Declaring a Variable of Non-optional Type

var age: Int
print("Person's age = (age)")

// This generates a compiler error:
// variable 'age' used before being initialized

These two lines generate a compiler error: error: variable 'age' used before being initialized. ActionScript defaults to automatically setting to null or to zero variables that you don’t explicitly initialize. Other languages are less merciful and will leave whatever junk is in the memory the variable in question happens to point at. If we had a penny for every hour we have spent in the past chasing a mysterious crash only to trace it down to an uninitialized variable. . . .⁴ This bitter experience makes us grateful that the Swift compiler can be of some help: catching situations like this at compile time is invaluable.

Next, let us see what happens if you try to initialize the age variable by assigning nil to it like we can do by assigning null in ActionScript (see Listing 19-12).

Listing 19-12. Initializing a Non-optional Type of Variable with Nil

var age: Int = nil
print("Person's age = (age)")
// error: nil cannot initialize specified type 'Int'

This change begets a different compiler error: error: nil cannot initialize specified type 'Int'. In Swift you can’t assign nil to just any variable. You need to explicitly tell the Swift compiler that this variable can take nil as a value. This could be useful if age was assigned the result of a third-party function, which may return nil, for example. Listing 19-13 shows you how to let the compiler know that the age variable can take nil.

Listing 19-13. Declaring a Variable of Optional Type and Initializing It with Nil

var age: Int? // the question mark tells the compiler that age can be nil
// This declaration also automatically initializes age with nil.

The question mark after the type signals to the Swift compiler that age can accept the nil value. In other words, having an actual integer value is optional: age can contain an integer or it can contain nil.

Note that the declaration above also initializes age with nil (i.e., it is shorthand for var age: Int? = nil). In other words, if you don’t provide a value for your optional variable, it is automatically set to nil.

Why Use Optionals?

Let us have another look at the age variable from the last two examples. Suppose you have a database query, which takes a person’s name and tells you how old they are (see Listing 19-14).

Listing 19-14. Assigning a Function Result to a Non-optional Variable

func getAgeFromName(name: String) -> Int {
    // query a database and return a result
}

var age: Int = getAgeFromName("John Smith")

An important question is: how do you deal with results for names that are not found in the database? Return 0? Return -1? Zero is less suitable of the two, as it is a valid age, but it may be your only choice if you were forced to use UInt, instead of Int. In either case you would need to add comments to document your intentions about which value should be interpreted as “no information about this person’s age.”

How about returning something that is neither Int nor UInt? Having getAgeFromName return nil to indicate missing information has two merits: it’s consistent and self-documented.⁵ Listing 19-15 shows this subtle change.

Listing 19-15. Assigning a Function Result to an Optional Variable

func getAgeFromName(name: String) -> Int? {
    // Query a database and return a result.
    // The result can now be nil.
}

let age: Int? = getAgeFromName("John Smith")
// If age contains any integer value, you know that “John Smith”
// was found in the database. A nil result on the other hand tells you
// that either the name was not found or age information was missing for it.

Note that in both listings you can omit the type from the declaration of age, as the compiler will infer it from the function result you assign to it:

let age = getAgeFromName("John Smith").

Unwrapping an Optional

Unwrapping is fancy speak for accessing the value of an optional variable or constant. For this to make complete sense it might be a good idea to peek behind the scenes first. In Swift Optional is actually a separate type, which looks like Listing 19-16.

Listing 19-16. The Optional Type in Swift

public enum Optional<Wrapped> : _Reflectable, NilLiteralConvertible {
    case None
    case Some(Wrapped)

    // Initializers and methods follow...
}

Unless you skip to Chapter 22 , some of the syntax above, namely, enum and <Wrapped>, may look unfamiliar. For the moment you can think of the code in Listing 19-16 like this: it declares a type, named Optional, which can have two states: None, which means “no value” and Some, which means “some value of type Wrapped.” Here Wrapped is not an actual type but a type placeholder. You can declare an Optional variable that can hold an Int value: Optional<Int> or a String value: Optional<String> or whatever value type you decide to plug in place of Wrapped.

The ? suffix after an optional-type declaration is syntactic shortcut for Optional<YourTypeHere>, so the following two declarations in Listing 19-17 are the same.

Listing 19-17. Two Different Ways of Declaring an Optional Variable

// These two lines declare the same thing:
var age: Int?
var age: Optional<Int>

So when you declare an optional Int variable, this effectively means you are not declaring an Int that might be nil but an Optional that may or may not contain an Int value. Getting this value out of the Optional variable is called unwrapping.

You can access the value of an Optional in one of two ways:

• by assigning its value to a temporary constant or variable, called optional binding; and

• by using forced unwrapping.

You can also use a third way, which requires a slightly different kind of optional, called implicitly unwrapped optional. We will have a brief look at each of these choices in the next few subsections.

Optional Binding

You bind an optional’s value by assigning it to a temporary constant or a variable. This allows you to perform a check for whether a value is available or whether the optional contains nil.

Listing 19-18 shows an example that extracts the value of the optional age variable into the constant tempAge. The code following the if statement will only be run if a non-nil value is assigned to tempAge.

Listing 19-18. Optional Binding

var age: Int? = 64
if let tempAge = age {
    // Use tempAge
}

Forced Unwrapping

Force-unwrapping an optional is a bit dramatic. First, you need to be confident that what you unwrap has a non-nil value. Second, you use the exclamation mark suffix to do the unwrapping (see Listing 19-19). What could declare confidence better than that?

Listing 19-19. Forced Unwrapping of an Optional

var sureAge = age! // The exclamation mark unwraps age's value

This line effectively says “I am sure that there is a non-nil value inside this variable and am not afraid to use it.”. The consequence of overconfidence is a runtime error:

fatal error: unexpectedly found nil while unwrapping an Optional value.

Implicitly Unwrapped Optionals

Instead of using the exclamation mark to unwrap an optional every time you need its value, you can declare an optional variable in a way that makes sure its value is unwrapped when you access it. Such a variable is called implicitly unwrapped and you can create one by adding an exclamation mark after its type (see Listing 19-20).

Listing 19-20. Declaring an Implicitly Unwrapped Optional

var implicitlyUnwrappedAge: Int! = 64

var implicitlyUnwrappedAge: ImplicitlyUnwrappedOptional<Int> = 64                    

As is the case with optionals, if you do not provide an initial value when you declare an implicitly unwrapped optional, it is automatically initialized with nil. You can think of an implicitly unwrapped optional as a hybrid between an optional and a non-optional variable or constant: it has the option of containing nil, but can also be used as your usual variable or constant without the need to unwrap its value every time (Listing 19-21).

Listing 19-21. Accessing the Value of an Implicitly Unwrapped Optional

let sureAge = implicitlyUnwrappedAge // no need for an exclamation mark

Using implicitly unwrapped optionals has its pros and cons. On the one hand, it unclutters your code from exclamation marks. On the other hand, a variable which contains nil when it shouldn’t makes your code more likely to break and, at the same time, makes it less obvious why it broke. For instance, if we did not initialize implicitlyUnwrappedAge and then tried to print it out, this would result in a runtime error (Listing 19-22).

Listing 19-22. Accessing an Implicitly Unwrapped Optional, Which Has Been Initialized with Nil

var implicitlyUnwrappedAge: Int! // The variable is is initialized with nil.
print(implicitlyUnwrappedAge) // This results in a runtime error.

Optional Chaining

Optional chaining saves you the need to check if an optional variable or constant is nil before you access its properties or call one of its methods. What you get as a result of that access, instead of a slap on the wrist, is another optional value.

Let us illustrate this with an example. The code in Listing 19-23 declares two classes: Person and PersonalInformation. PersonalInformation contains a single property: age of type Int. Person contains a single property too, personalInfo, of type PersonalInformation?, which may optionally contain an instance of PersonalInformation or may contain nil.

Listing 19-23. Declaring a Class with an Optional Property

class PersonalInformation {
    var age = 20
}

class Person {
    var personalInfo: PersonalInformation?
}

In Listing 19-24 the first line instantiates cookieMonster of type Person. Because no initial value is given to its property personalInfo, it is automatically assigned nil. So what’s going on on the second line, where cookieMonster.personalInfo? is accessed and why doesn’t it result in an exception?

Listing 19-24. Accessing a Property Through Optional Chaining

var cookieMonster = Person()
var monstersAge = cookieMonster.personalInfo?.age
print(monstersAge)

// output: nil                                                

Accessing a property (or calling a method or subscript) on an optional variable that may be nil and getting away with it is what optional chaining affords you. The way the compiler does it is: if cookieMonster.personalInfo? is nil, then the result of cookieMonster.personalInfo?.age is inferred to be an optional, which contains nil. The compiler then infers the same type for monstersAge, which gets assigned that result.

Using the is Operator

You check if an object is of a certain type with the is operator (see Listing 19-25). It takes an instance and a type and returns true if the instance is of that type or descends from it, false otherwise.

Listing 19-25. Using the is Operator for Type Checking

var randomInt = 42
var amIString = randomInt is String // returns false
var amIInt = randomInt is Int // returns true

Type Queries

You can query an instance’s runtime type with obj.dynamicType, as in Listing 19-26.

Listing 19-26. Querying an Object’s Type

var instanceOfInt = 66
print("(instanceOfInt.dynamicType)") // prints Int

You can obtain the type of a class or a protocol as a value with the postfix expression self. Listing 19-27 shows you a couple of examples.

Listing 19-27. Querying the Type of a Class and a Protocol

print("(MyClass.self)") // prints MyClass
print("(MyProtocol.self)") // prints MyProtocol                                                                                                        

Container Types: Array, Set, Dictionary

The container types in Swift are implemented as generic classes. We will go over generics in Chapter 22 in detail. For now, you can think of a generic class like this: Array<String> stands for “an array of String items and nothing else” and Array<Int> stands for “an array of Int items and nothing else.” By “nothing else” here we mean that an Array, or a Set in Swift contain items of the same type: you can have an array of Strings or an array of Ints, but you can’t have an array that contains a String and an Int.

var theThreeMusketeers = [String]()

var theThreeMusketeers = [String](count: 3, repeatedValue: "")

var theThreeMusketeers = ["Athos", "Porthos", "Aramis"]
var extraMusketeers = ["D'Artagnan"]

var theFourMusketeers = theThreeMusketeers + extraMusketeers

for musketeer in theFourMusketeers {
    print("Musketeer's name: (musketeer)")
}

for (index, value) in theFourMusketeers.enumerate() {
    print("(index + 1). Musketeer's name: (value)")
}

var theThreeMusketeers = [String]()

// adds "Athos" to the end of the array:
theThreeMusketeers.append("Athos")
// the array contains [“Athos”]

// concatenates theThreeMusketeers with the array ["Porthos", "Aramis"]
theThreeMusketeers += ["Porthos", "Aramis"]
// the array now contains ["Athos", "Porthos", "Aramis"]

// creates an array of four Strings and initializes them with an empty string:
var theFourMusketeers = [String](count: 4, repeatedValue: "")
// the array contains ["", "", "", ""]

// replaces the first string in the array with "D'Artagnan":
theFourMusketeers[0] = "D'Artagnan"
// the array now contains ["D'Artagnan", "", "", ""]

// replaces the range of items 1, 2 and 3 with new values:
theFourMusketeers[1...3] = ["Athos", "Porthos", "Aramis"]
// the array now contains ["D'Artagnan”, "Athos", "Porthos", "Aramis"]

var fireflyCharacters: Set<String> = ["Mal", "Inara"]

var fireflyCharacters: Set<String> = ["Mal", "Inara"]
var serenityCharacters: Set<String> = ["Mal", "Inara", "Kaylee", "Simon"]

var commonCharacters = fireflyCharacters.intersect(serenityCharacters)
// commonCharacters contains ["Mal", "Inara"]

// creates an empty dictionary with keys of type String and Double values:
var macOsXVersions = [String: Double]()

// creates a dictionary with keys of type String and values of type Double:
var macOsXVersions = ["Cheetah" : 10.0, "Puma" : 10.1, "Jaguar" : 10.2]

for (versionName, versionCode) in macOsXVersions {
    print("(versionName) (versionCode)")
}

// Iterating through the keys only
for versionName in macOsXVersions.keys {
    print("Mac OS X version name: (versionName)")
}

// Iterating through the values only
for versionCode in macOsXVersions.values {
    print("Mac OS X version code: (versionCode)")
}

macOsXVersions["Panther"] = 0.0
// macOsXVersions now contains
// ["Cheetah" : 10.0, "Puma" : 10.1, "Jaguar" : 10.2, "Panther" : 0.0]

// You can update a value using subscript
macOsXVersions["Panther"] = 0.3
// macOsXVersions now contains
// ["Cheetah" : 10.0, "Puma" : 10.1, "Jaguar" : 10.2, "Panther" : 0.3]

// ... or you can call the updateValue(_:forKey:) method
if let oldValue = macOsXVersions.updateValue(10.3, forKey: "Panther") {
    print("The old value for Mac OS X 10.3 was (oldValue).")
}
// macOsXVersions now contains
// ["Cheetah" : 10.0, "Puma" : 10.1, "Jaguar" : 10.2, "Panther" : 10.3]

macOsXVersions[“Panther”] = nil
// macOsXVersions now contains
// ["Cheetah" : 10.0, "Puma" : 10.1, "Jaguar" : 10.2]                                                                  

Tuples

Tuples are useful for temporarily keeping a group of values together. “Temporarily” here means as a way of returning multiple values from a function, for example. To keep values together that will have a longer lifespan than that, you would normally be better off keeping them in a class or a structure.

You define a tuple as a comma-separated list of types, enclosed in parentheses. Listing 19-49 declares a tuple, weatherStats, which contains two values: wind speed in miles per hour and wind direction. This means that the tuple’s type is (Int, String).

Listing 19-49. Defining a Tuple

let weatherStats = (7, "North") // Tuple of type (Int, String)

You can read the values in a tuple by assigning them to a temporary constant. The next few examples show you how to do that and how to read or ignore values selectively.

The code in Listing 19-50 assigns the values of the tuple we just declared to two temporary constants: windSpeed and windDirection.

Listing 19-50. Accessing Individual Values in a Tuple

let (windSpeedMph, windDirection) = weatherStats
print("wind speed: (windSpeedMph) mph, direction: (windDirection)")

You don’t have to define constants for all of the tuple’s values if you are not interested in all of them. Use underscore to ignore values that you don’t need to access (Listing 19-51).

Listing 19-51. Selectively Accessing Individual Values in a Tuple

let (_, windDirection) = weatherStats
print("wind direction: (windDirection)")

Each of the tuple’s values has an index which you can access by putting a dot, followed by the index’s number after the name of the tuple. Calling weatherStats.0 gives you access to the first member of the tuple, weatherStats.1—to the second, and so on, as shown in Listing 19-52.

Listing 19-52. Using an Index to Access a Tuple’s Member

print("wind speed: (weatherStats.0) mph, direction: (weatherStats.1)")

As an alternative to using indices, you can name each tuple member and use its name to access it. Listing 19-53 defines the tuple weatherStats with two named elements—windSpeed and windDirection—and then accesses their values as weatherStats.windSpeed and weatherStats.windDirection.

Listing 19-53. Using Names for Tuple Elements

let weatherStats = (windSpeed: 7, windDirection: "North")
print("wind speed: (weatherStats.windSpeed) mph,
direction: (weatherStats.windDirection)")

The example in Listing 19-54 shows you a function, which returns a tuple.

Listing 19-54. A Function, Which Returns a Tuple as a Result

func getWeatherStats() -> (Int, String) {
    return (7, "North")
}

The code in Listing 19-55 shows the ActionScript analogue of the tuple we defined in Listing 19-53.

Listing 19-55. Using Dynamic Objects in ActionScript Is Close in Syntax to Swift’s Tuples

// ActionScript code:
var weatherStats : Object = {windSpeed: 7, windDirection: "North"};
trace("wind speed: " + weatherStats.windSpeed + "mph,
direction: " + weatherStats.windDirection);

Function Types

In Swift the type of a function is its signature. Listing 19-56, for example, declares a function of type (String) -> String. This means that the function takes one argument of type String and returns a String result.

Listing 19-56. Declaring a Function of Type (String) -> String

func capitalize(str: String) -> String {
    return str.uppercaseString
}

When you know a function’s type, you can assign it to a variable, as shown in Listing 19-57. You define the type of the variable as ( functionArguments ) -> functionReturnType .

Listing 19-57. Assigning a Function to a Variable

// the next line declares a variable
// and assigns a function of type (String)->String to it:
let capitalizeFunction: (String) -> String = capitalize

// accessing the variable and giving it an argument
// results in the function being called:
print("capitalization: (capitalizeFunction("fallaciloquence"))")

You can also pass a function type as an argument to another function. Again, you use the function’s signature as the type of the argument, so capitalizationFunction’s type in Listing 19-58 is (String) -> String.

Listing 19-58. Using a Function Type as a Parameter to Another Function

// This function takes another function as an argument:
func printCapitalizedString(capitalizationFunction: (String) -> String,
                                str: String) {
    let capitalizeFunction: (String) -> String = capitalize
    print("capitalization: (capitalizeFunction("fallaciloquence"))")
}

Or, you can have a function that returns another function as a result. A bit weird, but only syntax-wise. The first arrow in Listing 19-59 is put before the return type of getCapitalizationFunction. The second arrow is part of its return type: (String) -> String.

Listing 19-59. Returning a Function Type as a Result of Another Function

func getCapitalizationFunction() -> (String) -> String {
    return capitalizeFunction
}

Type Aliases

Finally, you can name any existing type on a whim using the typealias keyword. Say you are writing an app that takes payments and want a more meaningful name for the type you would use to store prices. Using Price as an alias to UInt makes it obvious not only that it allows only non-negative values but also why (Listing 19-60).

Listing 19-60. Defining a Type Alias

public typealias Price = UInt