Protocol as types in Swift - Step-by-Step Execution

Concept Flow - Protocol as types

Define Protocol

↓

Create Structs/Classes

↓

Use Protocol as Type

↓

Call Protocol Methods

↓

Execute Concrete Implementation

↓

Output Result

This flow shows how a protocol defines a blueprint, structs/classes conform to it, and the protocol is used as a type to call methods on different concrete types.

Execution Sample

Swift

protocol Vehicle {
    func drive() -> String
}

struct Car: Vehicle {
    func drive() -> String { "Car is driving" }
}

let myVehicle: Vehicle = Car()
print(myVehicle.drive())

Defines a Vehicle protocol, a Car struct conforming to it, then uses Vehicle as a type to call drive() on a Car instance.

Execution Table

Step	Action	Evaluation	Result
1	Define protocol Vehicle with drive()	Protocol Vehicle created	Vehicle requires drive() method
2	Define struct Car conforming to Vehicle	Car implements drive()	Car can be used as Vehicle
3	Create instance myVehicle of type Vehicle assigned Car()	myVehicle holds Car instance	myVehicle is Vehicle type holding concrete Car
4	Call myVehicle.drive()	Calls Car's drive()	Returns "Car is driving"
5	Print result	Output to console	Car is driving

💡 Execution ends after printing the drive() method result

Variable Tracker

Variable	Start	After Step 3	After Step 4	Final
myVehicle	nil	Car instance	Car instance	Car instance

Key Moments - 3 Insights

Why can we assign a Car instance to a variable of type Vehicle?

Because Car conforms to the Vehicle protocol, it can be treated as a Vehicle type, as shown in execution_table step 3.

When calling drive() on myVehicle, which implementation runs?

The Car's implementation runs because myVehicle holds a Car instance, as shown in execution_table step 4.

Can we create an instance of Vehicle directly?

No, protocols cannot be instantiated directly; they only define a blueprint, as implied in execution_table step 1.

Visual Quiz - 3 Questions

Look at the execution_table, what is the type of myVehicle after step 3?

A Car type directly

B Vehicle holding a Car instance

C Protocol Vehicle itself

D Nil

💡 Hint

Check execution_table row 3 under 'Result' and 'Evaluation'

At which step does the Car's drive() method get called?

A Step 2

B Step 3

C Step 4

D Step 5

💡 Hint

Look at execution_table row 4 under 'Action' and 'Evaluation'

If Car did not conform to Vehicle, what would happen at step 3?

A Compilation error assigning Car to Vehicle

B Runtime error when calling drive()

C myVehicle would hold Car instance anyway

D drive() would call default protocol implementation

💡 Hint

Protocols require conforming types; see key_moments about assignment and conformance

Concept Snapshot

protocol ProtocolName {
    func method() -> ReturnType
}

struct TypeName: ProtocolName {
    func method() -> ReturnType { ... }
}

Use protocol as type:
let variable: ProtocolName = TypeName()
variable.method() calls concrete implementation.

Full Transcript

This example shows how a protocol defines a method requirement. A struct Car conforms to the Vehicle protocol by implementing the drive() method. We create a variable myVehicle of type Vehicle and assign it a Car instance. When we call drive() on myVehicle, the Car's implementation runs, demonstrating how protocols can be used as types to abstract over different concrete implementations.

Practice

1. What does it mean to use a protocol as a type in Swift?

easy

A. Any object that follows the protocol's rules can be used as that type.

B. Only classes can conform to the protocol.

C. Protocols can only be used to create new classes.

D. Protocols define stored properties for types.

Solution

1. Step 1: Understand what a protocol defines

   A protocol defines a set of rules or features that a type must implement.

2. Step 2: Using protocol as a type

   When a protocol is used as a type, any object that implements those rules can be assigned to that type.

3. Final Answer:

   Any object that follows the protocol's rules can be used as that type. -> Option A

4. Quick Check:

   Protocol as type means flexible object use = A [OK]

Hint: Protocol as type means any conforming object fits [OK]

Common Mistakes:

• Thinking protocols only apply to classes
• Believing protocols define stored properties
• Confusing protocol usage with inheritance

2. Which of the following is the correct way to declare a variable of a protocol type named Drawable?

easy

