Swift Error Handling

• Error handling addresses and recovers from error conditions during program runtime in Swift.
• Swift provides built-in support for throwing, catching, propagating, and handling recoverable errors.
• Error handling is crucial when operations may not always complete or produce valid output.
• Optionals represent the absence of a value, but understanding failure causes allows for appropriate code response.
• Distinguishing error situations enables a program to resolve some errors and inform the user of unresolvable ones.

Representing and Throwing Errors

• In Swift, the Error protocol represents errors, indicating a type suitable for error handling.
• Swift enumerations effectively model related error conditions and provide associated values for additional error information.
• Throwing an error signals an unexpected event that prevents normal execution flow.
• The throw statement is used to throw an error.
• Example: throw VendingMachineError.insufficientFunds(coinsNeeded: 5) indicates the need for five more coins.

Handling Errors

• When an error is thrown, surrounding code must handle it through correction, alternative approaches, or user notification.
• Four error handling methods exist in Swift: propagating the error, do-catch statements, optional values, or assertion of no error occurrence.
• The try keyword (or try? or try!) identifies code that calls a function, method, or initializer that can throw an error.

Propagating Errors Using Throwing Functions

• The throws keyword in a function declaration indicates that the function, method, or initializer can throw an error.
• A function marked with throws is a throwing function.
• The throws keyword is written before the return arrow (->) if the function specifies a return type.
• Throwing functions propagate errors to the scope from which they are called.
• Example: A VendingMachine class's vend(itemNamed:) method throws a VendingMachineError for invalid selection, out of stock, or insufficient funds.

Handling Errors Using Do-Catch

• A do-catch statement executes a block of code and handles any errors thrown.
• General structure:

do {
    try expression
    statements
} catch pattern 1 {
    statements
} catch pattern 2 where condition {
    statements
} catch {
    statements
}

• If no error is thrown within the do clause, code execution continues without any catch clause being executed
• If an error is thrown that matches a catch clause's pattern, code execution is transferred to the matching catch clause
• If no catch clause matches the error, the error propagates out to the surrounding scope.
• Catch clauses don't have to match every possible error the code in the do clause can throw
• If no pattern is provided, the catch clause matches any error and binds the error to a local constant named error.
• Example of handling vending machine errors:

do {
    try buyFavoriteSnack(person: "Alice", vendingMachine: vendingMachine)
    print("Success! Yummy.")
} catch VendingMachineError.invalidSelection {
    print("Invalid Selection, sorry")
} catch VendingMachineError.outOfStock {
    print("Out of Stock.")
} catch VendingMachineError.insufficientFunds(let coinsNeeded) {
    print("Insufficient funds. Please insert an additional \(coinsNeeded) coins.")
} catch {
    print("Unexpected error: \(error).")
}

• The buyFavoriteSnack(person:vendingMachine:) can throw a VendingMachineError, so it's called with a try expression.
• If an error is thrown, execution immediately transfers to the catch clauses to determine whether the error should be handled.
• If no catch clause matches the error, the error propagates to the surrounding scope.
• catch clauses don't have to match every possible error
• If no pattern is provided, the catch clause matches any error and binds the error to a local constant named error.

Converting Errors to Optional Values

• try? converts an error into an optional value.
• If an error is thrown during evaluation of the try? expression, the value of the expression is nil.
• Example:

func someThrowingFunction() throws -> Int {
    // ...
}

let x = try? someThrowingFunction()

let y: Int?
do {
    y = try someThrowingFunction()
} catch {
    y = nil
}

• If someThrowingFunction() throws an error, the value of x and y is nil.
• Otherwise, the value of x and y is the value that the function returned.
• Using try? allows concise error handling when all errors should be handled the same way.
• Example: Returning nil if all approaches to fetch data fail:

func fetchData() -> Data? {
    if let data = try? fetchDataFromDisk() { return data }
    if let data = try? fetchDataFromServer() { return data }
    return nil
}

Disabling Error Propagation

• try! disables error propagation, asserting that an error will not occur at runtime.
• If an error is thrown, a runtime error is triggered.
• Use when you know a throwing function/method won't throw an error.
• Example: loading an image that ships with the application:

let photo = try! loadImage(atPath: "./Resources/John Appleseed.jpg")

Specifying the Error Type

• Most Swift code handles errors of any type conforming to the Error protocol.
• You might limit code to throwing errors of only one specific type in special cases:
  • Running code on an embedded system that doesn’t support dynamic allocation of memory.
  • When the errors are an implementation detail of some unit of code, like a library, and aren’t part of the interface to that code.
  • In code that only propagates errors described by generic parameters
• typed throws is when the error type is written after throws in the declaration
• Example: Error type

enum StatisticsError: Error {
    case noRatings
    case invalidRating(Int)
}

• Example: The function below throws StatisticsError values as its errors.

func summarize(_ ratings: [Int]) throws(StatisticsError) {
    guard !ratings.isEmpty { throw.noRatings }

    var counts = [1: 0, 2: 0, 3: 0]
    for rating in ratings {
        guard rating > 0 && rating