Computed Properties

In real life, your main use of computed variables will nearly always be as instance properties. Here are some common ways in which computed properties are useful:

Façade for a longer expression

When a value can be readily calculated or obtained each time it is needed, it often makes for simpler syntax to express it as a read-only computed variable, which effectively acts as a shorthand for a longer expression. Here’s an example from my own code:

var mp : MPMusicPlayerController {
    MPMusicPlayerController.systemMusicPlayer
}
var nowPlayingItem : MPMediaItem? {
    self.mp.nowPlayingItem
}

No work is saved by these computed variables; each time we ask for self.nowPlayingItem, we are fetching MPMusicPlayerController.systemMusicPlayer.nowPlayingItem. Still, the clarity and convenience of the resulting code justifies the use of computed variables here.

Façade for an elaborate calculation

A computed variable getter can encapsulate multiple lines of code, in effect turning a method into a property. Here’s an example from my own code:

var authorOfItem : String? {
    guard let authorNodes =
        self.extensionElements(
            withXMLNamespace: "http://www.tidbits.com/dummy",
            elementName: "app_author_name")
        else {return nil}
    guard let authorNode = authorNodes.last as? FPExtensionNode
        else {return nil}
    return authorNode.stringValue
}

In that example, I’m diving into some parsed XML and extracting a value. I could have declared this as a method func authorOfItem() -> String?, but a method expresses a process, whereas a computed property characterizes it more intuitively as a thing.

Façade for storage

A computed variable can sit in front of one or more stored variables, acting as a gatekeeper on how those stored variables are set and fetched. This is comparable to an accessor method in Objective-C. Commonly, a public computed variable is backed by a private stored variable. The simplest possible storage façade would do no more than get and set the private stored variable directly:

private var _p : String = ""
var p : String {
    get {
        self._p
    }
    set {
        self._p = newValue
    }
}

That’s legal but pointless. A storage façade becomes useful when it does other things while getting or setting the stored variable. Here’s a more realistic example: a “clamped” setter. This is an Int property to which only values between 0 and 5 can be assigned; larger values are replaced by 5, and smaller values are replaced by 0:

private var _pp : Int = 0
var pp : Int {
    get {
        self._pp
    }
    set {
        self._pp = max(min(newValue,5),0)
    }
}

As the preceding examples demonstrate, a computed instance property getter or setter can refer to other instance members. That’s important, because in general the initializer for a stored property can’t do that. The reason it’s legal for a computed property is that the getter and setter functions won’t be called until the instance actually exists.

Property Wrappers

If we have several storage façade computed properties that effectively do the same thing, we’re going to end up with a lot of repeated code. Imagine implementing more than one Int property with a clamped setter, as in the preceding section. It would be nice to move the common functionality off into a single location. Starting in Swift 5.1, we can do that, using a property wrapper.

A property wrapper is declared as a type marked with the @propertyWrapper attribute, and must have a wrappedValue computed property. Here’s a property wrapper implementing the “clamped” pattern:

@propertyWrapper struct Clamped {
    private var _i : Int = 0
    var wrappedValue : Int {
        get {
            self._i
        }
        set {
            self._i = Swift.max(Swift.min(newValue,5),0)
        }
    }
}

The result is that we can declare a computed property marked with a custom attribute whose name is the same as that struct (@Clamped), with no getter or setter:

@Clamped var p : Int

Our property p doesn’t need to be initialized, because it’s a computed property. And it doesn’t need a getter or a setter, because the wrappedValue computed property of the Clamped struct supplies them! Behind the scenes, an actual Clamped instance has been created for us. When we set self.p to some value through assignment, the assignment passes through the Clamped instance’s wrappedValue setter, and the resulting clamped value is stored in the Clamped instance’s _i property. When we fetch the value of self.p, what we get is the value returned from the Clamped instance’s wrappedValue getter, which is the value stored in the Clamped instance’s _i property.

Thanks to our property wrapper, we have encapsulated this computed property pattern, which means we can now declare another @Clamped property which will behave in just the same way. It’s also nice that this pattern now has a name: the declaration @Clamped var tells us what the behavior of this computed property will be.

(Believe it or not, I created the Clamped example before discovering that the Swift language proposal for property wrappers uses the same example!)

There’s considerably more to know about property wrappers, but I’ll postpone further discussion to Chapter 5, after I’ve explained other language features that will help you appreciate their power and flexibility.

Singleton

Lazy initialization is often used to implement singleton. Singleton is a pattern where all code is able to get access to a single shared instance of a certain class:

class MyClass {
    static let sharedSingleton = MyClass()
}

Now other code can obtain a reference to MyClass’s singleton by saying MyClass.sharedSingleton. The singleton instance is not created until the first time other code says this; subsequently, no matter how many times other code may say this, the instance returned is always that same instance. (That is not what would happen if this were a computed read-only property whose getter calls MyClass() and returns that instance; do you see why?)

Lazy Initialization of Instance Properties

Why might you want an instance property to be lazy? One reason is obvious: the initial value might be expensive to generate, so you’d like to avoid generating it unless it is actually needed. But there’s another reason that turns out to be even more important: a lazy initializer can do things that a normal initializer can’t.

In particular, a lazy initializer can refer to the instance. A normal initializer can’t do that, because the instance doesn’t yet exist at the time that a normal initializer would need to run (we’re in the middle of creating the instance, so it isn’t ready yet). A lazy initializer, by contrast, is guaranteed not to run until some time after the instance has fully come into existence, so referring to the instance is fine. This code would be illegal if the arrow property weren’t declared lazy:

class MyView : UIView {
    lazy var arrow = self.arrowImage() // legal
    func arrowImage () -> UIImage {
        // ... big image-generating code goes here ...
    }
}

A very common idiom is to initialize a lazy instance property with a define-and-call anonymous function whose code can refer to self:

