Rethrowing functions in Swift - Interactive Code Practice

Practice - 5 Tasks

1fill in blank

easy

Complete the code to declare a function that can rethrow errors from its closure parameter.

Swift

func perform(action: () throws -> Void) [1] {
    try action()
}

Drag options to blanks, or click blank then click option'

Arethrows

Bthrows

Ctry

Dthrowing

Attempts:

3 left

💡 Hint

Common Mistakes

Using 'throws' instead of 'rethrows' causes the function to always throw.

Using 'try' or 'throwing' is not valid in function declaration.

The rethrows keyword allows the function to throw errors only if the closure parameter throws.

2fill in blank

medium

Complete the code to call a rethrowing function with a throwing closure.

Swift

[1] perform(action: {
    throw NSError(domain: "Error", code: 1)
})

Drag options to blanks, or click blank then click option'

Ado

Btry

Cthrow

Dcatch

Attempts:

3 left

💡 Hint

Common Mistakes

Using 'do' or 'catch' inside the closure parameter is incorrect here.

Forgetting 'try' causes a compile error.

You must use try before the closure call because it can throw an error.

3fill in blank

hard

Fix the error in the function declaration to correctly rethrow errors from the closure.

Swift

func execute(task: () throws -> Void) [1] {
    try task()
}

Drag options to blanks, or click blank then click option'

Atry

Bthrows

Cthrow

Drethrows

Attempts:

3 left

💡 Hint

Common Mistakes

Using 'throws' makes the function throw unconditionally.

Using 'throw' or 'try' in the declaration is invalid.

The function must be marked rethrows to propagate errors only if the closure throws.

4fill in blank

hard

Fill both blanks to define a rethrowing function that accepts a closure and calls it.

Swift

func runOperation(operation: () [1] -> Void) [2] {
    try operation()
}

Drag options to blanks, or click blank then click option'

Athrows

Brethrows

Attempts:

3 left

💡 Hint

Common Mistakes

Marking the function as 'throws' instead of 'rethrows'.

Not marking the closure as 'throws'.

The closure parameter must be marked throws because it can throw errors, and the function must be rethrows to propagate those errors.

5fill in blank

hard

Fill all three blanks to create a rethrowing function that accepts a closure, calls it, and handles errors.

Swift

func handle(action: () [1] -> Void) [2] {
    do {
        try action()
    } catch {
        print([3])
    }
}

Drag options to blanks, or click blank then click option'

Athrows

Brethrows

Cerror

Derrors

Attempts:

3 left

💡 Hint

Common Mistakes

Using 'errors' instead of 'error' in the catch block.

Marking the function as 'throws' instead of 'rethrows'.

The closure is marked throws, the function rethrows, and the caught error is referenced as error inside the catch block.

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