Overview

Swift is an open source programming language created by Apple. Key facts about Swift include the following:

• introduced by Apple at the 2014 WWDC conference
• became open source under an Apache license in December 2015
• goals are to be safe, fast, and expressive
• a compiled language, but there is also an interpreter
• strongly typed with type inference
• supports both object-oriented and functional programming
• a big language with a large number of features and a corresponding learning curve
• can be used to build applications for macOS, iOS, and Watch OS
• can be used to build command-line and server-side applications
• has six major types: structs, classes, enums, protocols, functions, and generics
• supports tuples
• standout features include computed properties, closure syntax, trailing closures, key paths, and a succinct way to refer to enum cases when their type can be inferred
• built on LLVM (Low Level Virtual Machine)
• interoperates with Objective-C code
• includes a Standard Library
• compiler is slow, not swift
• language makes some efforts to be concise, but also uses many long keywords and method names

Resources

• Apple Developer app in the macOS and iOS App Stores This is a large collection of developer resources from Apple include all WWDC videos.

• Swift home page - https://swift.org

• The Swift Programming Language Book

• Swift Playgrounds iOS app - free

• Unwrap app from Paul Hudson for learning Swift on an iPhone or iPad

• Hacking with Swift video series on Swift and SwiftUI by Paul Hudson (@twostraws) - free

• 100 Days of Swift by Paul Hudson (@twostraws) - free

• Swiftful Thinking YouTube videos by Nick Sarno - free

• Swift by Sundell by John Sundell

• CreaTECH Solutions YouTube videos by StewartLynch- free

• Sean Allen YouTube videos and paid courses

• Code With Chris by Chris Ching

• Stanford CS193p - Developing Apps for iOS course by Paul Hegarty - free

• iOS & Swift - The Complete iOS App Development Bootcamp Udemy course by Angela Yu - $14.99

Installing

Swift can be installed on macOS, Windows 10, Amazon Linux 2, CentOS, and Ubuntu.

To install Swift on macOS, install Xcode from the macOS App Store. For other operating systems, download it from Download Swift.

Editing

Most Swift developers use Xcode as their editor/IDE. However, there are good reasons to use VS Code in addition to Xcode.

VS Code as the following advantages over Xcode:

• There is a built-way to format code every time changes to a file are saved. To format code in Xcode, select the lines to be formatted and press ctrl-shift-i. Xcode can be configured to run SwiftFormat on save, but this requires a number of undocumented steps. SwiftFormat is a separate tool that is similar to a combination of the JavaScript tools ESLint (with autofix) and Prettier.
• Git integration is better. You can see at a glance which files have been added or modified and see side-by-side diffs without initiating a commit.
• Snippet support is much better. A snippet can refer to built-in variables for inserting things like the current file name and placeholders can be repeated so the same entered text can be inserted in multiple places.
• Files in the Navigator pane are always listed in alphabetical order.
• The Vim support in VS Code (provided by the Vim extension) is far better than the Vim support in Xcode (enabled by checking "Vim mode" on the Editor menu). In VS Code, the dot command (for repeating the last command) and macros (for recording and repeating a sequence of operations) are supported.

However, Xcode also has the following advantages over VS Code:

• Syntax error messages are displayed inline with the code where they appear.
• iOS projects can be run in the Simulator and on devices directly from Xcode.

I recommend simultaneously opening a project in both VS Code and Xcode and switching between them as needed to get the benefits of both. When a change is made to a file that is open in both, the other will automatically update to show the change.

Getting Started with VS Code

Install the Swift and SwiftFormat extensions.

In "User Settings" under Text Editor ... Formatting, enable "Format on Save".

Create the file .swiftformat in the top project directory with contents like the following:

--maxwidth 80
--ranges no-space
--swiftversion 5.6

For more options supported by SwiftFormat, see Rules.

Using the Interpreter

To start the interpreter as a REPL (Read Eval Print Loop), enter swift. Then enter Swift statements to be evaluated. For example, enter print(1 + 2).

To run the interpreter on code in a file, enter swift {file-path}. For example, create the file greet.swift containing print("Hello, World!") and enter swift greet.swift to run it.

Interpreter commands begin with a colon. The most commonly used commands are described in the table below.

Debugging Output

The global functions print and dump functions are useful for debugging Swift code.

The print function takes any number of arguments and prints them to stdout.

The literal expressions #file, #fileID, #function, #line, and #column can be used to provide context. For example:

print("\(#fileID) \(#function) score =", score)

The dump function takes one value to print and prints each property of the object on a separate line. To takes the optional arguments indent, maxDepth, and maxItems to customized the output.

The following code prints a subset of the data in an array.

struct Dog {
    let name: String
    let breed: String
    let owner: Person
}

struct Person {
    let name: String
}

let tami = Person(name: "Tami")
let amanda = Person(name: "Amanda")
let dogs = [
    Dog(name: "Oscar", breed: "GSP", owner: amanda),
    Dog(name: "Comet", breed: "Whippet", owner: tami)
]
dump(dogs)

The output from the dump function is:

▿ 2 elements
  ▿ __lldb_expr_136.Dog
    - name: "Oscar"
    - breed: "GSP"
    ▿ owner: __lldb_expr_136.Person
      - name: "Amanda"
  ▿ __lldb_expr_136.Dog
    - name: "Comet"
    - breed: "Whippet"
    ▿ owner: __lldb_expr_136.Person
      - name: "Tami"

To print the unique id of an object:

print("id = \(ObjectIdentifier(myObject))")

Packages

The Swift Package Manager is a "tool for managing the distribution of Swift code". It is similar to npm for JavaScript. Installing the Swift compiler also installs the Swift package manager.

To install a package in Xcode:

• select File ... Add Packages...
• Enter the GitHub URL of a package in the search input in the upper-right.
• Select the package
• Click the "Add Package" button.

Swift Standard Library

The Swift Standard Library defines fundamental types, protocols, and global functions. These include:

• types like Bool, Int, Float, Double, String, Regex, KeyPath, and Optional
• collections like Array, Set, Dictionary, and Range
• protocols like Comparable, Equatable, Hashable, CaseIterable, and Codable
• global functions like abs, max, min, print, dump, readLine, and assert

Fun Fact: "integer" means "complete" in Latin.

The Swift Standard Library is open source and implemented entirely in Swift. It is available by default, so nothing needs to be imported to use the things it defines.

Foundation Framework

The Foundation framework defines many types including AttributedString, Bundle, Calendar, CGFloat, Data, Date, DateFormatter, DateInterval, Decimal, Dimension, Error, FileManager, HTTPURLResponse, InputStream, Locale, Measurement, NumberFormatter, NumberFormatter, ObservableObject, OutputStream, Pipe, Port, Process, ProcessInfo, Published, RunLoop, Stream, Thread, TimeInterval, Timer, Timer, TimeZone, Unit, URL, URLRequest, URLResponse, URLSession, UserDefaults, UUID, and many more.

The Foundation Framework is not open source and is mostly implemented in Objective-C. However, the post The Future of Foundation from December 2022 states that work is underway to rewrite it in Swift and make it open source.

The Foundation Framework must be imported in order to use the things it defines. It is not necessary to explicitly import Foundation if another framework or package that uses Foundation is imported, and most of them do.

Libraries

Xcode is aware of many standard libraries such as SwiftUI and UIKit. To use the public types, functions, and values that a library defines, import them. For example, import SwiftUI.

Packages that are added to a project as described in the previous section must also be imported.

It is possible for two libraries/packages to define the same names. One approach to resolve such conflicts is to prefix the names with the name of the library/package. For example, SwiftUI.List. Another approach is to define type aliases and use those names. For example, typealias SUIList = SwiftUI.List.

Comments

Single-line comments begin with //. Multi-line comments are delimited by /* and */. Multi-line comments can be nested which makes it easy to comment out blocks of code that contain multi-line comments. Documentation comments begin with /// and appear before type definitions. This documentation appears when a name is option-clicked in Xcode.

Xcode can toggle whether lines are commented. To comment/uncomment the current line or selected lines, press cmd-/.

Comments whose purpose is to remind you to make a change later can be written in three ways:

• // TODO: some text

  This approach is not flagged when the project is built.

• #warning("some text")

  This approach results in a warning message when the project is built which makes it less likely to be overlooked than a TODO comment. The project will still build successfully.

