Rethrowing functions in Swift - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ Predict Output

intermediate

Output of a rethrowing function with no error

What is the output of this Swift code when the closure does not throw an error?

Swift

func perform(action: () throws -> Void) rethrows {
    try action()
    print("Action completed")
}

try? perform {
    print("Hello")
}

A Hello\nAction completed

B Action completed

C Hello

D Runtime error

💡 Hint

Remember that the closure prints first, then the function prints after successful execution.

The closure prints "Hello" first. Since it doesn't throw, the function continues and prints "Action completed".

❓ Predict Output

intermediate

Error propagation in rethrowing function

What happens when the closure passed to this rethrowing function throws an error?

Swift

enum SampleError: Error {
    case failed
}

func execute(task: () throws -> Void) rethrows {
    try task()
    print("Task done")
}

try? execute {
    throw SampleError.failed
}

A Task done

B Task done\nError thrown

C Runtime crash

D No output, error is caught silently

💡 Hint

The try? converts error to nil and suppresses output after error.

The closure throws an error, so the function does not print "Task done". The try? catches the error silently, so no output appears.

🔧 Debug

advanced

Identify the error in rethrowing function usage

Which option causes a compile-time error in this Swift code?

Swift

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

func callRisky() {
    try riskyOperation {
        print("Running")
    }
}

A The code compiles and runs without error

B Error: 'riskyOperation' cannot be marked 'rethrows' here

C Error: 'callRisky' must be marked 'throws' because it calls a throwing function

D Error: Missing 'try' keyword before 'riskyOperation' call

💡 Hint

Check if the calling function handles errors properly.

Since 'riskyOperation' is rethrowing and the closure can throw, 'callRisky' must be marked 'throws' or handle the error.

🧠 Conceptual

advanced

Understanding rethrowing function constraints

Which statement about rethrowing functions in Swift is TRUE?

A A rethrowing function can throw errors even if the closure does not throw

B A rethrowing function only throws if the closure passed to it throws

C A rethrowing function must always be marked with 'throws' keyword

D A rethrowing function cannot call non-throwing closures

💡 Hint

Think about when the function propagates errors.

Rethrowing functions only throw errors if the closure they call throws. They do not throw independently.

❓ Predict Output

expert

Output of nested rethrowing functions with error

What is the output of this Swift code snippet?

Swift

enum MyError: Error {
    case fail
}

func outer(action: () throws -> Void) rethrows {
    print("Outer start")
    try inner(action: action)
    print("Outer end")
}

func inner(action: () throws -> Void) rethrows {
    print("Inner start")
    try action()
    print("Inner end")
}

try? outer {
    print("Action running")
    throw MyError.fail
}

A Outer start\nInner start\nAction running

B Outer start\nInner start\nAction running\nInner end\nOuter end

C Outer start\nInner start\nAction running\nOuter end

D Outer start\nInner start

💡 Hint

Trace the prints until the error is thrown and stops execution.

The error thrown inside the closure stops execution immediately after "Action running". "Inner end" and "Outer end" are not printed.