Rethrowing functions in Swift - Cheat Sheet & Quick Revision

Recall & Review

beginner

What does it mean when a function is marked as rethrows in Swift?

A rethrows function can only throw an error if one of the functions it calls (passed as parameters) throws an error. It does not throw errors on its own.

beginner

How do you declare a function that can rethrow errors from a closure parameter?

You add the rethrows keyword after the parameter list. For example:
func perform(action: () throws -> Void) rethrows { try action() }

beginner

Can a rethrows function throw an error by itself without calling a throwing function?

No. A rethrows function can only throw if the closure or function it calls throws. It cannot throw errors independently.

intermediate

Why use rethrows instead of throws in Swift?

Using rethrows makes your function safer and clearer. It only throws errors if the passed-in function throws, so callers don’t have to handle errors if the passed function doesn’t throw.

intermediate

Example: What is the output of this Swift code?

func callTwice(action: () throws -> Void) rethrows { try action(); try action() }
try? callTwice { print("Hello") }

Output:
Hello
Hello

Explanation: The closure does not throw, so callTwice runs both times and prints "Hello" twice without error.

What keyword do you use to declare a function that only throws if a passed-in function throws?

A catch

B rethrows

C try

D throws

The rethrows keyword means the function only throws if the function it calls throws.

Can a rethrows function throw an error on its own without calling a throwing function?

A Yes, always

B Only if marked with <code>throws</code>

C No, never

D Only if the closure is non-throwing

A rethrows function cannot throw errors by itself; it only throws if the passed-in function throws.

Which of these is a valid declaration of a rethrowing function?

A func example(action: () -> Void) throws { action() }

B func example() rethrows { throw Error() }

C func example() throws { }

D func example(action: () throws -> Void) rethrows { try action() }

Only option A correctly declares a rethrowing function that calls a throwing closure.

What happens if you call a rethrows function with a non-throwing closure?

A It runs without throwing

B It throws an error

C You must use try

D It crashes

If the closure does not throw, the rethrows function runs without throwing.

Why might you prefer rethrows over throws?

A To allow throwing only when needed

B To avoid using try

C To force error handling always

D To catch errors automatically

rethrows lets the function throw only if the passed-in function throws, making error handling conditional.

Explain in your own words what a rethrowing function is and why it is useful.

Think about when the function throws errors and when it doesn't.

Write a simple Swift function that uses rethrows to call a throwing closure twice.

Use the example: func callTwice(action: () throws -> Void) rethrows { try action(); try action() }

Practice

1. What does the rethrows keyword indicate in a Swift function?

easy

A. The function cannot throw any errors.

B. The function always throws an error regardless of the closure.

C. The function only throws an error if the closure it receives throws an error.

D. The function catches all errors internally and never propagates them.

Solution

1. Step 1: Understand the role of rethrows

   The rethrows keyword means the function itself does not throw errors unless the closure it accepts throws.

2. Step 2: Compare options with this meaning

   The function only throws an error if the closure it receives throws an error. correctly states this behavior. Options B, C, and D misunderstand the conditional throwing nature of rethrows.

3. Final Answer:

   The function only throws an error if the closure it receives throws an error. -> Option C

4. Quick Check:

   rethrows means conditional throwing = A [OK]

Hint: Remember: rethrows means throw only if closure throws [OK]

Common Mistakes:

• Thinking rethrows means always throws
• Confusing rethrows with throws
• Assuming rethrows catches errors

2. Which of the following is the correct syntax to declare a function that rethrows errors from a closure parameter named operation?

easy

A. func perform(operation: () -> Void) rethrows {}

B. func perform(operation: () rethrows -> Void) throws {}

C. func perform(operation: () throws -> Void) throws {}

D. func perform(operation: () throws -> Void) rethrows {}

Solution

1. Step 1: Identify correct placement of throws and rethrows

   The closure parameter must be declared with throws if it can throw, and the function must be marked rethrows to propagate errors conditionally.

2. Step 2: Check each option

   func perform(operation: () throws -> Void) rethrows {} correctly declares the closure as () throws -> Void and the function as rethrows. func perform(operation: () rethrows -> Void) throws {} incorrectly uses rethrows on the closure. func perform(operation: () throws -> Void) throws {} marks the function as throws instead of rethrows. func perform(operation: () -> Void) rethrows {} declares a non-throwing closure but marks the function as rethrows, which is invalid.