• #error("some text")

  This approach results in an error message when the project is built which makes it impossible to forget because the project will not build.

Operators

The binary mathematical operators require the variables on each side to have the same type. For example, a Float cannot be divided by an Int. When the types differ, one side must be cast to the type of the other side.

let a = 8.0
let b = 3
print(8.0 / 3) // both sides are literals so allowed; 2.666...
print(a / 3) // one side is literal so allowed; same result
print(a / Double(b)) // variables on both sides so cast required; same result

When an Int is divided by an Int using the / operator, the result is truncated to an Int, not rounded.

The nil coalescing operator in a ?? b is shorthand for a != nil ? a! : b. This is often used to provide a default value to use when a is nil.

Swift supports optional chaining with the ?. operator so chains of references to optional values (see the "Optionals" section later) do not have to check for nil values. See the example in the Structs section.

Functions

Functions are defined using the func keyword, followed by the function name, the parameter list in parentheses, and an optional return type preceded by ->. The parentheses are required even for functions that have no parameters.

When the return type of a function cannot be inferred and no return type is specified, it defaults to the Void type The Void type has a single value which is an empty tuple (()).

To call a function, specify the function name followed by arguments in parentheses. The parentheses are required even when not passing any arguments.

func greet() {
    print("Hello, World!")
}
greet() // outputs Hello, World!

Parameters must have a name and type. They can also have an "argument label" that is the name callers must use when providing a value. The argument label defaults to the parameter name. Typically argument labels are omitted and callers use the parameter names.

func order(item: Item, quantity: Int) -> Int {
    // Place order and get order number.
    return orderNumber
}
let orderNumber = order(item: Item("chicken fried rice"), quantity: 2)

All function parameters are treated as let constants. This prevents function code from assigning new values to them. This also applies to the properties of objects passed to functions.

Swift does not support a shorthand syntax for calling functions when in-scope variables have the same names are argument labels.

let item = Item("chicken fried rice")
let quantity = 2
//let orderNumber = order(item, quantity) // doesn't work
let orderNumber = order(item: item, quantity: quantity)

When an argument label is underscore, it is a positional argument. The function must be called with only a value and no name for that parameter. Otherwise calls must include the argument label. A function can have a mixture of parameters with argument labels and positional parameters.

Typically positional arguments are only used for the first argument and only when the function name implies the meaning of the first argument. The following code demonstrates using multiple positional arguments.

func add(_ n1: Int, _ n2: Int) -> Int {
    return n1 + n2
}
print(add(2, 3)) // 5

