Type constraints with protocol conformance in Swift - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ Predict Output

intermediate

Output of generic function with protocol constraint

What is the output of this Swift code?

Swift

protocol Describable {
    func describe() -> String
}

struct Person: Describable {
    var name: String
    func describe() -> String {
        return "Person named \(name)"
    }
}

func printDescription<T: Describable>(_ item: T) {
    print(item.describe())
}

let p = Person(name: "Alice")
printDescription(p)

A No output

B Person named p

C Error: Type 'Person' does not conform to protocol 'Describable'

D Person named Alice

💡 Hint

Check how the describe() method is implemented and called.

The Person struct conforms to Describable and implements describe(). The generic function calls describe() on the passed instance, printing "Person named Alice".

🧠 Conceptual

intermediate

Understanding protocol conformance in type constraints

Which statement about Swift type constraints with protocol conformance is true?

A A generic type constrained to a protocol can only accept types that implement all protocol requirements.

B Protocols cannot be used as constraints in generic functions.

C A generic type constrained to a protocol can accept any type, regardless of conformance.

D Type constraints with protocols allow only classes, not structs or enums.

💡 Hint

Think about what it means to constrain a generic type to a protocol.

When you constrain a generic type to a protocol, only types that conform to that protocol (implement all its requirements) can be used.

🔧 Debug

advanced

Identify the error in protocol conformance with type constraints

What error does this Swift code produce?

Swift

protocol Runnable {
    func run()
}

struct Car: Runnable {
    func run() {
        print("Car is running")
    }
}

func start<T: Runnable>(_ vehicle: T) {
    vehicle.run()
}

struct Bike {}

start(Bike())

A Runtime error: method 'run()' not found

B Error: Missing implementation of 'run()' in 'Bike'

C Error: Type 'Bike' does not conform to protocol 'Runnable'

D No error, prints 'Car is running'

💡 Hint

Check the type passed to the generic function and its protocol conformance.

The generic function requires a type conforming to Runnable. Bike does not conform, so the compiler errors.

📝 Syntax

advanced

Correct syntax for protocol conformance in generic constraints

Which option shows the correct syntax to constrain a generic type T to conform to protocol Equatable?

A func compare<T: Equatable>(a: T, b: T) -> Bool { return a == b }

B func compare<T where T: Equatable>(a: T, b: T) -> Bool { return a == b }

C func compare<T: Equatable where T == Equatable>(a: T, b: T) -> Bool { return a == b }

D func compare<T: Equatable>(a: T, b: T) -> Bool { return a.equals(b) }

💡 Hint

Recall the syntax for generic constraints in Swift function declarations.

The correct syntax is func name<T: Protocol>(...). Option A uses this correctly.

🚀 Application

expert

Determine the number of items in the filtered array

Given the following Swift code, how many items are in the filtered array after execution?

Swift

protocol Filterable {
    var isActive: Bool { get }
}

struct Item: Filterable {
    var isActive: Bool
}

func filterActive<T: Filterable>(_ items: [T]) -> [T] {
    items.filter { $0.isActive }
}

let items = [Item(isActive: true), Item(isActive: false), Item(isActive: true), Item(isActive: false)]
let filtered = filterActive(items)
print(filtered.count)

A 4

B 2

C 0

D 3

💡 Hint

Count how many Item instances have isActive set to true.

Only two items have isActive == true, so the filtered array contains 2 elements.