Error protocol conformance in Swift - Step-by-Step Execution

Concept Flow - Error protocol conformance

Define Error Type

↓

Conform to Error Protocol

↓

Throw Error

↓

Catch Error

↓

Handle Error

This flow shows how to define a custom error type by conforming to the Error protocol, then throwing and catching that error.

Execution Sample

Swift

enum MyError: Error {
    case badInput
}

func check(input: Int) throws {
    if input < 0 { throw MyError.badInput }
}

Defines a custom error type and a function that throws this error if input is negative.

Execution Table

Step	Action	Condition	Result	Output
1	Call check(input: 5)	5 < 0?	False	No error thrown
2	Function returns normally	-	-	-
3	Call check(input: -3)	-3 < 0?	True	Throw MyError.badInput
4	Error caught in catch block	-	-	Handle error

💡 Execution stops normally or after error is caught and handled.

Variable Tracker

Variable	Start	After Step 1	After Step 3	Final
input	-	5	-3	-3
errorThrown	nil	nil	MyError.badInput	MyError.badInput

Key Moments - 2 Insights

Why do we need to conform to the Error protocol?

Only types that conform to the Error protocol can be thrown as errors in Swift, as shown in step 3 where MyError.badInput is thrown.

What happens if the condition to throw is false?

The function returns normally without throwing, as seen in step 2 when input is 5.

Visual Quiz - 3 Questions

Look at the execution table, what is the value of 'errorThrown' after step 1?

A nil

B MyError.badInput

C 5

D Undefined

💡 Hint

Check variable_tracker row for 'errorThrown' after step 1.

At which step does the error get thrown?

A Step 1

B Step 2

C Step 3

D Step 4

💡 Hint

Look at execution_table row where 'Throw MyError.badInput' appears.

If input was 0, what would happen according to the execution flow?

A Error thrown

B Function returns normally

C Crash

D Infinite loop

💡 Hint

Refer to the condition 'input < 0' in execution_table steps.

Concept Snapshot

Define an enum or struct conforming to Error protocol.
Use 'throw' keyword to throw errors.
Use 'try' to call throwing functions.
Catch errors with 'do-catch' blocks.
Only Error-conforming types can be thrown.

Full Transcript

This visual execution shows how to create a custom error type by conforming to the Error protocol in Swift. The sample code defines an enum MyError with a case badInput. The function check(input:) throws this error if the input is less than zero. The execution table traces calling check with positive and negative inputs, showing when the error is thrown and caught. The variable tracker follows the input value and whether an error was thrown. Key moments clarify why conforming to Error is required and what happens when the condition to throw is false. The quiz tests understanding of error throwing steps and variable states. The snapshot summarizes the syntax and rules for error protocol conformance in Swift.