If the body of the function is a single expression, the return keyword` is not required to return its value. The previous function can rewritten as follows:

func add(_ n1: Int, _ n2: Int) -> Int {
    n1 + n2
}
print(add(2, 3)) // 5

If the return type can be inferred, the return type can be omitted. The previous function can rewritten as follows:

func add(_ n1: Int, _ n2: Int) {
    n1 + n2
}
print(add(2, 3)) // 5

A parameter can specify a default value by including an equal sign (=) followed by a value after the type. Doing so makes the corresponding argument optional. All parameters with default values must follow those that do not have a default value.

Calls to a function must provide all the required arguments. Each argument is specified by the argument label, a colon, and a value. These must appear in the same orders as the corresponding parameters. The rationale for this is that it can make some calls more expressive, almost like sentences. It is useful to think of the argument labels as being part of the function name.

Here is an example of a function where it is useful for argument labels to differ from parameters names. It uses the types Ingredient and Food that are not defined here.

func getDailyPercentage(of ingredient: Ingredient, in food: Food) -> Float {
    // Perhaps look up the value in a Dictionary and return it.
}

let sugar = Ingredient(name: "sugar")
let frostedFlakes = Food(name: "Frosted Flakes")
let dailySugarPct = getDailyPercentage(of: sugar, in: frostedFlakes)

Code hints provided by Xcode help developers know the argument labels and types that must be provided.

A "variadic" parameter accepts multiple values of the same type, indicated by following the type with three periods. The parameter value will be a constant array of values.

func displaySum(label: String, numbers: Int...) {
    let sum = numbers.sum();
    print("\(label) = \(sum)")
}

Function names can be overloaded based on their parameter types.

To return multiple values, return a tuple which is written as a list of values inside parentheses.

func getAvgSum(_ numbers: [Float]) -> (Float, Float) {
    let sum = numbers.reduce(0, {$0 + $1})
    let avg = sum / Float(numbers.count)
    return (avg, sum)
}

print(getAvgSum([1, 3, 8])) // (4.0, 12.0)

// This defines a "tuple" type and assigns a name to it.
typealias RGB = (red: Int, green: Int, blue: Int)

let rgbDict: [String : RGB] = [
    "red": (red: 255, green: 0, blue: 0),
    "green": (red: 0, green: 255, blue: 0),
    "blue": (red: 0, green: 0, blue: 255)
]

// The question mark at the end of the return type
// indicates that the function might return nil.
func getRgb(_ color: String) -> RGB? {
    return rgbDict[color]
}

print(getRgb("red")) // (red: 255, green: 0, blue: 0)
print(getRgb("green")) // (red: 0, green: 255, blue: 0)
print(getRgb("pink")) // nil

By default, parameters cannot be modified in function bodies. Adding the keyword inout before a parameter type changes the parameter to be passed by reference instead of by value. Callers must precede corresponding argument values with an ampersand (&). Modifying the values of these parameters changes the value of the corresponding argument in the caller. This only works if the value passed in is a variable (var) rather than a constant (let). The use of inout parameters is not allowed in concurrently executing code.

The type of a function is described by its parameter types and return type. For example, the type of the displaySum function above is (String, Int) -> Void. The type of a function that takes no arguments and returns nothing is () -> Void.

Function types can be used for variable, parameter, and return types. This means that compatible functions can be assigned to variables, passed to functions, and returned from functions.

Argument labels are not used when calling a function stored in a variable because each function that can be assigned to the variable could specify different argument labels. For example:

typealias BinaryFn = (Double, Double) -> Double

func add(n1: Double, n2: Double) -> Double { n1 + n2 }
let subtract: BinaryFn = { n1, n2 in n1 - n2 }
let multiply: BinaryFn = { $0 * $1 }

var operation: BinaryFn = add
print(operation(2, 3)) // 5.0
operation = subtract
print(operation(2, 3)) // -1.0
operation = multiply
print(operation(2, 3)) // 6.0

Functions can defined in the bodies of other functions to scope their usage. Otherwise they are global and can be called from anywhere. Nested functions can be returned by their enclosing function to allow them to be called from outside.

Swift does not support function currying. This creates a new version of an existing function that takes one fewer argument and uses a fixed value for the omitted argument. JavaScript functions support this using the bind method.

Closures

Anonymous functions (a.k.a closures) can be used as the values of variables and arguments. They are written with the following syntax: { parameter-list -> return-type in statements }. The return type can be omitted when it can be inferred. Note the use of the in keyword to mark the end of the parameter list and the beginning of the statements.

The following code defines and calls several closures.

// This function has no parameters.
let printTime = {
    let date = Date() // now
    let dateFormatter = DateFormatter()
    dateFormatter.dateFormat = "M/d/yyyy"
    print(dateFormatter.string(from: date))
}
printTime() // 3/8/2022

// This function specifies all of its parameter types and the return type.
let product = {(a: Double, b: Double) -> Double in a * b}
print(product(2, 3)) // 6.0

// This function omits the return type because it can be inferred.
let product2 = {(a: Double, b: Double) in a * b}
print(product2(2, 3)) // 6.0

If the parameter types of a closure can be inferred from usage, the parameter list can be omitted and the parameter values can be referred to by index using the names $0, $1, and so on.

let numbers = [1, 3, 7]
let doubled = numbers.map({$0 * 2}) // [2, 6, 14]

If parameters to a closure are not used, their names can be replaced by underscores.

If a closure takes no arguments and just returns the value of an expression, it can be written as just the expression inside curly braces. For example, the closure { 7 } takes no arguments and always returns 7.

If the last parameters to a function or method are functions, they can be passed using "trailing closures". Typically this is only done for the last argument. For example, these are equivalent:

let prices = [1.23, 2.34, 3.45]
let total = prices.reduce(0, { result, price in result + price })
let total = prices.reduce(0) { result, price in result + price }
let total = prices.reduce(0, {$0 + $1})

Closures can be passed as arguments to other functions. If the receiving function has asynchronous behavior that invokes the closure after the function returns, the closure parameter must be declared to be @escaping. TODO: Why is this required? TODO: Are non-escaping closures handled in an optimized way that discards their context after the function returns?

When an escaping closure references self, typically the closure parameter list should be preceded by [weak self]. This enables the object that uses the escaping closure can be garbage collected when there are no longer references to it. The type of self will be optional inside the closure, so all references to it will have to account for the possibility of it being nil.

Stopping Execution

Swift provides three global functions that can stop program execution.

The assert function conditionally prints a message that includes the current file and line number and then stops the program. These calls are ignored in release builds.

The precondition function is the same as the assert function, but it is also honored in release builds.

The fatalError function unconditionally prints a message that includes the current file and line number and then stops the program, even in release builds.

Error Handling

Errors in that occur in Swift code are described by objects that conform to the Error protocol. A protocol is like an interface in other programming languages. These are described in detail later in the Protocols section.

The Error protocol is merely a marker protocol, not requiring any properties or methods. There are a small number of provided types that conform to this protocol, summarized below. Perhaps only DecodingError and EncodingError are suitable for throwing from your own functions.

• CancellationError is thrown when a Task is cancelled.
• DecodingError is thrown when a value cannot be decoded.
• DistributedActorCodingError is thrown when a distributed actor cannot encode or decode a value.
• EncodingError is thrown when a value cannot be encoded
• ExecuteDistributedGTargetError is thrown by the executeDistributedTargetError method
• LocalTestingDistributedActorSystemError is not described in the Apple documentation.
• Never is the return type of functions that should never return. It's not clear why this conforms to the Error protocol.

Typically custom error types are defined and used. Often these are define as an enum that conforms to the Error or LocalizedError protocol. Each enum case represents a variation of the error and specific cases are thrown.

The Error protocol provides a single property, localizedDescription, which is a String.

The LocalizedError protocol inherits from the Error protocol. It supports four additional properties named errorDescription, failureReason, helpAnchor, and recoverySuggestion. These provided more detail about the error. Each has the type String?. These properties can be implemented as computed properties in order to provide dynamic values.

An alternative to defining a custom error type is to allow any String to be thrown by defining an extension that makes the String type conform to the LocalizedError protocol which inherits from the Error protocol as follows:

extension String: LocalizedError {
    public var errorDescription: String? { self }
}

To throw an error, use the throw keyword followed by an instance of any type that conforms to the Error protocol.

To handle errors, use one of the following approaches:

• allow errors to propagate to the caller

  This is done by adding the throws keyword after the parameter list and before the return type. It is not possible to indicate the kinds of errors that can be thrown. For example:

  func divide(numerator: Double, denominator: Double) throws -> Double {
      ...
  }

• use a do/catch statement

  The do statement supports having any number of associated catch blocks that each handle different kinds of errors.

  Each statement in the do block that can throw an error must be preceded by the try keyword. This is different from most programming languages where it is assumed that any statement in a try block can thrown.

  Each catch can be followed by a pattern, or list of patterns, that identify the kinds of errors it handles. To access data associated with errors caught by these cases, use the let syntax shown in the example code below.

  A catch with no pattern can appear at the end and is used to handle all remaining kinds of errors. Inside this block the variable error is set to the value that was thrown.

  If none of the catches handle the error type that has occurred, the error is propagated to the caller.

  If an error propagates to the top of the call chain and is not handled, the program will terminate with a fatal error.

• treat the error as an optional value

  When setting a variable to the result of an expression that can throw, one option is to precede the expression with try?. If the expression throws, the variable is set to nil and error is considered handled. Such code does not need to be in a do block.

• assert that the error should never occur

  If an expression or statement technically can throw, but should never throw given the way it is being used, it can be preceded with try!. This performs a force unwrap of the result and frees the code from needing the handle errors. If the code actually does throw, the program will terminate with a fatal error. For this reason is not frequently used.

We have seen three variations of trying something that can throw which are try, try?, and try!. It is important to understand the differences between these.

A defer block contains code to execute before its containing block or function exits, regardless of whether an error was thrown. This is similar to a "finally" block in other languages. The code in a defer block typically performs cleanup activities such as closing files or database connections.

The following code demonstrates using the do/catch syntax:

enum IntError: Error {
    case negative(_ n: Int)
    case other
    case zero
    case tooHigh(_ n: Int, max: Int)
}

struct PositiveInteger {
    var n: Int

    init(_ n: Int, max: Int) throws {
        if (n < 0) { throw IntError.negative(n) }
        if (n == 0) { throw IntError.zero }
        if (n > max) { throw IntError.tooHigh(n, max: max) }
        // This is used to test a catch with no pattern.
        if (n == 7) { throw IntError.other }
        self.n = n
    }
}

do {
    // Try each of the variations below by uncommented it
    // and commenting all the others.

    let pi = try PositiveInteger(3, max: 10) // doesn't throw
    print("pi =", pi)

    //let pi = try PositiveInteger(0, max: 10) // throws zero
    //print("pi =", pi)

    //let pi = try PositiveInteger(-2, max: 10) // throws negative
    //print("pi =", pi)

    //let pi = try PositiveInteger(11, max: 10) // throws tooHigh
    //print("pi =", pi)

    //let pi = try PositiveInteger(7, max: 10) // throws other
    //print("pi =", pi)
} catch IntError.negative(let n) {
    print("negative numbers like \(n) are not allowed")
} catch IntError.zero {
    print("zero is not allowed")
} catch IntError.tooHigh(let n, let max) {
    print("value \(n) exceeds the maximum of \(max)")
} catch {
    print("error value is", error)
}

Type Aliases

A type alias assigns an alternate name to another type. By convention these names are CamelCase, beginning with an uppercase letter.

One use is to provide additional documentation for primitive types. For example, the following documents the expected format of a String.

typealias MMDDYYYY = String
var date: MMDDYYYY = "04161961"

Another use of type aliases is to give a shorter name to a long name or complicated type definition that is used multiple times. For example, typealias ToString = CustomStringConvertible.

The type of a closure can be assigned to a typealias. This is useful for declaring the types of functions that are passed as arguments to other functions. For example, the product function above can be written as follows:

typealias DoublePairToDouble = (Double, Double) -> Double
let product: DoublePairToDouble = {$0 * $1}
print(product(2, 3))

Swift does not support type unions like in TypeScript. For example, it is not possible to define a type that can be an Int or a Double using typealias Number = Int | Double.

A typealias can be used to give a name to a combination of protocols. For example, the following type alias is defined by Swift.

typealias Codable = Decodble & Encodable

Instances of types that conform to this protocol can be serialized and deserialized to and from formats like JSON.

struct Sport: Codable {
    let name: String
    let playerCount: Int
}

let hockey = Sport(name: "Hockey", playerCount: 6)

let encoder = JSONEncoder()
let decoder = JSONDecoder()
do {
    let data = try encoder.encode(hockey)
    let json = String(data: data, encoding: .utf8)!
    print(json) // {"name":"Hockey","playerCount":6}

    // The first argument to decode specifies the type to be created.
    let newSport = try decoder.decode(Sport.self, from: data)
    print(newSport) // Sport(name: "Hockey", playerCount: 6)
} catch {
    print("fail")
}

Converting an instance of Data to a UTF8 String is a common task. Consider implementing the following extension to simplify the code.

extension Data {
    var utf8: String {
        String(data: self, encoding: .utf8)
    }
}

Primitive Types

In Swift, values of these types are objects with properties and methods.

All of these types are defined as structs and are therefore immutable.

Variables of these types cannot be set to nil unless a ? follows the type to indicate that it is optional. See the "Optionals" section later.

The type function returns the type of its argument as a String.

var c: Character = "x"
print(type(of: c)) // "Character"

Bool Type

The Bool type has two possible values, true and false.

Bool instance properties include the following:

Bool type methods include, but are not limited to the following:

Bool instance methods include, but are not limited to the following:

Note that myBool.toggle() is equivalent to myBool = !myBool.

Numeric Types

The type hierarchy of Swift numeric types is:

• Numeric
  • BinaryInteger
    • UnsignedInteger
      • UInt*
    • SignedInteger
      • Int*
    • FixedWidthInteger
      • Int* and UInt*
  • SignedNumeric
    • SignedInteger (see above)
    • FloatingPoint
      • BinaryFloatingPoint
        • CGFloat, Float*, and Double

The Int, Float, and Double types have some common properties and methods. But some are not shared by all of these types.

Global numeric constants include:

Number type properties include the following:

Number type methods include, but are not limited to the following:

// Generate a random integer from 0 to 9.
// This can also be used on the Float and Double types.
let r = Int.random(in: 0...10)

Number instance methods include, but are not limited to the following:

Many more math functions are defined in the Foundation framework. This "provides a base layer of functionality for apps and frameworks, including data storage and persistence, text processing, date and time calculations, sorting and filtering, and networking." Many math functions can only be used if the Foundation framework is imported.

import Foundation
print(abs(3.7)) // gives absolute value which is 3.
print(sin(45.0)) // 0.8509...

Numeric Foundation functions include:

To create an Int by rounding a Double, use Int(myDouble.rounded()).

To format a Double value as a String with a limited number of decimal places use the String initializer that takes a format string and the value. For example:

let angle = 57.2169308
let formatted = String(format: "Angle: %.2f", angle) // 57.22

Measurement Type

The Measurement struct from the Foundation library is used to specify a quantity (Double) with a unit of measure. Values of this type can be passed to the Text initializer along with a format argument of type Measurement.FormatStyle.

The supported quantity types include UnitAcceleration, UnitAngle, UnitArea, UnitDispersion, UnitDuration, UnitElectricalCharge, UnitElectricalCurrent, UnitEnergy, UnitFrequency, UnitFuelEfficiency, UnitIlluminance, UnitLength, UnitMass, UnitPoint, UnitPower, UnitPressure, UnitSpeed, UnitTemperature, and UnitVolume. Each of these define a set of class properties that specify the supported units. For example, UnitLength defines the metric system class properties millimeters, centimeters, meters, and kilometers, the imperial system class properties inches, feet, yards, and miles, and many more.

A Measurement has a value and a unit.

Measurements support many operators including +, -, *, /. These operators return a new Measurement instance. Only one operand can be a Measurement. The other must be a number.

Measurements support comparison operators like ==, <, and >.

Measurements can be converted to compatible units.

For example:

let metricLength = Measurement(value: 10, unit: UnitLength.centimeters)
let imperialWidth = Measurement(value: 7, unit: UnitLength.inches)
let metricWidth = imperialWidth.converted(to: metricLength.unit)
let metricArea = Measurement(
    value: metricLength.value * metricWidth.value,
    unit: UnitArea.squareCentimeters
) // 177.8 square centimeters

The SwiftUI Text view supports displaying Measurement instances including their value and unit.

String Type

The String type is a struct that represents a sequence of Unicode characters. Literal Character and single-line String values are both delimited by double-quotes.

The type StaticString represents text that is known at compile-time which means it is not formed using string interpolation.

Multi-line String values are delimited by triple double-quotes that are on their own lines. The lines of text between the delimiters should not be indented because indentation whitespace is retained. Newline characters other than the first and last are retained unless each line but the last ends with a backslash. For example:

let someParagraph = """
The newline at the end of this line is retained.
But the newline here is not retained \
because the line ends with a backslash.
"""

Strings are value types. This means that assigning a String variable to another makes a copy rather than assigning a reference to the same memory.

To insert expressions in string values use the string interpolation syntax.

let item = "milk"
let price = 2.59
let taxRate = 0.8
print("item \(item) costs \(price * (1 + taxRate))") // single string
print("item", item, "costs", price * (1 + taxRate)) // alternative

String interpolation is more efficient than concatenating several strings. For example, "\(s1)\(s2)\(s3)" is more efficient than s1 + s2 + s3.

There are two approaches that can be used to included double quotes in a string. The first is to escape them by preceding them with a backslash. The second is to use a raw string which surrounds a string literal with # characters.

Raw strings differ in the following ways from normal strings:

• A double quote character doesn't terminate the string unless it is followed by a # character.
• A backslash is treated as a literal character rather than as an escape character.
• String interpolation requires the syntax \#(expression) rather than \(expression).

The following code demonstrates both approaches:

let s1 = "She said \"goodbye for now\" and turned to leave."
let s2 = #"She said "goodbye for now" and turned to leave."#

A new string can be created by concatenating existing strings using the + operator.

A string can be appended to an existing string variable using the += operator.

To iterate over the characters in a String, use a for-in loop or the forEach method.

let name = "Mark"

for c in name {
  print(c)
}

name.forEach({(c: Character) -> Void in print(c)})
name.forEach({c in print(c)}) // same as previous line

String instance properties include the following:

String instance methods include, but are not limited to the following:

Indexes into strings have the type String.Index rather than Int. This makes many string operations more verbose than in other languages because obtaining a String.Index value requires a method call.

For example, the following gets the 2nd and 3rd characters of a string.

let name = "Mark"
let start = name.index(name.startIndex, offsetBy: 1)
let end = name.index(start, offsetBy: 1)
print(name[start...end]) // "ar"

Getting the character at a given index requires using the index method which makes if quite verbose.

let name = "Mark"
print(name[name.index(name.startIndex, offsetBy: 2)]) // "r"

Fortunately we can override the subscript operator in an extension to make this easier.

extension String: BidirectionalCollection {
    subscript(i: Index) -> Character { return characters[i] }
}

print(name[2]) // "r"

Comparing strings in a case-insensitive way is quite verbose.

if s1.name?.caseInsensitiveCompare(s2) == .orderedSame {
    print("s1 and s2 are the same when not considering case.")
}

Strings that contain numbers can be converted to numbers using casting which returns an optional. The following code demonstrates three approaches.

let i = "3"
let f = "3.14"
let d = "3.14159"

// "Int" returns an "optional".
// "if let" unwraps it if the conversion is successful.
// See the "Optionals" section for details.
if let number = Int(i) {
    print(number * 2) // 6
}

// Using nil-coalescing
print((Float(f) ?? 0) + 2) // 5.14

let number = Double(d)
if number != nil {
    // Using force unwrap
    print(number! + 2) // 5.14159
}

To create a String from a number with a specific format, use the NumberFormatter class. For example, this creates a String where that contains grouping commas:

let value = 1234567
let formatter = NumberFormatter()
formatter.numberStyle = .decimal
let number = NSNumber(value: value)
let formatted = formatter.string(from: number) ?? "" // 1,234,567

The formatted method can be applied to many kinds of values to produce a locale-specific, formatted string. See the example code at FormattingDemo.

Many String methods return a String.SubSequence. Values of this type cannot be passed to functions that expect a String. There are two ways to resolve this. One is to pass the SubSequence to the String initializer to obtain a compatible value. The other is to change the function parameter type to any StringProtocol which works because both String and String.SubSequence conform to that protocol. For example:

func printString(_ s: String) {
    print(s)
}

func printStringProtocol(_ sp: any StringProtocol) {
    print(sp)
}

let s = "test" // String
let ps = s.prefix(2) // String.SubSequence
printString(String(ps)) // "te"
printStringProtocol(ps) // "te"

Character Type

The Character type is a struct that represents a single Unicode character. Literal Character values are delimited by double-quotes.

Character instance properties include the following:

Character instance methods include, but are not limited to the following:

Dates

Swift provides the Date and Calendar structs for operating on dates.

To represent a date that is before all real dates, use Date.distantPast.

To represent a date that is after all real dates, use Date.distantFuture.

The formatted method can return part of a Date as a String. For example:

let now = Date() // run on September 3, 2022 at 2:16:41 PM
print(now.formatted(.dateTime.day())) // 3
print(now.formatted(.dateTime.dayOfYear())) // 246
print(now.formatted(.dateTime.era())) // AD
print(now.formatted(.dateTime.hour())) // 2 PM
print(now.formatted(.dateTime.minute())) // 16
print(now.formatted(.dateTime.month(.wide))) // September
print(now.formatted(.dateTime.quarter())) // Q3
print(now.formatted(.dateTime.second())) // 41
print(now.formatted(.dateTime.timeZone())) // CDT
print(now.formatted(.dateTime.week())) // 36
print(now.formatted(.dateTime.weekday(.wide))) // Saturday
print(now.formatted(.dateTime.year())) // 2022

For custom date formats, create a DateFormater object, set its dateFormat property, and call its string method, passing it a Date object. The characters that can be used in dateFormat strings are summarized in Date Format Cheatsheet and NSDateFormatter.

For example:

var formatter = DateFormatter()
formatter.dateFormat = "h a" // just the hour and AM/PM
let now = Date()
let dateString = formatter.string(from: now)

Date/time strings in ISO 8601 format have content like "2022-08-30T15:39:19Z". To convert one of these strings to a Swift Date:

let formatter = ISO8601DateFormatter()
let date = formatter.date(from: dateString) ?? .now

To get the number of days between two dates:

let days = Calendar.current.dateComponents(
    [.day], from: date1, to: date2
).day ?? 0

Ranges

There are many uses of ranges including:

• iterating over a range of values
• checking whether a value is in a range
• extracting a subset of data from a collection
• modifying a subset of a collection

Swift supports four kinds of ranges.

• Range: start..<end

  This is half-open, meaning that the end index is not included. CountableRange is a typealias of this type.

• ClosedRange: start...end This is a closed, meaning that the end index is included. CountableClosedRange is a typealias of this type.

• PartialRangeFrom: start...

  This is one-sided, meaning that the end index is not specified.

• PartialRangeUpTo: ..<end This is one-sided at the end, meaning that the start index is not specified.

A range can be assigned to a variable.

let r = 2...4

To determine if a number is in a range, pass it to the contains method.

print(r.contains(3)) // true
print(r.contains(5)) // false

To iterate over the values in a range, use a for-in loop.

for n in r {
  print(n)
}

Enumerations

Enumerations are declared with the enum keyword. They have a name and a list of possible cases. Each case has a name and an optional value that can be any type, though Int, and String are common types. By convention both enum names and case names use camel-case, but enum names begin uppercase and case names begin lowercase. These names should be singular rather than plural.

Enums are value types like structs. When an enum value is assigned to a variable or passed to a function, it is copied rather than using a reference.

When case values are provided, their type must be specified after the enum name. These values are accessed with the rawValue property. TODO: Why doesn't an enum name evaluate to its value like in other languages so rawValue would not be needed? TODO: Why isn't this property just named value?

If a type is provided after the enum name, any cases without specified values are given default values. For example, if the type is Int, incrementing values starting with zero are assigned. When the type is String, values matching the case name are assigned.

If no type is provided, the cases are not assigned default values. This differs from many other programming languages.

enum Color {
    // Multiple cases can be specified on the same line.
    case red, green, blue
}

// The cases here have specified values.
enum ColorHex: String {
    case red = "ff0000"
    case green = "00ff00"
    case blue = "0000ff"
}

When the type of a value can be inferred to be a specific enum type, a value can be specified with only a period followed by a case name as a shorthand. This is a distinguishing feature of Swift and is used frequently.

var c1 = Color.red
print(c1.rawValue) // ff0000
var c2: Color = .red // using shorthand
print(c2.rawValue) // ff0000

switch c1 {
case .red:
    print("hot") // this prints
case .green:
    print("warm")
case .blue:
    print("color")
}

An enumeration case value can have associated data specified as a list. Each piece of associated data:

• must specify its type
• can have a name for documentation, but is identified by position when used
• can have a default value which makes it optional to specify a value when creating an instance

Typically a switch statement is used to evaluate enum instances and take different actions based on the case. These must be exhaustive, meaning that either there is a case for every possible value or the default case must be specified.

For example:

enum Activity {
    case swim(googles: Bool, inPool: Bool = true)
    case bike(Bike) // this associated data item has no name
    case run(shoes: Shoe)
    case sleep // no associated data
}

// CustomStringConvertible is a protocol implemented by types that can
// be converted to a string using the computed property "description".
struct Bike: CustomStringConvertible {
    var brand: String
    var model: String
    var description: String { "\(brand) \(model)" }
}

struct Shoe: CustomStringConvertible {
    var brand: String
    var model: String
    var description: String { "\(brand) \(model)" }
}

func printActivity(_ activity: Activity) {
    switch activity {
    // Variable names are not required to match associated data names.
    // These become local variables that are scoped to the case.
    // _ can be used for a name if it isn't used.
    case .swim(let g, let inP):
        print("swimming \(inP ? "in" : "out of") a pool \(g ? "with" : "without") goggles")
    case .bike(let bike):
        print("riding a \(bike)") // uses description
    case .run(let shoes):
        print("running in \(shoes) shoes") // uses description
    case .sleep:
        print("sleeping")
    }
}

var activity: Activity = .swim(googles: true)
printActivity(activity) // swimming in a pool with googles
activity = .bike(Bike(brand: "Cannondale", model: "Topstone"))
printActivity(activity) // riding a Cannondale Topstone
activity = .run(shoes: Shoe(brand: "Hoka", model: "Clifton"))
printActivity(activity) // running in Hoka Clifton shoes
activity = .sleep
printActivity(activity) // sleeping

If an enum conforms to the CaseIterable protocol then its cases will be held in the allCases type property. This can be used to iterate over the cases. If a value type is also specified, it must appear before CaseIterable.

enum Color: String, CaseIterable {
    case red = "ff0000"
    case green = "00ff00"
    case blue = "0000ff"
}

print(Color.allCases.count) // 3
for color in Color.allCases {
    print(color) // red, green, and blue
}

Like structs and classes (described later), enumerations can define initializers, computed properties, and methods. Enumerations cannot have regular (non-computed) properties. The following enum defines a computed property and a method.

enum Color: String, CaseIterable {
    case red = "ff0000"
    case green = "00ff00"
    case blue = "0000ff"

    // Computed property
    var redHex: Substring {
        let hex = self.rawValue
        let start = hex.startIndex
        let end = hex.index(start, offsetBy: 1)
        return hex[start...end]
    }

    // Method
    func greenHex() -> Substring {
        let hex = self.rawValue
        let start = hex.index(hex.startIndex, offsetBy: 2)
        let end = hex.index(start, offsetBy: 1)
        return hex[start...end]
    }


    func temperature() {
        // Methods can test for the case by switching on "self".
        switch self {
        case .red: print("hot")
        case .green: print("comfortable")
        case .blue: print("cold")
        }
    }
}

print(Color.red.redHex) // ff
print(Color.green.redHex) // 00
print(Color.red.greenHex()) // 00
print(Color.green.greenHex()) // ff
let color: Color = .red
print(color.temperature()) // hot

Generics

Swift supports generic types. These can be used in many settings including struct, class, and function definitions.

The following example defines a Stack where all the elements have the same type. The element type must be specified when a Stack instance is created using a "type parameter".

Any number of type parameters can be specified inside angle brackets, separated by commas. By convention, type parameter names are CamelCase, beginning with an uppercase letter. Type parameters can be used anywhere a type can appear inside the definition including properties, variables, parameters, and return types.

struct Stack<Element> {
    var elements: [Element] = []

    mutating func push(_ item: Element) {
        elements.append(item)
    }

    mutating func pop() -> Element {
        return elements.removeLast()
    }
}

var s = Stack<String>()
s.push("Moe")
s.push("Larry")
s.push("Curly")
//s.push(7) // Cannot convert value of type 'Int' to expected argument type 'String'
print(s.pop()) // Curly
print(s.pop()) // Larry
print(s.pop()) // Moe

The following code demonstrates implementing and using a generic linked list:

class Node<T> {
    var value: T
    var next: Node<T>? // cannot use Self

    init(value: T, next: Node<T>? = nil) {
        self.value = value
        self.next = next
    }

    func log() {
        print("\(value)")
        if let next = next {
            next.log()
        }
    }
}

typealias INode = Node<Int>
var node1 = INode(value: 1)
var node2 = INode(value: 2)
node1.next = node2
var node3 = INode(value: 3)
node2.next = node3
// Alternate version of the previous 5 lines.
// var node1 = INode(value: 1, next: INode(value: 2, next: INode(value: 3)))
node1.log()

typealias SNode = Node<String>
var fruitList = SNode(
    value: "apple",
    next: SNode(value: "banana", next: SNode(value: "cherry"))
)
fruitList.log()

The type of a type parameter can be constrained to only types that conform to given protocols using the where keyword. For example:

// The Equatable protocol requires a type
// to implement the == and != operators.
// The Identifiable protocol requires a type
// to have an "id" property that uniquely identifies an instance.
struct Stack<Element> where Element: Equatable & Identifiable {
    ...
}

There are two ways to define functions that take generic arguments. These are equivalent, but the second is easier to read.

func update<T: CloudKitable>(item: T) async throws { ... }

func update(item: some CloudKitable) async throws { ... }

Collection Types

Swift provides several generic collection types.

All of these types are defined as structs.

When a variable is set to a collection instance, the elements in the collection can be modified. However, when a constant is initialized to a collection instance, the elements in the collection cannot be modified.

The following is a partial class hierarchy of the collection types provided by Swift, including the protocols to which they conform:

• Sequence protocol
  • Collection protocol
    • Dictionary struct
    • Range struct
    • Set struct
    • Slice struct
    • BidirectionalCollection protocol
      • RandomAccessCollection protocol
        • Array struct
        • Data struct - byte buffer
        • range struct
      • Range struct
      • String
    • MutableCollection protocol
      • Array struct
      • Data struct - byte buffer
      • Dictionary.Values struct

The Sequence protocol defines operations for collections that "provide sequential, iterated access to their elements". Iterating can be destructive to the elements.

The Collection protocol defines operations for collections that "can be traversed multiple times, nondestructively, and accessed by an indexed subscript".

The MutableCollection protocol defines operations that change the values of elements. Methods include reverse, shuffle, and sort.

When an instance is assigned to another variable or passed to a function, a copy-on-write version is created that shares the data with the original. Operations that attempt to modify an instance have two possible behaviors. If there is only one reference to the object, it is modified in place. Otherwise the data is copied before being modified.

From "The Swift Programming Language":

Collections defined by the standard library like arrays, dictionaries, and strings use an optimization to reduce the performance cost of copying. Instead of making a copy immediately, these collections share the memory where the elements are stored between the original instance and any copies. If one of the copies of the collection is modified, the elements are copied just before the modification. The behavior you see in your code is always as if a copy took place immediately.

Arrays

Arrays can be created by listing elements in square brackets, separated by commas.

var scores = [2, 5] // type is inferred to be [Int]

var numbers: [Int] = [] // can't infer type, so must specify; uses short form
var numbers: Array<Int> = [] // same as previous line; uses long form
var numbers = [Int]() // same as previous lines

var zeros = Array(repeating: 0, count: 5) // array containing 5 zeros

To append new elements to an array:

scores += [10, 3] // now [2, 5, 10, 3]
scores.append(9) // can only pass one value; now [2, 5, 10, 3, 9]

To change values at specific indexes:

scores[0] = 4 // now [4, 5, 10, 3, 9]
scores[2...3] = [1, 2] // inclusive range; now [4, 5, 1, 2, 9]

To iterate over the elements in an Array, use a for/in loop.

for score in scores {
    print(score)
}

To iterate over the indices in an Array, use a for/in loop.

for index in 0..<scores.count {
    print(score)
}

// This is equivalent and reads better.
for index in scores.indices {
    print(score)
}

To access both the index and value of each element, use the enumerated method.

for (index, score) in scores.enumerated() {
    print("score \(index + 1): \(score)")
}

Array instance properties include the following:

Array instance methods include, but are not limited to the following:

Here are examples of using some of these methods.

let data = [1, 4, 7, 10, 16]

let doubled = data.map { $0 * 2 } // uses a trailing closure
print(doubled) // [2, 8, 14, 20, 32]

let allData = [1, nil, 7, nil, nil, 10]
let goodData = allData.compactMap { $0 }
print(goodData) // [1, 7, 10]

let evens = data.filter { $0 % 2 == 0}
print(evens) // [4, 10, 16]

// This shows three ways to use the Array reduce method to sum numbers.

// Passing a closure as the last argument.
let sum = data.reduce(0, {acc: Int, n: Int in acc + n}) // 38

// Using a trailing closure.
let sum = data.reduce(0) {acc: Int, n: Int in acc + n} // 38

// Passing a binary operator.
// This works because binary operators are
// implemented as functions that take two arguments
let sum = data.reduce(0, +) // 38
print(sum)

let prices = [1.23, 5.79, 3.48]
let quantities = [5, 2, 4, 7, 1] // 7 and 1 are ignored
// The zip function only takes two sequences
// and only uses elements up to the shortest count.
// It returns a Sequence, not an Array.
let zipped = Array(zip(prices, quantities))
print(zipped) // [(1.23, 5), (5.79, 2), (3.48, 4)]
print(zipped[2].0) // 3.48

Many Array methods return an Array.SubSequence. Values of this type cannot be passed to functions that expect an Array. There are two ways to resolve this. One is to pass the SubSequence to the Array initializer to obtain a compatible value. The other is to change the function parameter type to any Sequence which works because both Array and Array.SubSequence conform to that protocol. For example:

func printArray(_ array: [Any]) {
    for item in array {
        print(item)
    }
}

func printSequence(_ seq: any Sequence) {
    for item in seq {
        print(item)
    }
}

let a = [1, 2, 3, 4] // Array<Int>
let pa = a.prefix(2) // Array<Int>.SubSequence
printArray(Array(pa)) // 1 and 2
printSequence(pa) // 1 and 2

Sets

Sets are created by assigning an Array literal or by passing elements to the Set initializer.

// The type of the following is inferred to be Set<String>.
var cards: Set = ["5C", "KH"] // 5 of clubs and King of hearts

var cards = Set<String>() // starts empty; can't infer type so must specify

To add an element, use the insert method:

cards.insert("AD") // Ace of diamonds

To iterate over the elements in a Set, use a for/in loop.

for card in cards { // elements are unordered
    print(card)
}

To iterate over the elements in a Set in sorted order, add use of the sorted method.

for card in cards.sorted() {
    print(card)
}

The == operator can be used to determine if two sets contain the same elements.

Set instance properties include the following:

Set instance methods include, but are not limited to the following:

Dictionaries

Dictionaries are hash tables that hold key/value pairs. They can be created by listing key/value pairs in square brackets, separated by commas. Keys and values are separated by colons.

While typically the keys are strings, they can be any type that conforms to the Hashable protocol. Tuples cannot be made to conform to Hashable, so they cannot be used as Dictionary keys. For details on the Hashable protocol, see the Apple Developer Documentation.

// When the type can't be inferred, it must be specified.
// The syntax for an empty Dictionary includes a colon.
var pairs: [Int : String] = [:] // uses short form of the type
var pairs: Dictionary<Int, String> = [:] // same as previous line; uses long form
var pairs = [Int : String]() // same as previous lines

// The type of fruitColors is inferred to be [String : String].
var fruitColors = ["apple": "red", "banana": "yellow", "orange": "orange"];

To set the value of a given key, use the subscript operator [] and an assignment.

fruitColors["strawberry"] = "red"

To get the value of a given key, use the subscript operator [] which returns an Optional:

let color = fruitColors["banana"]; // Optional("yellow")

To delete a key pair:

fruitColors.removeValue(forKey: "banana") // returns value
fruitColors["banana"] = nil // same, but shorter and doesn't return value

To iterate over the keys and values in a Dictionary, use a for/in loop.

for (name, color) in fruitColors {
    print("\(name) is \(color)")
}

To iterate over the keys in a Dictionary, use a for/in loop.

for name in fruitColors.keys { // can add .sorted()
    print("name is \(name)")
}

To iterate over the values in a Dictionary, use a for/in loop.

for color in fruitColors.values { // can add .sorted()
    print("color is \(color)")
}

The default argument provides default values for missing keys.

// This holds the sum of the scores for each person.
var scoreMap: [String: Int] = [:]

func addScore(_ score: Int, to name: String) {
    scoreMap[name, default: 0] += score
}

addScore(85, to: "Mark")
addScore(90, to: "Tami")
addScore(93, to: "Mark")
print(scoreMap) // ["Mark": 178, "Tami": 90]

// This holds an Array of all the scores for each person.
var scoresMap: [String: [Int]] = [:]

func collectScore(_ score: Int, to name: String) {
    scoresMap[name, default: []].append(score)
}

collectScore(85, to: "Mark")
collectScore(90, to: "Tami")
collectScore(93, to: "Mark")
print(scoresMap) // ["Mark": [85, 93], "Tami": [90]]

To create a Dictionary from an array of objects where the keys are the values of a given property in the objects and the values are arrays of the objects that have that property value, use the Dictionary initializer that takes grouping and by arguments. For example:

struct City {
    let name: String
    let country: String
}

let cities = [
    City(name: "Chicago", country: "USA"),
    City(name: "London", country: "England"),
    City(name: "Manchester", country: "England"),
    City(name: "New York", country: "USA"),
]

let cityDict = Dictionary(grouping: cities, by: \.country)
// Keys are "England" and "USA".
// Value for England is an array of City objects for London and Manchester.
// Value for USA is an array of City objects for Chicago and New York.

Dictionary instance properties include the following:

Dictionary instance methods include, but are not limited to the following:

Here are examples of using some of these methods.

let scoreDict = ["Mark": 19, "Tami": 20, "Amanda": 18, "Jeremy": 17]
let allOdd = scoreDict.allSatisfy({$0.value % 2 == 1}) // false
let someOdd = scoreDict.contains(where: {$0.value % 2 == 1}) // true
let odds = scoreDict.filter({$0.value % 2 == 1}) // includes Mark & Jeremy elements
let upperNames = scoreDict.map({$0.key.uppercased()}) // array of uppercase names
let doubledScoresDict = scoreDict.mapValues({$0 * 2}) // scoreDict w/ doubled scores
scoreDict.removeValue(forKey: "Mark")
let sorted = scoreDict.sorted(by: {$0.value > $1.value}); // descending

Tuples

To define a tuple type, provide a list of elements types in parentheses. These can be named or unnamed. Access elements by zero-based index or by name.

typealias MyUnnamedTuple = (Bool, Int, String)
let t1: MyUnnamedTuple = (true, 19, "Mark")
print(t1.1) // accessed by zero-based index; 19

typealias MyNamedTuple = (happy: Bool, score: Int, name: String)
let t2: MyNamedTuple = (happy: true, score: 19, name: "Mark")
print(t2.score) // accessed by name; 19

The elements of a tuple can be assigned to variables using destructuring, All of the elements must be assigned, not just a subset.

let myTuple = (true, "test", 1, 2.3)
let (b, s, i, d) = myTuple

Swift only supports destructuring of tuples, not arrays or objects.

To sort an array of objects based on multiple properties, use tuples. For example:

struct Person {
    let firstName: String
    let lastName: String
    let country: String
}

let people = [
    Person(firstName: "Mark", lastName: "Volkmann", country: "USA"),
    Person(firstName: "Tami", lastName: "Volkmann", country: "USA"),
    Person(firstName: "Stewart", lastName: "Lynch", country: "Canada"),
    Person(firstName: "Paul", lastName: "Hudson", country: "England"),
]

// Sorts on country first, then lastName, then firstName.
let sortedPeople = people.sorted {
    ($0.country, $0.lastName, $0.firstName) <
        ($1.country, $1.lastName, $1.firstName)
}

Regular Expressions

Swift 5.7 added support for regular expressions.

The Regex struct represents a regular expression. Instances can be created in three ways:

• Use the literal syntax that surrounds the regular expression with slashes.
• Use one of several Regex initializers.
• Use the RegexBuilder framework which supports passing a closure to Regex that contains DSL-like syntax using types defined by this framework.

Here are examples that capture data from a sentence describing a sports score:

// This import is only needed to use types defined by the RegexBuilder
// framework such as One, Optionally, ZeroOrMore, OneOrMore, Repeat,
// ChoiceOf, Capture, TryCapture, and Reference.
import RegexBuilder

let sentence = "The Chiefs defeated the Eagles 38 to 35." // 2023 Super Bowl

// This is the type of a Regex that has five capture groups.
// The generic type is a tuple containing the capture types.
// The return value of some Regex and String methods is a
// Regex.Match object whose `output` property has this generic type.
typealias MyRegex =
    Regex<(Substring, Substring, Substring, Substring, Substring)>

// This is a compile-time regular expression.
// These are parsed at compile-time to verify that their syntax is correct.
// They use the same syntax as Perl, Python, Ruby,
// and many other programming languages.
// #/.../# is the extended delimiter syntax which is usually needed
// for Swift to correctly interpret any non-trivial regular expression
// and also to prevent Xcode from adding spaces inside it.
// Adding ?: inside parentheses allows a choice
// between words to be matched, but not captured.
let re1: MyRegex = #/^The (\w+) (?:beat|defeated) the (\w+) (\d+) to (\d+).$/#

// This is a runtime regular expression,
// useful when string interpolation is used to define
// the regular expression using data only known at runtime.
let namePattern = #"\w+"#
let scorePattern = #"\d+"#
let winWords = "(?:beat|defeated)"
let re2: MyRegex = try! Regex(
    "The (\(namePattern)) \(winWords) the (\(namePattern)) " +
        "(\(scorePattern)) to (\(scorePattern))."
)

// This regular expression is defined using the builder syntax.

// `OneOrMore` is a struct defined by the RegexBuilder framework.
// Other such structs include:
// - `One`: exactly one
// - `Optionally`: zero or one
// - `OneOrMore`: one or more
// - `Repeat`: range of occurrences

// `word` and `digit` are static properties of the `RegexComponent` protocol.
// `word` represents a single word character
// `digit` represents a single digit
// Other static properties include
// `whitespace`, `any`, `anyOf(sequence)`, and more.

let name = OneOrMore(.word)
let score = OneOrMore(.digit)
// Use .any to match any single character.

let re3: MyRegex = Regex {
    // Builder types that can be used here include
    // One, Optionally, ZeroOrMore, OneOrMore, Repeat,
    // ChoiceOf, Capture, and TryCapture.
    "The "
    Capture { name }
    " "
    ChoiceOf {
        "beat"
        "defeated"
    }
    " "
    Capture { name }
    " "
    Capture { score }
    " to "
    Capture { score }
    "."
}

Each of the regular expressions defined above produce the same results. The following code demonstrates using each of them. The match variable below is a Match struct instance. This has an output property whose value is a tuple containing the full match and each of the capture group values.

func tryRegex(_ re: MyRegex) {
    if let match = sentence.firstMatch(of: re) {
    // The previously line can also be written as follows:
    // if let match = try! re.firstMatch(in: sentence) {
        // This uses an underscore to ignore the full match value.
        let (_, team1, team2, score1, score2) = match.output
        print(team1) // Chiefs
        print(team2) // Eagles
        print(score1) // 38
        print(score2) // 35
    } else {
        print("not matched")
    }
}

tryRegex(re1)
tryRegex(re2)
tryRegex(re3)

The builder syntax supports transforming captured text to a type other than String. For example, we can change the type and definition of re3 defined above to the following so that the captured scores have Int values.

typealias MyTypedRegex = Regex<(Substring, Substring, Substring, Int, Int)>

let name = OneOrMore(.word)
let score = OneOrMore(.digit)

let re3: MyTypedRegex = Regex {
    "The "
    Capture { name }
    " "
    ChoiceOf {
        "beat"
        "defeated"
    }
    " the "
    Capture { name }
    " "
    Capture {
        score
    } transform: {
        Int($0)! // safe because this only matches digits
    }
    " to "
    Capture {
        score
    } transform: {
        Int($0)! // safe because this only matches digits
    }
    "."
}

The String methods contains, firstMatch, wholeMatch, prefixMatch, starts, replacing, and trimmingPrefix can take regular expressions as arguments. The following code demonstrates each of these:

let digitsRE = #/\d+/#

// This tests whether any part of a String matches a Regex
// and returns a Bool value.
print(sentence.contains(digitsRE)) // true

// This finds any match of the Regex in a String.
// This tests whether any part of a String matches a Regex.
if let result = sentence.firstMatch(of: digitsRE) {
// The previously line can also be written as follows:
// if let result = try! digitsRE.firstMatch(in: sentence) {
    print(result.output) // 38
}

// This tests whether a whole String matches a Regex.
let wholeRE = #/^The (\w+) (?:beat|defeated) the (\w+) (\d+) to (\d+).$/#
if let result = sentence.wholeMatch(of: wholeRE) {
// The previous line can also be written as follows:
// if let result = try wholeRE.wholeMatch(in: sentence) {
    // result.output is a tuple that can be destructured.
    let (whole, name1, name2, score1, score2) = result.output
    print(whole) // The Chiefs defeated the Eagles 38 to 35.
    print(name1) // Chiefs
    print(name2) // Eagles
    print(score1) // 38
    print(score2) // 35
}

let prefixRE = #/The (\w+) /#
if let result = sentence.prefixMatch(of: prefixRE) {
// The previous line can also be written as follows:
// if let result = try prefixRE.prefixMatch(in: sentence) {
    let (whole, name) = result.output
    print(whole) // The Chiefs
    print(name) // Chiefs
}

if sentence.starts(with: prefixRE) {
    print("starts with success")
}

let newSentence = sentence.replacing(digitsRE, with: "?")
print(newSentence) // The Chiefs defeated the Eagles ? to ?.

let trimmedSentence = sentence.trimmingPrefix(prefixRE)
print(trimmedSentence) // defeated the Eagles 38 to 35.

let family = "Mark, Tami, Amanda, and Jeremy"
let names = family.split(separator: #/, and |, /#)
print(names) // ["Mark", "Tami", "Amanda", "Jeremy"]

A regular expression can ignore case as shown in the following example:

// let re = /test/i // This syntax is not supported.
let re = /test/.ignoresCase(true)
print("test".contains(re)) // true
print("Test".contains(re)) // true
print("TEST".contains(re)) // true
print("tes".contains(re)) // false

There were plans to allow switch cases to match regular expressions. It was shown in the WWDC video Swift Regex: Beyond the basics but it doesn't seem to be supported yet. See this StackOverflow post.

func classify(_ token: String) {
    switch token {
    case /\d+/:
        print("found number")
    case /\w+/:
        print("found word")
    default:
        print("found something else")
    }
}

classify("123")
classify("Hello")
classify("!@#")

Xcode can convert a literal regular expression to a Regex Builder. To do this, right-click anywhere in a literal regular expression and select Refactor ... Convert to Regex Builder.

For example, here is a line we saw earlier that defines a literal regular expression:

let re1: MyRegex = #/^The (\w+) (?:beat|defeated) the (\w+) (\d+) to (\d+).$/#

Converting this results in the following:

let re1: MyRegex = Regex {
    /^/
    "The "
    Capture {
        OneOrMore(.word)
    }
    " "
    // Without the ?: in the parentheses of the literal regular expression
    // this would be wrapped in a Capture.
    ChoiceOf {
        "beat"
        "defeated"
    }
    " the "
    Capture {
        OneOrMore(.word)
    }
    " "
    Capture {
        OneOrMore(.digit)
    }
    " to "
    Capture {
        OneOrMore(.digit)
    }
    /./
    /$/
}

Variables

Mutable variables are declared with the var keyword. Immutable variables are declared with the let keyword. This is an unfortunate choice for JavaScript developers where let is used for mutable variables and const is used for immutable variables.

Variable names can be followed by a colon and a type. They can also be followed by = and an initial value. The type can be omitted if the desired type can be inferred from the initial value.

let name1: String = "Mark" // type and initial value

let name2 = "Mark" // only value; String type is inferred

var score1: Int // only type; can't use until initialized
score1 = 19 // initializes

var score2 = 19 // only value; inferred type is Int

var score3 = 1.23 // inferred type is Double, not Float

Multiple variables can be declared on the same line.

let a = 1, b = 2.3, c = true, d = "test"

var e: Int?, f: Double?, g: Bool?, h: String?
e = 1
f = 2.3
g = true
h = "test"

Swift is able to optimized storage of let variables more than var variables. Because the value of a let variable never changes, its size is known. This allows it to be allocated on the stack rather than the heap. Data on the stack can be accessed more efficiently. Values of let variables can also be inlined in the generated code.

Type Checking and Casting

Basic type names can be used as functions to cast another primitive type to a given type. The Bool and Characters types can be cast to and from a String, but no other types.

The following code demonstrates the supported primitive type casts.

let b = true
let i = 3
let f = 3.14
let d = 3.14159
let c: Character = "4"
var s = "7"

print(String(b)) // "true"

print(Float(i)) // 3.0
print(Double(i)) // 3.0
print(String(i)) // "3"

print(Int(f)) // 3
print(Double(f)) // 3.14
print(String(f)) // "3.14"

print(Int(d)) // 3
print(Float(d)) // 3.14159
print(String(d)) // "3.14159"

print(String(c)) // "4"

let bStr = "true"
print(Character(s)) // "7"; Fatal Error if String contains more than one character
// The remaining examples use nil-coalescing
// because the typecasts return nil if they fail.
print(Bool(bStr) ?? false) // true
print(Int(s) ?? 0) // 7
print(Float(s) ?? 0) // 7.0
print(Double(s) ?? 0) // 7.0

The is operator is used to check the type of an expression and returns a Bool.

The as? operator is used to downcast a value of a superclass type to a value of a subclass type. Since this can fail, it is typically used in an if let statement. The code example below uses the is and as? operators in the evaluate function.

class Animal: CustomStringConvertible {
    var name: String

    init(name: String) {
        self.name = name
    }

    // This is a computed property that is required
    // by the CustomStringConvertible protocol.
    // It is used when a variable of this type
    // is printed or converted to a string.
    public var description: String { return name }
}

class Cat: Animal {
    var declawed: Bool

    init(name: String, declawed: Bool) {
        self.declawed = declawed
        // All properties in this class must be initialized
        // before the superclass init method is called.
        super.init(name: name)
    }
}

class Dog: Animal {
    var hasTail: Bool

    init(name: String, hasTail: Bool) {
        self.hasTail = hasTail
        super.init(name: name)
    }
}

let a = Animal(name: "Mystery")
let c = Cat(name: "Whiskers", declawed: true)
let d = Dog(name: "Comet", hasTail: true)

func evaluate(_ animal: Animal) {
    if animal is Cat {
        print("\(animal) is a cat. ")
    } else if animal is Dog {
        print("\(animal) is a dog.")
    } else {
        print("\(animal) is an unknown kind of animal.")
    }

    // The as? operator attempts to perform downcasting to a subclass type.
    // This is necessary to access properties
    // or call methods defined in a subclass.
    if let cat = animal as? Cat {
        print("has claws? \(!cat.declawed)")
    }
    if let dog = animal as? Dog {
        print("has tail? \(dog.hasTail)")
    }
}

evaluate(a) // Mystery is an unknown kind of animal.
evaluate(c) // Whiskers is a cat.\nhas claws? false
evaluate(d) // Comet is a dog.\nhas tail? true

Optionals

Variables must be assigned a value before they are accessed unless they have an Optional type. This is a generic enum with the following definition:

enum Optional<T> {
    case none
    case some(T) // associated data of type T
}

Adding ? after a type name is syntactic sugar for creating an Optional value. It allows the value to be nil.

The following are equivalent:

There are several ways to extract the value from a variable or property with an optional type.

• if let

  if let unwrapped = someOptional { ... }

  If the value is not nil, it is assigned to the variable value (which is scoped to the block that follows) and the block is executed. If the value is nil, the block is not executed. An else block can be included to specify code to run when the value is nil.

  It is common to unwrap an optional held in a variable (someOptional above) into a variable with the same name (unwrapped above). The one on the left shadows the one on the right inside the block. For example, if let result = result { ... }

• optional chaining

  let value = myOptionalObject?.someProperty;

  This uses the optional chaining operator ?.. If myOptionalObject is nil, value will be set to nil. Otherwise it will be set to the value of someProperty in the object. This operator can also precede method calls to avoid calling them if the receiver is nil.

• nil-coalescing

  let value = myDictionary[someKey] ?? defaultValue

  This uses the nil-coalescing operator ?? to get either the unwrapped value or a default value. The example above gets a value from myDictionary if it exist or uses a default value.

• guard

  guard let value = myOptional else { ... }

  This uses a "guard" to assign the value of an optional to a variable if it is not nil or run the code in the else block if it is nil. In a sense this it the opposite of the if let syntax. It is typically used near the beginning of function bodies to check the value of an argument and exit if it is unacceptable. For this reason, the else block usually contains a return statement.

• force unwrap

  if myOptional != nil { let value = myOptional!; ... }

  This uses the ! operator to "force unwrap" an optional. If the optional set to nil, the program will crash with a fatal error. Use this option only when the value should never be nil.