3. Final Answer:

   func perform(operation: () throws -> Void) rethrows {} -> Option D

4. Quick Check:

   Closure throws + function rethrows = A [OK]

Hint: Closure uses throws, function uses rethrows keyword [OK]

Common Mistakes:

• Using rethrows on closure instead of function
• Marking function as throws instead of rethrows
• Marking function rethrows with non-throwing closure

3. What will be the output of the following Swift code?

func execute(task: () throws -> String) rethrows -> String {
    return try task()
}

func successTask() throws -> String {
    return "Success"
}

func failTask() throws -> String {
    throw NSError(domain: "Error", code: 1)
}

print(try execute(task: successTask))

medium

A. Success

B. Error thrown but caught silently

C. Compilation error due to rethrows misuse

D. Runtime crash without error handling

Solution

1. Step 1: Understand function behavior with successTask

   The execute function calls task() which is successTask here. Since successTask returns "Success" without throwing, execute returns "Success".

2. Step 2: Analyze output of print statement

   The print statement outputs the returned string "Success". No errors are thrown or caught here.

3. Final Answer:

   Success -> Option A

4. Quick Check:

   Successful closure call prints result = B [OK]

Hint: If closure succeeds, rethrowing function returns its result [OK]

Common Mistakes:

• Assuming error is thrown when closure succeeds
• Confusing rethrows with always throws
• Expecting silent error handling

4. Identify the error in this Swift code snippet:

func run(operation: () throws -> Void) rethrows {
    do {
        try operation()
    } catch {
        print("Caught error")
    }
}

func risky() throws {
    throw NSError(domain: "Fail", code: 0)
}

try run(operation: risky)

medium

A. The function cannot be marked rethrows if it catches errors internally.

B. The closure parameter must not be marked throws.

C. The catch block should rethrow the error to propagate it.

D. The call to run must be inside a do-catch block.

Solution

1. Step 1: Understand rethrows and error catching

   A function marked rethrows must not catch errors from the closure; it only propagates them. Catching errors inside breaks this rule.

2. Step 2: Analyze the code's catch block

   The run function catches errors from operation() internally, so it cannot be marked rethrows. This causes a compile error.

3. Final Answer:

   The function cannot be marked rethrows if it catches errors internally. -> Option A

4. Quick Check:

   rethrows disallows internal catch = D [OK]

Hint: rethrows functions must not catch errors inside [OK]

Common Mistakes:

• Marking function rethrows but catching errors inside
• Confusing rethrows with throws
• Expecting rethrows to handle errors silently

5. You want to write a Swift function processAll that takes an array of closures, each possibly throwing an error, and calls them all. If any closure throws, processAll should rethrow that error. Which is the best way to declare processAll?

hard

A. func processAll(tasks: [() throws -> Void]) rethrows {
for task in tasks {
try task()
}
}

B. func processAll(tasks: [() throws -> Void]) throws {
for task in tasks {
try task()
}
}

C. func processAll(tasks: [() -> Void]) rethrows {
for task in tasks {
task()
}
}

D. func processAll(tasks: [() throws -> Void]) {
for task in tasks {
try? task()
}
}

Solution

1. Step 1: Understand rethrows limitation

   The rethrows keyword only works if the function takes exactly one throwing closure parameter. Here, tasks is an array of closures, so rethrows cannot be used.

2. Step 2: Choose correct error propagation

   Since multiple closures can throw, processAll must be marked throws to propagate errors. func processAll(tasks: [() throws -> Void]) throws { for task in tasks { try task() } } correctly uses throws. func processAll(tasks: [() throws -> Void]) rethrows { for task in tasks { try task() } } incorrectly uses rethrows. func processAll(tasks: [() -> Void]) rethrows { for task in tasks { task() } } uses non-throwing closures. func processAll(tasks: [() throws -> Void]) { for task in tasks { try? task() } } ignores errors with try?.

3. Final Answer:

   func processAll(tasks: [() throws -> Void]) throws { for task in tasks { try task() } } -> Option B

4. Quick Check:

   Multiple throwing closures require throws, not rethrows = C [OK]

Hint: Use throws when multiple throwing closures are parameters [OK]

Common Mistakes:

• Using rethrows with multiple throwing closures
• Ignoring errors with try?
• Declaring non-throwing closures when errors can occur