Rethrowing functions in Swift

Introduction

Rethrowing functions let you pass errors up without handling them immediately. This helps keep your code clean and lets the caller decide how to handle errors.

When you want to write a function that calls another function which might throw an error, but you don't want to handle the error inside your function.

When you want to create a wrapper function that can throw errors only if the function it calls throws errors.

When you want to keep error handling flexible and let the caller decide how to handle errors.

When you want to write reusable code that works with throwing and non-throwing functions.

Syntax

Swift

func yourFunction(closure: () throws -> Void) rethrows {
    try closure()
}

The rethrows keyword means your function only throws if the passed-in closure throws.

You must use try when calling the closure inside your function.

Examples

This function takes a closure that might throw an error and rethrows it if needed.

Swift

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

This function runs the closure twice and rethrows any error from it.

Swift

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

This function takes a closure that does not throw, so it does not need rethrows.

Swift

func noThrow(action: () -> Void) {
    action()
}

Sample Program

This program defines a function callTwice that rethrows errors from a closure it calls twice. It shows calling it with a closure that does not throw and one that throws an error. The error is caught outside the rethrowing function.

Swift

enum SimpleError: Error {
    case exampleError
}

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

func mightThrow(shouldThrow: Bool) throws {
    if shouldThrow {
        throw SimpleError.exampleError
    } else {
        print("No error")
    }
}

// Using callTwice with a throwing closure

print("Calling with no error:")
try? callTwice {
    try mightThrow(shouldThrow: false)
}

print("Calling with error:")
do {
    try callTwice {
        try mightThrow(shouldThrow: true)
    }
} catch {
    print("Caught an error")
}

Important Notes

Use rethrows only when your function calls a throwing closure and you want to pass errors up.

If your function can throw errors on its own, you cannot use rethrows; use throws instead.

Rethrowing helps keep error handling flexible and clear.

Summary

Rethrowing functions let you pass errors from closures up to the caller without handling them inside.

Use rethrows when your function only throws if the closure throws.

This keeps your code clean and lets callers decide how to handle errors.