Examples 25-30

Author: tib

contents/[25]error-types/index.md

@@ -4,4 +4,35 @@ description: ""
 order: 25
 ---
 
+In Swift, we often use enums and sometimes structs to create meaningful error representations. An enum must conform to the `Error` protocol to act as an error type:
+
+```swift
+enum NetworkError: Error {
+    case noConnection
+    case timeout
+    case invalidResponse
+}
+```
+
+To create a struct for error representation, just make the struct conform to the `Error` protocol and define the properties that will carry the error details:
+
+```swift
+struct CustomError: Error {
+    let message: String
+    let code: Int
+}
+```
+
+By conforming a struct or enum to the `Error` protocol, you enable these types to be thrown as errors in your code. Using the `throw` keyword, you signal that an error has occurred and that it must be handled appropriately:
+
+```swift
+throw NetworkError.timeout
+
+throw CustomError(
+    message: "Not found", 
+    code: 404
+)
+```
+
+In the following example, you will learn how to properly catch and respond to these thrown errors using Swift's do-catch system.
 

contents/[26]do-catch/index.md

@@ -4,46 +4,74 @@ description: ""
 order: 26
 ---
 
-
-foo
+Effective error handling begins by defining an enum or struct to represent all possible error cases your code might encounter:
 
 ```swift
-let x = 5
-let y = 5
-var z = 0
-
-z = x + y // addition
-print(z) // => 10
-
-z = x - y // subtraction
-print(z) // => 0
-
-z = x * y // multiplication
-print(z) // => 25
-
-z = x / y // division
-print(z) // => 1
-
-
-var x = 10
-
-x += 2 // addition
-print(x) // => 12
-
-x -= 2 // subtraction
-print(x) // => 10
-
-x *= 2 // multiplication
-print(x) // => 20
-
-x /= 2 // division
-print(x) // => 10
+enum InputError: Error {
+    case invalidNumber
+}
+
+print("Please enter a number:")
+let rawInput = readLine() ?? ""
+
+if let numberInput = Int(rawInput) {
+    print(numberInput)
+}
+else {
+    throw InputError.invalidNumber
+}
 ```
 
-bar
+Because the thrown error is not caught or handled, Swift does not know how to proceed and the program immediately crashes with a runtime error. To avoid that crash, we need to wrap the throwing code inside a do-catch block, where we can decide what to do when that specific error happens:
 
-```sh
-swift main.swift
+```swift
+enum InputError: Error {
+    case invalidNumber
+}
+
+enum MathError: Error {
+    case divisionByZero
+}
+
+do {
+    print("Please enter a number:")
+    let rawA = readLine() ?? ""
+
+    if let a = Int(rawA) {
+        
+        print("Please enter a second number:")
+        let rawB = readLine() ?? ""
+        
+        if let b = Int(rawB) {
+            
+            if b == 0 {
+                throw MathError.divisionByZero
+            }
+            else {
+                print(a/b)
+            }
+        }
+        else {
+            throw InputError.invalidNumber
+        }
+    }
+    else {
+        throw InputError.invalidNumber
+    }
+}
+catch is InputError {
+    print("Input error.")
+}
+catch let error as MathError {
+    switch error {
+    case .divisionByZero:
+        print("Division by zero is not possible.")
+    }
+}
+catch {
+    print(error)
+}
 ```
 
-baz
+In this example, both `InputError` and `MathError` are explicitly handled using separate catch blocks. The final catch block serves as a fallback, capturing any errors that do not match the previous cases.
+

contents/[27]throwing-functions/index.md

@@ -4,46 +4,160 @@ description: ""
 order: 27
 ---
 
+In Swift, functions that can throw errors are explicitly marked with the throws keyword. This is the language's way of making error-prone operations visible and intentional.
 
-foo
+```swift
+enum PrinterError: Error {
+    case outOfPaper
+}
+
+func printDocument() throws {
+    throw PrinterError.outOfPaper
+}
+```
+
+You can be explicit about what kind of error a function throws by writing the type in parentheses:
+
+```swift
+func printDocument() throws(PrinterError) {
+    throw PrinterError.outOfPaper
+}
+```
+
+Calling a throwing function is different from calling a regular function. You need to use the `try` keyword to tell the Swift compiler: "I know this might fail, and I'll handle it." You always have to use `try` whether the function throws any error or a specific error type:
+
+```swift
+do {
+    try printDocument()
+    print("Printed successfully.")
+} 
+catch {
+    print("Printing failed: \(error)")
+}
+```
+
+Let's go a bit deeper. First, we define a custom error:
+
+```swift
+struct InputError: Error {
+    let message: String
+}
+```
+
+Then here's a function that can fail by throwing `InputError`:
 
 ```swift
