Handling Multiple Error Types

enum NetworkError: Error {
    case timeout
}
enum ParsingError: Error {
    case malformed
}
func fetchData(shouldTimeout: Bool) throws {
    if shouldTimeout {
        throw NetworkError.timeout
    }
    throw ParsingError.malformed
}
do {
    try fetchData(shouldTimeout: true)
} catch is NetworkError {
    print("A network error occurred")
} catch is ParsingError {
    print("A parsing error occurred")
} catch {
    print("Some other error")
}

enum AppError: Error {
    case notFound(id: Int)
}
func lookup(id: Int) throws {
    throw AppError.notFound(id: id)
}
do {
    try lookup(id: 42)
} catch let appError as AppError {
    print("App error: \(appError)")
} catch {
    print("Unhandled error: \(error)")
}

1. Trying to catch two completely different error enum types in the same single catch clause without pattern matching each type separately.
2. Forgetting a generic catch (with no type) binds a plain Error value, which then requires casting to check a specific concrete error type.
3. Not centralizing related error cases into a shared enum when a function can fail in several closely related ways, spreading complexity across many ad hoc error types.

• Different throwing functions can define and throw their own distinct Error-conforming types.
• A do block can have multiple catch clauses, each matching a specific error type or case.
• A generic catch binds the error as the general Error type, which may need casting to inspect further.
• Grouping related failure cases into one enum keeps error handling for a subsystem organized.