Extensions with constraints in Swift - Step-by-Step Execution

Concept Flow - Extensions with constraints

Start with a type

↓

Declare extension

↓

Add where clause with constraint

↓

Add methods/properties only if constraint met

↓

Use extended type

↓

Check if constraint allows access

↓

Yes: method/property available

↓

No: method/property unavailable

This flow shows how Swift extensions add features only when certain conditions (constraints) on the type are met.

Execution Sample

Swift

extension Array where Element: Numeric {
    func sum() -> Element {
        self.reduce(0, +)
    }
}

let numbers = [1, 2, 3]
print(numbers.sum())

Adds a sum() method to arrays only if their elements are Numeric, then sums [1,2,3].

Execution Table

Step	Code Line	Action	Condition/Check	Result/Output
1	extension Array where Element: Numeric	Declare extension with constraint	Check if Element conforms to Numeric	Extension applies only if true
2	func sum() -> Element	Define sum method	Inside constrained extension	Method available only if constraint met
3	let numbers = [1, 2, 3]	Create array instance	Array of Int (Int conforms to Numeric)	numbers is [1, 2, 3]
4	print(numbers.sum())	Call sum()	Check if sum() exists for numbers	sum() exists, call proceeds
5	self.reduce(0, +)	Calculate sum	Add elements 1+2+3	Result is 6
6	print output	Print result	Output value	6
7	If array was ["a", "b"]	Try sum()	Element String does not conform to Numeric	sum() method unavailable, compile error

💡 Execution stops after printing 6; sum() only available when Element is Numeric.

Variable Tracker

Variable	Start	After Step 3	After Step 5	Final
numbers	undefined	[1, 2, 3]	[1, 2, 3]	[1, 2, 3]
sum()	not defined	available (because Element is Int)	called, computes 6	returns 6

Key Moments - 3 Insights

Why does sum() only work for some arrays and not others?

Because the extension has a constraint 'where Element: Numeric', sum() is only added to arrays whose elements follow Numeric. See execution_table row 1 and 7.

What happens if I try to call sum() on an array of Strings?

The compiler will give an error because String does not conform to Numeric, so the sum() method is not available. See execution_table row 7.

How does Swift know which arrays get the sum() method?

Swift checks the constraint in the extension's where clause at compile time. If the array's Element type meets the constraint, sum() is added. See execution_table row 1.

Visual Quiz - 3 Questions

Look at the execution_table at step 4, why does numbers.sum() work?

A Because numbers is an array of Int, which conforms to Numeric

B Because sum() is defined for all arrays

C Because numbers is empty

D Because sum() is a global function

💡 Hint

Check execution_table row 3 and 4 where the array type and constraint are verified.

At which step does the program calculate the sum of elements?

A Step 2

B Step 4

C Step 5

D Step 7

💡 Hint

Look at execution_table row 5 where reduce is called to add elements.

If the array was ["a", "b"], what would happen when calling sum()?

A sum() would return "ab"

B sum() method would not be available, causing a compile error

C sum() would return 0

D sum() would sum ASCII values

💡 Hint

See execution_table row 7 about constraint failure for String elements.

Concept Snapshot

Swift extensions can add methods only when types meet conditions.
Use 'extension Type where Condition' to add constrained features.
Methods inside run only if the constraint is true.
Example: extension Array where Element: Numeric adds sum() only for numeric arrays.
This helps add safe, specific functionality without changing original types.

Full Transcript

This visual trace shows how Swift extensions with constraints work. We start by declaring an extension on Array but only when its Element type conforms to Numeric. Inside, we add a sum() method that adds all elements. When we create an array of Ints, which are Numeric, the sum() method is available and returns 6. If we tried with Strings, sum() would not exist, causing a compile error. The key is the 'where Element: Numeric' clause that limits the extension's application. This lets Swift add methods safely only to types that meet the condition.