A. var shape: Drawable

B. var shape: Drawable()

C. var shape: Drawable = Drawable()

D. var shape: Drawable[]

Solution

1. Step 1: Understand protocol type declaration

   To declare a variable of a protocol type, use the protocol name without parentheses or brackets.

2. Step 2: Analyze options

   var shape: Drawable correctly declares a variable of type Drawable. Options A and B incorrectly try to instantiate a protocol, which is not allowed. var shape: Drawable[] uses invalid syntax.

3. Final Answer:

   var shape: Drawable -> Option A

4. Quick Check:

   Protocol type variable = var name: ProtocolName [OK]

Hint: Declare protocol type without parentheses or initialization [OK]

Common Mistakes:

• Trying to instantiate a protocol directly
• Using parentheses after protocol name
• Using array brackets incorrectly

3. What will be the output of this Swift code?

protocol Greetable {
    func greet() -> String
}

struct Person: Greetable {
    func greet() -> String {
        "Hello"
    }
}

let greeter: Greetable = Person()
print(greeter.greet())

medium

A. greet()

B. Compile error

C. Person

D. Hello

Solution

1. Step 1: Understand protocol conformance

   Person struct conforms to Greetable and implements greet() returning "Hello".

2. Step 2: Using protocol as type and calling method

   Variable greeter is of type Greetable but holds a Person instance, so calling greet() returns "Hello".

3. Final Answer:

   Hello -> Option D

4. Quick Check:

   Protocol method call returns implemented string = Hello [OK]

Hint: Protocol variable calls conforming type's method [OK]

Common Mistakes:

• Expecting protocol name or method name as output
• Thinking protocol cannot be used as variable type
• Confusing compile error with runtime behavior

4. Identify the error in this Swift code using protocol as a type:

protocol Vehicle {
    func start()
}

class Car: Vehicle {
    func start() {
        print("Car started")
    }
}

var myVehicle: Vehicle = Vehicle()
myVehicle.start()

medium

A. Variable myVehicle should be a class, not protocol

B. Missing method implementation in Car

C. Cannot instantiate protocol directly with Vehicle()

D. start() method should return a value

Solution

1. Step 1: Check protocol instantiation

   Protocols cannot be instantiated directly, so Vehicle() causes an error.

2. Step 2: Analyze variable assignment

   Variable myVehicle must hold an instance of a type conforming to Vehicle, like Car(), not Vehicle() itself.

3. Final Answer:

   Cannot instantiate protocol directly with Vehicle() -> Option C

4. Quick Check:

   Protocols can't be created with () = Error [OK]

Hint: Protocols can't be instantiated directly [OK]

Common Mistakes:

• Trying to create an instance of a protocol
• Confusing protocol with class instantiation
• Ignoring method return types

5. Given the protocol and classes below, which code correctly stores different types conforming to Animal in an array and calls sound() on each?

protocol Animal {
    func sound() -> String
}

class Dog: Animal {
    func sound() -> String { "Bark" }
}

class Cat: Animal {
    func sound() -> String { "Meow" }
}

hard

A. let animals: [Animal] = [Dog(), Cat()]
for animal in animals {
print(animal.sound)
}

B. let animals: [Animal] = [Dog(), Cat()]
for animal in animals {
print(animal.sound())
}

C. let animals: [Dog] = [Dog(), Cat()]
for animal in animals {
print(animal.sound())
}

D. let animals = [Dog(), Cat()]
for animal in animals {
print(animal.sound())
}

Solution

1. Step 1: Understand protocol array usage

   To store different types conforming to Animal, declare array as [Animal].

2. Step 2: Call method correctly

   Use animal.sound() with parentheses to call the method. let animals: [Animal] = [Dog(), Cat()] for animal in animals { print(animal.sound()) } does this correctly.

3. Final Answer:

   let animals: [Animal] = [Dog(), Cat()] for animal in animals { print(animal.sound()) } -> Option B

4. Quick Check:

   Protocol array with method calls = let animals: [Animal] = [Dog(), Cat()] for animal in animals { print(animal.sound()) } [OK]

Hint: Use protocol array type and call methods with () [OK]

Common Mistakes:

• Using concrete type array instead of protocol type
• Calling method without parentheses
• Mixing incompatible types in array