lazy var prog : UIProgressView = {
    let p = UIProgressView(progressViewStyle: .default)
    p.alpha = 0.7
    p.trackTintColor = UIColor.clear
    p.progressTintColor = UIColor.black
    p.frame =
        CGRect(x:0, y:0, width:self.view.bounds.size.width, height:20) // legal
    p.progress = 1.0
    return p
}()

There’s no lazy let for instance properties, so you can’t readily make a lazy instance property read-only. That’s unfortunate, because there are some common situations that would benefit from such a feature.

Suppose we want to arm ourselves (self) with a helper property holding an instance of a Helper class that needs a reference back to self. We also want this one Helper instance to persist for the entire lifetime of self. We can enforce that rule by making helper a let property and initializing it in its declaration. But we can’t pass self into the Helper instance at that point, because we can’t refer to self in the property declaration.

We can solve the problem by declaring the helper property lazy, but then it has to be a var property, meaning that, in theory, other code can come along and replace this Helper with another. Of course, we’ll try not to let that happen; but the point is that the expression lazy var fails to express and enforce this policy as an unbreakable contract. (It may be possible to work around the issue by making helper a computed property acting as a façade on storage — and we can even encapsulate that pattern as a property wrapper — but even then we can enforce our policy only at runtime, not at compile time the way let does.)

Bool

The Bool object type (a struct) has only two values, commonly regarded as true and false (or yes and no). You can represent these values using the literal keywords true and false, and it is natural to think of a Bool value as being either true or false:

var selected : Bool = false

In that code, selected is a Bool variable initialized to false; it can subsequently be set to false or true, and to no other values. Because of its simple yes-or-no state, a Bool variable of this kind is often referred to as a flag.

Cocoa methods very often expect a Bool parameter or return a Bool value. For example, when your app launches, Cocoa calls a method in your code declared like this:

