Protocol as types in Swift - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ Predict Output

intermediate

What is the output of this Swift code using protocol as type?

Consider the following Swift code where a protocol is used as a type. What will be printed when the code runs?

Swift

protocol Vehicle {
    func description() -> String
}

struct Car: Vehicle {
    func description() -> String {
        return "Car"
    }
}

struct Bike: Vehicle {
    func description() -> String {
        return "Bike"
    }
}

func printVehicle(_ v: Vehicle) {
    print(v.description())
}

let myVehicle: Vehicle = Car()
printVehicle(myVehicle)

A Car

B Bike

C Vehicle

D Compilation error

💡 Hint

Remember that the variable is declared as the protocol type but holds a Car instance.

The variable myVehicle is of type Vehicle but holds a Car instance. When calling description(), the Car's implementation is used, so it prints "Car".

❓ Predict Output

intermediate

What error occurs when assigning a non-conforming type to a protocol variable?

Given the protocol and struct below, what happens if you try to assign a String to a variable of type Vehicle?

Swift

protocol Vehicle {
    func description() -> String
}

struct Car: Vehicle {
    func description() -> String {
        return "Car"
    }
}

let myVehicle: Vehicle = "Not a vehicle"

A No error, but description() returns empty string

B Runtime error: Cannot cast String to Vehicle

C The code compiles and prints "Not a vehicle"

D Compilation error: String does not conform to Vehicle

💡 Hint

Check if String implements the Vehicle protocol.

String does not conform to the Vehicle protocol, so assigning it to a Vehicle type variable causes a compilation error.

🔧 Debug

advanced

Why does this code cause a runtime error when using protocol as type?

Examine the code below. It compiles but crashes at runtime. What is the cause?

Swift

protocol Vehicle {
    func description() -> String
}

struct Car: Vehicle {
    func description() -> String {
        return "Car"
    }
}

struct Bike: Vehicle {
    func description() -> String {
        return "Bike"
    }
}

let myVehicle: Vehicle = Car()
let bike = myVehicle as! Bike
print(bike.description())

A Compilation error: Bike not defined

B Runtime crash due to forced cast from Car to Bike failing

C Prints "Car" without error

D Runtime crash due to missing description() method

💡 Hint

Check the forced cast from one type to another unrelated type.

The forced cast 'as!' tries to convert a Car instance to Bike, which is invalid and causes a runtime crash.

🧠 Conceptual

advanced

How does Swift use protocols as types to enable polymorphism?

Which statement best explains how using a protocol as a type enables polymorphism in Swift?

A A protocol type variable can hold any instance of a type that conforms to that protocol, allowing different implementations to be used interchangeably.

B Protocols store the actual data of conforming types, so variables of protocol type contain all properties directly.

C Using a protocol as a type disables dynamic dispatch and forces static method calls.

D Protocols can only be used as types if they have no methods or properties.

💡 Hint

Think about how different types can be treated the same way through a protocol.

Protocols as types allow variables to hold any conforming instance, enabling polymorphism by calling methods defined in the protocol but implemented differently.

📝 Syntax

expert

Which option correctly declares a variable of protocol type with an instance conforming to it?

Given the protocol and struct below, which option correctly declares a variable of type Vehicle and assigns a Car instance?

Swift

protocol Vehicle {
    func description() -> String
}

struct Car: Vehicle {
    func description() -> String {
        return "Car"
    }
}

A let myVehicle: Car = Vehicle()

B let myVehicle = Vehicle(Car())

C let myVehicle: Vehicle = Car()

D let myVehicle: Vehicle = Vehicle()

💡 Hint

Remember protocols cannot be instantiated directly.

Option C correctly declares a variable of protocol type and assigns a conforming instance. Option C tries to call protocol as a function, A assigns protocol to struct type, D tries to instantiate protocol directly.