Protocol conformance in Swift - Time & Space Complexity

Time Complexity: Protocol conformance

O(n)

Understanding Time Complexity

When we use protocols in Swift, we want to know how fast the program runs when it checks if a type follows a protocol.

We ask: How does the time to confirm protocol conformance change as we add more types or protocols?

Scenario Under Consideration

Analyze the time complexity of the following code snippet.

protocol Greetable {
    func greet()
}

struct Person: Greetable {
    func greet() {
        print("Hello!")
    }
}

let p = Person()
p.greet()

This code defines a protocol and a struct that follows it, then calls the protocol method.

Identify Repeating Operations

Identify the loops, recursion, array traversals that repeat.

• Primary operation: Calling the method defined by the protocol.
• How many times: Once in this example, but could be many times if called repeatedly.

How Execution Grows With Input

When calling a protocol method, the time depends on how many calls you make, not on how many types conform.

Input Size (n)	Approx. Operations
10 calls	10 method calls
100 calls	100 method calls
1000 calls	1000 method calls

Pattern observation: The time grows directly with the number of calls, not with the number of types or protocols.

Final Time Complexity

Time Complexity: O(n)

This means the time grows linearly with how many times you call the protocol method.

Common Mistake

[X] Wrong: "Checking if a type conforms to a protocol takes longer as more types conform."

[OK] Correct: Swift uses fast lookups for protocol conformance, so checking does not slow down with more types.

Interview Connect

Understanding how protocol conformance affects speed helps you write clear and efficient Swift code, a skill valued in many coding challenges.

Self-Check

"What if we used a protocol with associated types? How would that affect the time complexity of calling methods?"