func application(_ application: UIApplication,
    didFinishLaunchingWithOptions
    launchOptions: [UIApplication.LaunchOptionsKey : Any]?)
    -> Bool {

You can do anything you like in that method; often, you will do nothing. But you must return a Bool! And in real life, that Bool will probably be true. A minimal implementation looks like this:

func application(_ application: UIApplication,
    didFinishLaunchingWithOptions
    launchOptions: [UIApplication.LaunchOptionsKey : Any]?)
    -> Bool {
        return true
}

A Bool is useful in conditions; as I’ll explain in Chapter 5, when you say if something, the something is the condition, and is a Bool or an expression that evaluates to a Bool. When you compare two values using the equality comparison operator ==, the result is a Bool — true if they are equal to each other, false if they are not:

if meaningOfLife == 42 { // ...

(I’ll talk more about equality comparison in a moment, when we come to discuss types that can be compared, such as Int and String.)

When preparing a condition, you will sometimes find that it enhances clarity to store the Bool value in a variable beforehand:

let comp = self.traitCollection.horizontalSizeClass == .compact
if comp { // ...

Observe that, when employing that idiom, we use the Bool variable comp directly as the condition. There is no need to test explicitly whether a Bool equals true or false; the conditional expression itself is already testing that. It is pointless to say if comp == true, because if comp already means “if comp is true.”

Since a Bool can be used as a condition, a call to a function that returns a Bool can be used as a condition. Here’s an example from my own code. I’ve declared a function that returns a Bool to say whether the cards the user has selected constitute a correct answer to the puzzle:

func isCorrect(_ cells:[CardCell]) -> Bool { // ...

I can then use a call to isCorrect as a condition:

if self.isCorrect(cellsToTest) { // ...

Unlike many computer languages, nothing else in Swift is implicitly coerced to or treated as a Bool. In C, for example, a boolean is actually a number, and 0 is false. But in Swift, nothing is false but false, and nothing is true but true.

The type name, Bool, comes from the English mathematician George Boole; Boolean algebra provides operations on logical values. Bool values are subject to these same operations:

! (not)

The ! unary operator reverses the truth value of the Bool to which it is applied as a prefix. If ok is true, !ok is false — and vice versa.

&& (logical-and)

Returns true only if both operands are true; otherwise, returns false. If the first operand is false, the second operand is not even evaluated (avoiding possible side effects).

|| (logical-or)

Returns true if either operand is true; otherwise, returns false. If the first operand is true, the second operand is not even evaluated (avoiding possible side effects).

If a logical operation is complicated or elaborate, parentheses around subexpressions can help clarify both the logic and the order of operations.

A common situation is that we have a Bool stored in a var variable somewhere, and we want to reverse its value — that is, make it true if it is false, and false if it is true. The ! operator solves the problem; we fetch the variable’s value, reverse it with !, and assign the result back into the variable:

v.isUserInteractionEnabled = !v.isUserInteractionEnabled

That, however, is cumbersome and error-prone. Starting in Swift 4.2, there’s a simpler way — call the toggle method on the Bool variable:

v.isUserInteractionEnabled.toggle()

Numbers

The main numeric types are Int and Double — meaning that, left to your own devices, those are the types you’ll generally use. Other numeric types exist mostly for compatibility with the C and Objective-C APIs that Swift needs to be able to talk to when you’re programming iOS.

let i = 10
let x = Double(i)
print(x) // 10.0, a Double
let y = 3.8
let j = Int(y)
print(j) // 3, an Int

let d : Double = 10

let i = 10
let d : Double = i // compile error

let i = 10
let d : Double = Double(i)

let x = 10/3.0
print(x) // 3.33333333333333

let i = 10
let n = 3.0
let x = i / n // compile error; you need to say Double(i)

Other numeric types

If you were using Swift in some isolated, abstract world, you could probably do all necessary arithmetic with Int and Double alone. But when you’re programming iOS, you encounter Cocoa, which is full of other numeric types; and Swift has types that match every one of them. In addition to Int, there are signed integer types of various sizes — Int8, Int16, Int32, Int64 — plus the unsigned integer type UInt along with UInt8, UInt16, UInt32, and UInt64. In addition to Double, there is the lower-precision Float (32-bit storage, about 6 or 7 decimal places of precision), the even lower-precision Float16 (new in Swift 5.3), and the extended-precision Float80 — plus, in the Core Graphics framework, CGFloat (whose size can be that of Float or Double, depending on the bitness of the architecture).

You may also encounter a C numeric type when trying to interface with a C API. These types, as far as Swift is concerned, are just type aliases, meaning that they are alternate names for another type: a CDouble (corresponding to C’s double) is just a Double by another name, a CLong (C’s long) is an Int, and so on. Many other numeric type aliases will arise in various Cocoa frameworks; for example, TimeInterval (Objective-C NSTimeInterval) is merely a type alias for Double.

Recall that you can’t assign, pass, or combine values of different numeric types using variables; you have to coerce those values explicitly to the correct type. But now it turns out that you’re being flooded by Cocoa with numeric values of many types! Cocoa will often hand you a numeric value that is neither an Int nor a Double — and you won’t necessarily realize this, until the compiler stops you dead in your tracks for some sort of type mismatch. You must then figure out what you’ve done wrong and coerce everything to the same type.

Here’s a typical example from one of my apps. A slider in the interface is a UISlider, whose minimumValue and maximumValue are Floats. In this code, s is a UISlider, g is a UIGestureRecognizer, and we’re trying to use the gesture recognizer to move the slider’s “thumb” to wherever the user tapped within the slider:

let pt = g.location(in:s) 
let percentage = pt.x / s.bounds.size.width 
let delta = percentage * (s.maximumValue - s.minimumValue) // compile error 

That won’t compile. Here’s why:

pt is a CGPoint, and therefore pt.x is a CGFloat.

Luckily, s.bounds.size.width is also a CGFloat, so the second line compiles; percentage is now inferred to be a CGFloat.

We now try to combine percentage with s.maximumValue and s.minimumValue — and they are Floats, not CGFloats. That’s a compile error.

This sort of thing is not an issue in C or Objective-C, where there is implicit coercion; but in Swift a CGFloat can’t be combined with Floats. We must coerce explicitly:

let delta = Float(percentage) * (s.maximumValue - s.minimumValue)

The good news here is that if you can get enough of your code to compile, Xcode’s Quick Help feature will tell you what type Swift has inferred for a variable (Figure 3-1). This can assist you in tracking down your issues with numeric types.

Figure 3-1. Quick Help displays a variable’s type

Another problem is that not every numeric value can be coerced to a numeric value of a different type. In particular, integers of various sizes can be out of range with respect to integer types of other sizes. For example, Int8.max is 127, so attempting to assign a literal 128 or larger to an Int8 variable is illegal. Fortunately, the compiler will stop you in that case, because it knows what the literal is. But now consider coercing a variable value of a larger integer type to an Int8:

let i : Int16 = 128
let ii = Int8(i)

That code is legal — and will crash at runtime. One solution is to call the numeric exactly: initializer; this is a failable initializer — meaning, as I’ll explain in Chapter 4, that you won’t crash, but you’ll have to add code to test whether the coercion succeeded (and you’ll understand what the test would be when you’ve read the discussion of Optionals later in this chapter):

let i : Int16 = 128
let ii = Int8(exactly:i)
if // ... test to learn whether ii holds a real Int8

Yet another solution is to call the clamping: initializer; it always succeeds, because an out of range value is forced to fall within range:

let i : Int16 = 128
let ii = Int8(clamping:i) // 127

(There is also a truncatingIfNeeded: initializer, but you probably won’t need to know about it unless you are deliberately manipulating integers as binary, so I won’t describe it here.)

When a floating-point type, such as a Double, is coerced to an integer type, the stuff after the decimal point is thrown away first and then the coercion is attempted. Int8(127.9) succeeds, because 127 is in bounds.

let i = Int.max - 2
let j = i + 12/2 // crash

let i = Int.max - 2
let (j, over) = i.addingReportingOverflow(12/2)

var i = 1
i = i + 7

var i = 1
i += 7

let i = -7
let j = 6
print(abs(i)) // 7
print(max(i,j)) // 6

// pick a number from 1 to 10
let i = Int.random(in: 1...10)

let i:Int = 1
let i2:UInt8 = 2
let ok = i < i2 // true
let ok2 = i == i2 // false
let sum = i + i2 // error

let f = 0.1
var sum = 0.0
for _ in 0..<10 { sum += f }
let product = f * 10
let ok = sum == product // false

let ok2 = sum >= product.nextDown && sum <= product.nextUp // true

String

The String object type (a struct) represents text. The simplest way to represent a String value is with a literal, delimited by double quotes:

let greeting = "hello"

A Swift string is thoroughly modern; under the hood, it’s Unicode, and you can include any character (such as an emoji) directly in a string literal. If you don’t want to bother typing a Unicode character whose codepoint you know, use the notation u{...}, where what’s between the curly braces is up to eight hex digits:

let leftTripleArrow = "u{21DA}"

The backslash in that string representation is the escape character; it means, “I’m not really a backslash; I indicate that the next character gets special treatment.” Various nonprintable and ambiguous characters are entered as escaped characters; the most important are:

A Unix newline character

A tab character

"

A quotation mark (escaped to show that this is not the end of the string literal)

\

A backslash (escaped because a lone backslash is the escape character)

Escaped quotation marks and backslashes can quickly make your string literals ugly and illegible. The issue arises particularly in contexts such as regular expression patterns. For example, the pattern dd (a word consisting of two digits) must be written "\b\d\d\b". But you can omit the escape character before quotes and backslashes by surrounding your literal with one or more hash characters (#); these are all identical strings:

let pattold = "\b\d\d\b"
let pattnew = #"dd"# // same thing
let pattnew2 = ##"dd"## // same thing

That’s called a raw string literal. The downside is that if you want to use a backslash as an escape character in a raw string literal — for example, in order to indicate string interpolation — you must follow it with the same number of # characters you are using to surround your literal.

Starting in Swift 4, a string literal containing newline characters can be entered as multiple lines (rather than a single-line expression containing " " characters). This is called a multiline string literal. The rules are:

• The multiline string literal must be delimited by a triple of double quotes (""") at start and end.

• No material may follow the opening delimiter on the same line.

• No material other than whitespace may appear on the same line as the closing delimiter.

• The last implicit newline character before the closing delimiter is ignored.

• The indentation of the closing delimiter dictates the indentation of the lines of text, which must be indented at least as far as the closing delimiter (except for completely empty lines).

For example:

func f() {
    let s = """
    Line 1
        Line 2
    Line 3
    """
    // ...
}

In that code, the string s consists of three lines of text; lines 1 and 3 start with no whitespace; line 2 starts with four spaces; and there are two newline characters, namely after lines 1 and 2. To add a newline after line 3, you could enter a blank line, or write it as an escaped .

Quotation marks do not have to be escaped. A line ending with a backslash is joined with the following line. In this code, the string s consists of just two lines of text; the second line consists of four spaces followed by “Line 2 and this is still line 2”:

func f() {
    let s = """
    Line "1"
        Line 2 
    and this is still Line 2
    """
    // ...
}

(You can surround a multiline string literal with # characters, making a raw multiline string literal; but you are unlikely to do so.)

String interpolation permits you to embed any value that can be output with print inside a string literal as a string, even if it is not itself a string. The notation is escaped parentheses: (...):

let n = 5
let s = "You have (n) widgets."

Now s is the string "You have 5 widgets." The example is not very compelling, because we know what n is and could have typed 5 directly into our string; but imagine that we don’t know what n is! Moreover, the stuff in escaped parentheses doesn’t have to be the name of a variable; it can be almost any expression that evaluates as legal Swift:

let m = 4
let n = 5
let s = "You have (m + n) widgets."

String interpolation is legal inside a multiline string literal. It is also legal inside a string literal surrounded with # characters, but the backslash must be followed by the same number of # characters, to indicate that it is the escape character.

let s = "You have (n, roman:true) widgets"

To combine (concatenate) two strings, the simplest approach is to use the + operator:

let s = "hello"
let s2 = " world"
let greeting = s + s2

This convenient notation is possible because the + operator is overloaded: it does one thing when the operands are numbers (numeric addition) and another when the operands are strings (concatenation). As I’ll explain in Chapter 5, all operators can be overloaded, and you can overload them to operate in some appropriate way on your own types.

The + operator comes with a += assignment shortcut; naturally, the variable on the left side must have been declared with var:

var s = "hello"
let s2 = " world"
s += s2

As an alternative to +=, you can call the append(_:) instance method:

var s = "hello"
let s2 = " world"
s.append(s2)

Another way of concatenating strings is with the joined(separator:) method. You start with an array of strings to be concatenated, and hand it the string that is to be inserted between all of them:

let s = "hello"
let s2 = "world"
let space = " "
let greeting = [s,s2].joined(separator:space)

The comparison operators are also overloaded so that they work with String operands. Two String values are equal (==) if they are, in the natural sense of the words, the same text. A String is less than another if it is alphabetically prior.

Some additional convenient instance methods and properties are provided. isEmpty returns a Bool reporting whether this string is the empty string (""). hasPrefix(_:) and hasSuffix(_:) report whether this string starts or ends with another string; "hello".hasPrefix("he") is true. The uppercased and lowercased methods provide uppercase and lowercase versions of the original string.

Coercion between a String and an Int is possible. To make a string that represents an Int, it is sufficient to use string interpolation; alternatively, use a String initializer taking the Int:

let i = 7
let s = String(i) // "7"

Your string can also represent an Int in some other base; in the initializer, supply a radix: argument expressing the base:

let i = 31
let s = String(i, radix:16) // "1f"

A String that might represent a number can be coerced to a numeric type; an integer type will accept a radix: argument expressing the base. The coercion might fail, because the String might not represent a number of the specified type; so the result is not a number but an Optional wrapping a number (I haven’t talked about Optionals yet, so you’ll have to trust me for now; failable initializers are discussed in Chapter 4):

let s = "31"
let i = Int(s) // Optional(31)
let s2 = "1f"
let i2 = Int(s2, radix:16) // Optional(31)

Similarly, you can coerce a Bool to a String, which will be "true" or "false". Going the other way, you can coerce the string "true" to the Bool true and the string "false" to the Bool false; again, this is a failable initializer, and any other string will fail.

The length of a String, in characters, is given by its count property:

let s = "hello"
let length = s.count // 5

This property is called count rather then length because a String doesn’t really have a simple length. The String comprises a sequence of Unicode codepoints, but multiple Unicode codepoints can combine to form a single character; so, in order to know how many characters are represented by such a sequence, we actually have to walk through the sequence and resolve it into the characters that it represents.

You, too, can walk through a String’s characters. The simplest way is with the for...in construct (see Chapter 5). What you get when you do this are Character objects; I’ll talk more about Character objects later:

let s = "hello"
for c in s {
    print(c) // print each Character on its own line
}

At an even deeper level, you can decompose a String into its UTF-8 codepoints or its UTF-16 codepoints, using the utf8 and utf16 properties:

let s = "u{BF}Quiu{E9}n?"
for i in s.utf8 {
    print(i) // 194, 191, 81, 117, 105, 195, 169, 110, 63
}
for i in s.utf16 {
    print(i) // 191, 81, 117, 105, 233, 110, 63
}

There is also a unicodeScalars property representing a collection (a String.UnicodeScalarView) of the String’s UTF-32 codepoints expressed as UnicodeScalar structs. To illustrate, here’s a utility function that turns a two-letter country abbreviation into an emoji representation of its flag:

func flag(country:String) -> String {
    let base : UInt32 = 127397
    var s = ""
    for v in country.unicodeScalars {
        s.unicodeScalars.append(UnicodeScalar(base + v.value)!)
    }
    return String(s)
}
// and here's how to use it:
let s = flag(country:"DE")

The curious thing is that there aren’t more methods for standard string manipulation. How do you capitalize a string, or find out whether a string contains a given substring? Most modern programming languages have a compact, convenient way of doing things like that; Swift doesn’t. The reason appears to be that missing features are provided by the Foundation framework, to which you’ll always be linked in real life (importing UIKit imports Foundation). A Swift String is bridged to a Foundation NSString. This means that, to a large extent, Foundation NSString properties and methods magically spring to life whenever you are using a Swift String:

let s = "hello world"
let s2 = s.capitalized // "Hello World"

The capitalized property comes from the Foundation framework; it’s provided by Cocoa, not by Swift. It’s an NSString property; it appears tacked onto String “for free.” Similarly, here’s how to locate a substring of a string:

let s = "hello"
let range = s.range(of:"ell") // Optional(Range(...)) [details omitted]

I haven’t explained yet what an Optional is or what a Range is (I’ll talk about them later in this chapter), but that innocent-looking code has made a remarkable round-trip from Swift to Cocoa and back again: the Swift String s becomes an NSString, an NSString method is called, a Foundation NSRange struct is returned, and the NSRange is converted to a Swift Range and wrapped up in an Optional.

Character and String Index

You are more likely to be interested in a string’s characters than its codepoints. Codepoints are numbers, but what we naturally think of as characters are effectively minimal strings: a character is a single “letter” or “symbol” — formally, a grapheme. The equivalence between numeric codepoints and symbolic graphemes is provided, in Unicode, by the notion of a grapheme cluster. To embody this equivalence, Swift provides the Character object type (a struct), representing a single grapheme cluster.

A String (in Swift 4 and later) simply is a character sequence — quite literally, a Sequence of the Character objects that constitute it. That is why, as I mentioned earlier, you can walk through a string with for...in to obtain the String’s Characters, one by one; when you do that, you’re walking through the string qua character sequence:

let s = "hello"
for c in s {
    print(c) // print each Character on its own line
}

It isn’t common to encounter Character objects outside of some character sequence of which they are a part. There isn’t even a way to write a literal Character. To make a Character from scratch, initialize it from a single-character String:

let c = Character("h")

Similarly, you can pass a one-character String literal where a Character is expected, and many examples in this section will do so.

By the same token, you can initialize a String from a Character:

let c = Character("h")
let s = (String(c)).uppercased()

Characters can be compared for equality; “less than” means what you would expect it to mean.

Formally, a String is both a Sequence of Characters and a Collection of Characters. Sequence and Collection are protocols; I’ll discuss protocols in Chapter 4, but what’s important for now is that a String is endowed with methods and properties that it gets by virtue of being a Sequence and a Collection.

A String has a first and last property; the resulting Character is wrapped in an Optional because the string might be empty:

let s = "hello"
let c1 = s.first // Optional("h")
let c2 = s.last // Optional("o")

The firstIndex(of:) method locates the first occurrence of a given character within the sequence and returns its index. Again, this is an Optional, because the character might be absent:

let s = "hello"
let firstL = s.firstIndex(of:"l") // Optional(2)

All Swift indexes are numbered starting with 0, so 2 means the third character. The index value here, however, is not an Int; I’ll explain in a moment what it is and what it’s good for.

A related method, firstIndex(where:), takes a function that takes a Character and returns a Bool. This code locates the first character smaller than "f":

let s = "hello"
let firstSmall = s.firstIndex {$0 < "f"} // Optional(1)

Those methods are matched by lastIndex(of:) and lastIndex(where:).

A String has a contains(_:) method that returns a Bool, reporting whether a certain character is present:

let s = "hello"
let ok = s.contains("o") // true

Alternatively, contains(_:) can take a function that takes a Character and returns a Bool. This code reports whether the target string contains a vowel:

let s = "hello"
let ok = s.contains {"aeiou".contains($0)} // true

The filter(_:) method, too, takes a function that takes a Character and returns a Bool, effectively eliminating those characters for which false is returned. Here, we delete all consonants from a string:

let s = "hello"
let s2 = s.filter {"aeiou".contains($0)} // "eo"

The dropFirst and dropLast methods return, in effect, a new string without the first or last character, respectively:

let s = "hello"
let s2 = s.dropFirst() // "ello"

I say “in effect” because a method that extracts a substring returns, in reality, a Substring instance. The Substring struct is an efficient way of pointing at part of some original String, rather than having to generate a new String. When we call s.dropFirst() on the string "hello", the resulting Substring points at the "ello" part of "hello", which continues to exist; there is still only one string, and no new string storage memory is required.

In general, the difference between a String and a Substring will make little practical difference to you, because what you can do with a String, you can usually do also with a Substring. Nevertheless, they are different classes; this code won’t compile:

var s = "hello"
let s2 = s.dropFirst()
s = s2 // compile error

To pass a Substring where a String is expected, coerce the Substring to a String explicitly:

var s = "hello"
let s2 = s.dropFirst()
s = String(s2)

You can coerce the other way, too, from a String to a Substring.

prefix(_:) and suffix(_:) extract a Substring of a given length from the start or end of the original string:

var s = "hello"
s = String(s.prefix(4)) // "hell"

split(_:) breaks a string up into an array, according to a function that takes a Character and returns a Bool. In this example, I obtain the words of a String, where a “word” is simplemindedly defined as a run of Characters other than a space:

let s = "hello world"
let arr = s.split {$0 == " "} // ["hello", "world"]

The result is actually an array of Substrings. If we needed to get String objects, we could apply the map(_:) function and coerce them all to Strings. I’ll talk about map(_:) in Chapter 4, so you’ll have to trust me for now:

let s = "hello world"
let arr = s.split {$0 == " "}.map {String($0)} // ["hello", "world"]

A String, qua character sequence, can also be manipulated similarly to an array. For example, you can use subscripting to obtain the character at a certain position. Unfortunately, this isn’t as easy as it might be. What’s the second character of "hello"? This doesn’t compile:

let s = "hello"
let c = s[1] // compile error

The reason is that the indexes on a String are not Int values, but rather a special nested type, a String.Index (which is actually a type alias for String.CharacterView.Index). To make an object of this type is rather tricky. Start with a String’s startIndex or endIndex, or with the return value from firstIndex or lastIndex; you can then call the index(_:offsetBy:) method to derive the index you want:

let s = "hello"
let ix = s.startIndex
let ix2 = s.index(ix, offsetBy:1)
let c = s[ix2] // "e"

The reason for this clumsy circumlocution is that Swift doesn’t know where the characters of a character sequence are until it actually walks the sequence; calling index(_:offsetBy:) is how you make Swift do that.

To offset an index by a single position, you can obtain the next or preceding index value with the index(after:) and index(before:) methods. I could have written the preceding example like this:

let s = "hello"
let ix = s.startIndex
let c = s[s.index(after:ix)] // "e"

Another reason why it’s necessary to think of a string index as an offset from the startIndex or endIndex is that those values may not be what you think they are — in particular, when you’re dealing with a Substring. Consider, once again, the following:

let s = "hello"
let s2 = s.dropFirst()

Now s2 is "ello". What, then, is s2.startIndex (as an Int)? Not 0, but 1 — because s2 is a Substring pointing into the original "hello", where the index of the "e" is 1. Similarly, s2.firstIndex(of:"o") is not 3, but 4, because the index value is reckoned with respect to the original "hello".

Once you’ve obtained a desired character index value, you can use it to modify the String. The insert(contentsOf:at:) method inserts a string into a string:

var s = "hello"
let ix = s.index(s.startIndex, offsetBy:1)
s.insertContentsOf("ey, h", at: ix) // s is now "hey, hello"

Similarly, remove(at:) deletes a single character, and also returns that character. (Manipulations involving longer character stretches require use of a Range, which is the subject of the next section.)

On the other hand, a character sequence can be coerced directly to an Array of Character objects — Array("hello") creates an array of the characters "h", "e", and so on — and array indexes are Ints and are easy to work with. Once you’ve manipulated the array of Characters, you can coerce it directly to a String. I’ll give an example in the next section (and I’ll discuss arrays, and say more about collections and sequences, in Chapter 4).

Range

The Range object type (a struct) represents a pair of endpoints. There are two operators for forming a Range literal; you supply a start value and an end value, with one of the Range operators between them:

... (closed range operator)

The notation a...b means “everything from a up to b, including b.”

..< (half-open range operator)

The notation a..<b means “everything from a up to but not including b.”

Spaces around a Range operator are legal.

The types of a Range’s endpoints will typically be some kind of number — most often, Ints:

let r = 1...3

If the end value is a negative literal, it has to be enclosed in parentheses or preceded by whitespace:

let r = -1000 ... -1

A very common use of a Range is to loop through numbers with for...in:

for ix in 1...3 {
    print(ix) // 1, then 2, then 3
}

There are no reverse Ranges: the start value of a Range can’t be greater than the end value (the compiler won’t stop you, but you’ll crash at runtime). In practice, you can use Range’s reversed() method to iterate from a higher value to a lower one:

for ix in (1...3).reversed() {
    print(ix) // 3, then 2, then 1
}

In Chapter 5 I’ll show how to create a custom operator that effectively generates a reverse Range.

You can also use a Range’s contains(_:) instance method to test whether a value falls within given limits:

let ix = // ... an Int ...
if (1...3).contains(ix) { // ...

For purposes of testing containment, a Range’s endpoints can be Doubles:

let d = // ... a Double ...
if (0.1...0.9).contains(d) { // ...

There are also methods for learning whether two ranges overlap, and for clamping one range to another.

Another common use of a Range is to index into a sequence. Here’s one way to get the second, third, and fourth characters of a String. As I suggested at the end of the preceding section, if we coerce the String to an Array of Character, we can then use an Int Range as an index into that array, and coerce back to a String:

let s = "hello"
let arr = Array(s)
let result = arr[1...3]
let s2 = String(result) // "ell"

A String is itself a sequence — a character sequence — so you can use a Range to index directly into a String; but then it has to be a Range of String.Index, which, as I’ve already pointed out, is rather tricky to obtain. By manipulating String.Index values, you can form a Range of the proper type and use it to extract a substring by subscripting:

let s = "hello"
let ix1 = s.index(s.startIndex, offsetBy:1)
let ix2 = s.index(ix1, offsetBy:2)
let s2 = s[ix1...ix2] // "ell"

The replaceSubrange(_:with:) method splices into a range, modifying the string:

var s = "hello"
let ix = s.startIndex
let r = s.index(ix, offsetBy:1)...s.index(ix, offsetBy:3)
s.replaceSubrange(r, with: "ipp") // s is now "hippo"

Similarly, you can delete a stretch of characters with the removeSubrange(_:) method:

var s = "hello"
let ix = s.startIndex
let r = s.index(ix, offsetBy:1)...s.index(ix, offsetBy:3)
s.removeSubrange(r) // s is now "ho"

It is possible to omit one of the endpoints from a Range literal, specifying a partial range. There are three kinds of partial range expression, corresponding to three types of Range-like struct. To illustrate, the following expressions are identical ways of specifying the range of an entire String s:

let range1 = s.startIndex..<s.endIndex      // Range
let range2 = ..<s.endIndex                  // PartialRangeUpTo
let range3 = ...s.index(before: s.endIndex) // PartialRangeUpThrough
let range4 = s.startIndex...                // PartialRangeFrom

If you need to convert a partial range to a range, call relative(to:). In the preceding code, range1 and range2.relative(to:s) are identical. But in general you won’t need to do that, because a partial range literal can be used wherever you would use a range literal. For instance, a partial range is a legal String subscript value:

let s = "hello"
let ix2 = s.index(before: s.endIndex)
let s2 = s[..<ix2] // "hell"

I’ll show further practical examples later on.

Tuple

A tuple is a lightweight custom ordered collection of multiple values. As a type, it is expressed by surrounding the types of the contained values with parentheses, separated by a comma. Here’s a declaration for a variable whose type is a tuple of an Int and a String:

var pair : (Int, String)

The literal value of a tuple is expressed in the same way — the contained values, surrounded with parentheses and separated by a comma:

var pair : (Int, String) = (1, "Two")

Those types can be inferred, so there’s no need for the explicit type in the declaration:

var pair = (1, "Two")

Tuples are a pure Swift language feature; they are not compatible with Cocoa and Objective-C, so you’ll use them only for values that Cocoa never sees. Within Swift, however, they have many uses. For example, a tuple is an obvious solution to the problem that a function can return only one value; a tuple is one value, but it contains multiple values, so using a tuple as the return type of a function permits that function to return multiple values.

Tuples come with numerous linguistic conveniences. You can assign to a tuple of variable names as a way of assigning to multiple variables simultaneously:

let ix: Int
let s: String
(ix, s) = (1, "Two")

That’s such a convenient thing to do that Swift lets you do it in one line, declaring and initializing multiple variables simultaneously:

let (ix, s) = (1, "Two")

To ignore one of the assigned values, use an underscore to represent it in the receiving tuple:

let pair = (1, "Two")
let (_, s) = pair // now s is "Two"

Assigning variable values to one another through a tuple swaps them safely:

var s1 = "hello"
var s2 = "world"
(s1, s2) = (s2, s1) // now s1 is "world" and s2 is "hello"

The enumerated method lets you walk a sequence with for...in and receive, on each iteration, each successive element’s index number along with the element itself; this double result comes to you as — you guessed it — a tuple:

let s = "hello"
for (ix,c) in s.enumerated() {
    print("character (ix) is (c)")
}

I also pointed out earlier that numeric instance methods such as addingReportingOverflow return a tuple.

You can refer to the individual elements of a tuple directly, in two ways. The first way is by index number, using a literal number (not a variable value) as the name of a message sent to the tuple with dot-notation:

let pair = (1, "Two")
let ix = pair.0 // now ix is 1

If you have a var reference to a tuple, you can assign into it by the same means:

var pair = (1, "Two")
pair.0 = 2 // now pair is (2, "Two")

The second way to access tuple elements is to give them labels. The notation is like that of function parameters, and must appear as part of the explicit or implicit type declaration. Here’s one way to establish tuple element labels:

let pair : (first:Int, second:String) = (1, "Two")

And here’s another way:

let pair = (first:1, second:"Two")

The labels are now part of the type of this value, and travel with it through subsequent assignments. You can then use them as literal messages, just like (and together with) the numeric literals:

var pair = (first:1, second:"Two")
let x = pair.first // 1
pair.first = 2
let y = pair.0 // 2

The tuple generated by the enumerated method has labels offset and element, so we can rewrite an earlier example like this:

let s = "hello"
for t in s.enumerated() {
    print("character (t.offset) is (t.element)")
}

You can assign from a tuple without labels into a corresponding tuple with labels (and vice versa):

let pair = (1, "Two")
let pairWithNames : (first:Int, second:String) = pair
let ix = pairWithNames.first // 1

You can also pass, or return from a function, a tuple without labels where a corresponding tuple with labels is expected:

func tupleMaker() -> (first:Int, second:String) {
    return (1, "Two") // no labels here
}
let ix = tupleMaker().first // 1

If you’re going to be using a certain type of tuple consistently throughout your program, it might be useful to give it a type name. To do so, define a type alias. In my LinkSame app, I have a Board class describing and manipulating the game layout. The board is a grid of Piece objects. I need a way to describe positions of the grid. That’s a pair of integers, so I define my own type as a tuple:

class Board {
    typealias Point = (x:Int, y:Int)
    // ...
}

The advantage of that notation is that it now becomes easy to use Points throughout my code. Given a Point, I can fetch the corresponding Piece:

func piece(at p:Point) -> Piece? {
    let (i,j) = p
    // ... error-checking goes here ...
    return self.grid[i][j]
}

Still, one should not overuse tuples. In a very real sense, they are not a full-fledged type. Keep your tuples small, light, and temporary.

Optional

The Optional object type (an enum) wraps another object of any type. What makes an Optional optional is this: it might wrap another object, but then again it might not. Think of an Optional as being itself a kind of shoebox — a shoebox which can quite legally be empty.

Let’s start by creating an Optional that does wrap an object. Suppose we want an Optional wrapping the String "howdy". One way to create it is with the Optional initializer:

var stringMaybe = Optional("howdy")

If we log stringMaybe to the console with print, we’ll see an expression identical to the corresponding initializer: Optional("howdy").

After that declaration and initialization, stringMaybe is typed, not as a String, nor as an Optional plain and simple, but as an Optional wrapping a String. This means that any other Optional wrapping a String can be assigned to it — but not an Optional wrapping some other type. This code is legal:

var stringMaybe = Optional("howdy")
stringMaybe = Optional("farewell")

This code, however, is not legal:

var stringMaybe = Optional("howdy")
stringMaybe = Optional(123) // compile error

Optional(123) is an Optional wrapping an Int, and you can’t assign an Optional wrapping an Int where an Optional wrapping a String is expected.

Optionals are so important to Swift that special syntax for working with them is baked into the language. The usual way to make an Optional is not to use the Optional initializer (though you can certainly do that), but to assign or pass a value of some type to a reference that is already typed as an Optional wrapping that type. This seems as if it should not be legal — but it is. Once stringMaybe is typed as an Optional wrapping a String, it is legal to assign a String directly to it. The outcome is that the assigned String is wrapped in an Optional for us, automatically:

var stringMaybe = Optional("howdy")
stringMaybe = "farewell" // now stringMaybe is Optional("farewell")

We also need a way of typing something explicitly as an Optional wrapping a String. Otherwise, we cannot declare a variable or parameter with an Optional type. Formally, an Optional is a generic, so an Optional wrapping a String is an Optional<String>. (I’ll explain that syntax in Chapter 4.) However, you don’t have to write that. The Swift language supports syntactic sugar for expressing an Optional type: use the name of the wrapped type followed by a question mark:

var stringMaybe : String?

Thus I don’t need to use the Optional initializer at all. I can type the variable as an Optional wrapping a String and assign a String into it for wrapping, all in one move:

var stringMaybe : String? = "howdy"

That, in fact, is the normal way to make an Optional in Swift.

Once you’ve got an Optional wrapping a particular type, you can use it wherever an Optional wrapping that type is expected — just like any other value. If a function expects an Optional wrapping a String as its parameter, you can pass stringMaybe as the argument:

func optionalExpecter(_ s:String?) {}
let stringMaybe : String? = "howdy"
optionalExpecter(stringMaybe)

Moreover, where an Optional wrapping a certain type of value is expected, you can pass a value of that wrapped type instead. That’s because parameter passing is just like assignment: an unwrapped value will be wrapped implicitly for you. If a function expects an Optional wrapping a String, you can pass a String argument, which will be wrapped into an Optional in the received parameter:

func optionalExpecter(_ s:String?) {
    // ... here, s will be an Optional wrapping a String ...
    print(s)
}
optionalExpecter("howdy") // console prints: Optional("howdy")

But you cannot do the opposite — you cannot use an Optional wrapping a type where the wrapped type is expected. This won’t compile:

func realStringExpecter(_ s:String) {}
let stringMaybe : String? = "howdy"
realStringExpecter(stringMaybe) // compile error

The error message reads: “Value of Optional type String? must be unwrapped.” You’re going to be seeing that sort of message a lot in Swift, so get used to it! If you want to use an Optional where the type of thing it wraps is expected, you must unwrap the Optional — that is, you must reach inside it and retrieve the actual thing that it wraps. Now I’m going to talk about how to do that.

func realStringExpecter(_ s:String) {}
let stringMaybe : String? = "howdy"
realStringExpecter(stringMaybe!)

let stringMaybe : String? = "howdy"
let upper = stringMaybe.uppercased() // compile error

let stringMaybe : String? = "howdy"
let upper = stringMaybe!.uppercased()

// self.window is an Optional wrapping a UIWindow
self.window!.rootViewController = RootViewController()
self.window!.backgroundColor = UIColor.white
self.window!.makeKeyAndVisible()

// self.window is an Optional wrapping a UIWindow
let window = self.window!
// now window (not self.window) is a UIWindow, not an Optional
window.rootViewController = RootViewController()
window.backgroundColor = UIColor.white
window.makeKeyAndVisible()

func realStringExpecter(_ s:String) {}
var stringMaybe : String! = "howdy"
realStringExpecter(stringMaybe) // no problem

self.view.addSubview(v)

let mainview = self.view
mainview.addSubview(v) // compile error

let mainview = self.view!
mainview.addSubview(v)

var stringMaybe : String? = "Howdy"
print(stringMaybe) // Optional("Howdy")
if stringMaybe == nil {
    print("it is empty") // does not print
}
stringMaybe = nil
print(stringMaybe) // nil
if stringMaybe == nil {
    print("it is empty") // prints
}

func optionalExpecter(_ s:String?) {}
var stringMaybe : String?
optionalExpecter(stringMaybe)

var stringMaybe : String?
let s = stringMaybe! // crash

var stringMaybe : String?
// ... stringMaybe might be assigned a real value here ...
if stringMaybe != nil {
    let s = stringMaybe!
    // ...
}

let stringMaybe : String? = "howdy"
let upper = stringMaybe.uppercased() // compile error

let stringMaybe : String? = "howdy"
let upper = stringMaybe!.uppercased()

var stringMaybe : String?
// ... stringMaybe might be assigned a real value here ...
let upper = stringMaybe?.uppercased()

var stringMaybe : String?
stringMaybe = "howdy"
let upper = stringMaybe?.uppercased()

var stringMaybe : String?
let upper = stringMaybe?.uppercased()

// self is a UIViewController
let f = self.view.window?.rootViewController?.view.frame

class Dog {
    var noise : String?
    func speak() -> String? {
        return self.noise
    }
}
let d = Dog()
let bigname = d.speak()?.uppercased()

// self is a UIViewController
self.navigationController?.hidesBarsOnTap = true

let ok : Void? = self.navigationController?.hidesBarsOnTap = true

let s : String? = "howdy"
let s2 = s.map {$0.uppercased()}

let s : String? = // whatever
let i = s.flatMap {Int($0)}

let s : String? = "Howdy"
if s == "Howdy" { // ... they _are_ equal!

let i : Int? = 2
if i < 3 { // compile error

if i != nil && i! < 3 { // ... it _is_ less

let arr = [1,2,3]
let ix = arr.firstIndex(of:4)
if ix == nil { // ...

let v = UIView()
let c = v.backgroundColor
let c2 = c.withAlphaComponent(0.5) // compile error

let v = UIView()
let c = v.backgroundColor
let c2 = c?.withAlphaComponent(0.5)

class RootViewController : UITableViewController {
    var albums : [MPMediaItemCollection]? // initialized to nil
    // ...
}

class ViewController: UIViewController {
    @IBOutlet var myButton: UIButton! // initialized to nil
    // ...
}