-let x = 5
-let y = 5
-var z = 0
+func readInt(
+    message: String,
+    errorMessage: String
+) throws(InputError) -> Int {
+    print(message)
+    let rawInput = readLine() ?? ""
+    
+    if let number = Int(rawInput) {
+        return number
+    }
+    else {
+        throw InputError(message: errorMessage)
+    }
+}
+```
+
+In this example, the `readInt` is a typed throwing function, it can only throw `InputError`.  If the user input can't be converted to an Int, we throw an `InputError` with a custom message. If the input is fine, we return the number as usual.
 
-z = x + y // addition
-print(z) // => 10
+In the following snippet, we introduce a second error type: 
+
+```swift
+enum MathError: Error {
+    case divisionByZero
+}
+
+func main() throws {
+    let a = try readInt(
+        message: "Please enter A as a number:", 
+        errorMessage: "A is invalid."
+    )
+    let b = try readInt(
+        message: "Please enter B as a number:", 
+        errorMessage: "B is invalid."
+    )     
+    if b == 0 {
+        throw MathError.divisionByZero
+    }
+    else {
+        print(a/b)
+    }
+}
+```
 
-z = x - y // subtraction
-print(z) // => 0
+The `main` function can throw any error because it doesn't specify a type. We call `try` before both calls to `readInt`, because each might throw an `InputError`. We manually check for division by zero and throw a `MathError` if needed.
 
-z = x * y // multiplication
-print(z) // => 25
+We can handle various error types, using catch:
 
-z = x / y // division
-print(z) // => 1
+```swift
+do {
+    try main()
+}
+catch let error as InputError {
+    print(error.message)
+}
+catch let error as MathError {
+    switch error {
+    case .divisionByZero:
+        print("Division by zero is not possible.")
+    }
+}
+catch {
+    print(error)
+}
+```
 
+The `try?` keyword "converts" the throwing function into a non-throwing one. It returns an optional value instead of the original return type. If something goes wrong, `try?` returns `nil` instead of throwing an error and it returns the actual value if the function succeeds-but either way, it returns an optional:
 
-var x = 10
+```swift
+func example() throws -> Int {
+    return 10
+}
 
-x += 2 // addition
-print(x) // => 12
+let number: Int? = try? example()
+print(number ?? -1)
+```
 
-x -= 2 // subtraction
-print(x) // => 10
+Just like `try?`, the `try!` keyword lets you call a throwing function without using a do-catch block. But there's a big difference: if an error happens, that'll cause a fatal error and your app will crash:
 
-x *= 2 // multiplication
-print(x) // => 20
+```swift
+func example() throws -> Int {
+    return 10
+}
 
-x /= 2 // division
-print(x) // => 10
+let number: Int = try! example()
+print(number)
 ```
 
-bar
+The `rethrows` keyword is used in function definitions. It means the function itself doesn't throw errors, but it can pass along errors from a closure parameter that throws:
+
+```swift
+enum CustomError: Error {
+    case ouch
+}
+
+func execute(
+    closure: () throws -> Void
+) rethrows {
+    try closure()
+}
+
+let block: () -> Void = {
+    print("This works without try!")
+}
+
+execute(closure: block)
+
+let throwingBlock: () throws -> Void = {
+    throw CustomError.ouch
+}
 
-```sh
-swift main.swift
+try execute(closure: throwingBlock)
 ```
 
-baz
+The `execute` function accepts a closure that might throw an error. But `execute` itself only rethrows an error if the closure it receives actually throws one. If the closure doesn't throw, `execute` behaves like a normal function. If the closure does throw, `execute` requires you to handle that possibility with try.