Protocol conformance via extension in Swift - Time & Space Complexity

Time Complexity: Protocol conformance via extension

O(n)

Understanding Time Complexity

When a Swift type adopts a protocol through an extension, it gains new behavior. We want to understand how the time it takes to use that behavior changes as input grows.

How does the program's work grow when calling protocol methods added by extensions?

Scenario Under Consideration

Analyze the time complexity of the following code snippet.

protocol Summable {
    func sum() -> Int
}

extension Array: Summable where Element == Int {
    func sum() -> Int {
        var total = 0
        for number in self {
            total += number
        }
        return total
    }
}

let numbers = [1, 2, 3, 4, 5]
let result = numbers.sum()
    

This code adds a sum() method to arrays of integers using a protocol extension. It calculates the total of all numbers in the array.

Identify Repeating Operations

Identify the loops, recursion, array traversals that repeat.

• Primary operation: Looping through each element in the array to add it to a total.
• How many times: Once for every element in the array (n times, where n is the array size).

How Execution Grows With Input

As the array gets bigger, the method does more additions, one per element.

Input Size (n)	Approx. Operations
10	10 additions
100	100 additions
1000	1000 additions

Pattern observation: The work grows directly with the number of elements. Double the elements, double the work.

Final Time Complexity

Time Complexity: O(n)

This means the time to compute the sum grows linearly with the number of items in the array.

Common Mistake

[X] Wrong: "Adding a method via protocol extension makes the code run instantly regardless of input size."

[OK] Correct: Even though the method is added by extension, it still processes each element one by one, so the time depends on input size.

Interview Connect

Understanding how protocol extensions affect performance helps you explain your code choices clearly and shows you know how Swift handles behavior and efficiency together.

Self-Check

What if the sum() method used recursion instead of a loop? How would the time complexity change?

Practice

1. What is the main purpose of using an extension to conform a type to a protocol in Swift?

easy

A. To add protocol requirements to a type without modifying its original definition

B. To create a new subclass from an existing class

C. To override existing methods in a class

D. To declare a new protocol

Solution

1. Step 1: Understand protocol conformance

   Protocols define a set of methods or properties a type must implement.

2. Step 2: Role of extensions

   Extensions allow adding these implementations to a type without changing its original code.

3. Final Answer:

   To add protocol requirements to a type without modifying its original definition -> Option A

4. Quick Check:

   Extensions add protocol conformance without altering original type [OK]

Hint: Extensions add protocol methods without touching original code [OK]

Common Mistakes:

• Thinking extensions create subclasses
• Confusing extensions with method overriding
• Believing extensions declare new protocols

2. Which of the following is the correct syntax to make a struct Car conform to protocol Drivable using an extension?

easy

A. protocol Drivable extension Car { func drive() { print("Driving") } }

B. struct Car: Drivable { extension { func drive() { print("Driving") } } }

C. extension Drivable: Car { func drive() { print("Driving") } }

D. extension Car: Drivable { func drive() { print("Driving") } }

Solution

1. Step 1: Identify correct extension syntax

   Extensions use the format: extension TypeName: ProtocolName { ... }.

2. Step 2: Check each option

   extension Car: Drivable { func drive() { print("Driving") } } correctly extends Car to conform to Drivable and implements drive().

3. Final Answer:

   extension Car: Drivable { func drive() { print("Driving") } } -> Option D

4. Quick Check:

   Correct extension syntax = extension Car: Drivable { func drive() { print("Driving") } } [OK]

Hint: Use 'extension Type: Protocol { }' to conform [OK]

Common Mistakes:

• Placing extension inside struct
• Swapping type and protocol names
• Using 'protocol' keyword incorrectly

3. Consider the code below:

protocol Greetable {
    func greet() -> String
}

struct Person {
    let name: String
}

extension Person: Greetable {
    func greet() -> String {
        return "Hello, \(name)!"
    }
}

let p = Person(name: "Anna")
print(p.greet())

What is the output when this code runs?

medium

A. Hello, !

B. Hello, name!

C. "Hello, Anna!"

D. Error: Person does not conform to Greetable

Solution

1. Step 1: Check protocol conformance

   Person is extended to conform to Greetable by implementing greet() returning "Hello, \(name)!".

2. Step 2: Analyze output

   Creating Person with name "Anna" and calling greet() returns "Hello, Anna!" which is printed.

3. Final Answer:

   "Hello, Anna!" -> Option C

4. Quick Check:

   Extension adds greet() returning personalized string [OK]

Hint: Extension adds greet() returning personalized message [OK]

Common Mistakes:

• Expecting error due to missing conformance
• Ignoring string interpolation
• Assuming default greet() implementation

4. The following code tries to make Rectangle conform to Shape via extension, but it causes a compile error. What is the error?

protocol Shape {
    var area: Double { get }
}

struct Rectangle {
    var width: Double
    var height: Double
}

extension Rectangle: Shape {
    func area() -> Double {
        return width * height
    }
}

medium

A. Method 'area()' should be a computed property, not a function

B. Cannot extend a struct to conform to a protocol

C. Missing initializer in Rectangle

D. Protocol Shape requires a method named 'area()', not a property

Solution

1. Step 1: Check protocol requirement

   Shape requires a property area of type Double with a getter.

2. Step 2: Analyze extension implementation

   The extension implements area() as a method, but protocol expects a computed property var area: Double { get }.

3. Final Answer:

   Method 'area()' should be a computed property, not a function -> Option A

4. Quick Check:

   Property requirement needs computed property, not method [OK]

Hint: Match protocol property with computed property, not method [OK]

Common Mistakes:

• Implementing property as method
• Thinking structs can't conform via extension
• Ignoring protocol property vs method difference

5. You have a protocol Printable requiring a method printDetails(). You want to add this conformance to an existing class Book without changing its original code. Which approach correctly achieves this and allows printDetails() to print the book's title and author?

class Book {
    let title: String
    let author: String
    init(title: String, author: String) {
        self.title = title
        self.author = author
    }
}

hard

A. class Book: Printable {
func printDetails() {
print(title + author)
}
}

B. extension Book: Printable {
func printDetails() {
print("Title: \(title), Author: \(author)")
}
}

C. protocol Printable {
func printDetails()
}
extension Printable {
func printDetails() {
print("No details")
}
}

D. extension Printable: Book {
func printDetails() {
print(title + author)
}
}

Solution

1. Step 1: Understand requirement

   We want to add Printable conformance to Book without changing Book's original code.

2. Step 2: Use extension to conform

   extension Book: Printable { func printDetails() { print("Title: \(title), Author: \(author)") } } extends Book to conform to Printable and implements printDetails() accessing Book's properties.

3. Final Answer:

   extension Book: Printable { func printDetails() { print("Title: \(title), Author: \(author)") } } -> Option B

4. Quick Check:

   Extension adds protocol conformance and method using existing properties [OK]

Hint: Use extension on class to add protocol methods accessing properties [OK]

Common Mistakes:

• Trying to modify original class code
• Incorrectly extending protocol instead of class
• Not implementing required method