Opaque types with some keyword in Swift - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ Predict Output

intermediate

Output of function returning opaque type

What is the output of this Swift code using some keyword for opaque return type?

Swift

protocol Shape {
    func area() -> Double
}

struct Circle: Shape {
    var radius: Double
    func area() -> Double {
        return Double.pi * radius * radius
    }
}

func makeCircle() -> some Shape {
    return Circle(radius: 3)
}

print(Int(makeCircle().area()))

A 18

B 9

C 28

D Runtime error

💡 Hint

Recall the formula for the area of a circle and how opaque types hide the concrete type but preserve behavior.

The function returns a Circle with radius 3. Area = π * 3 * 3 ≈ 28.27. Casting to Int truncates to 28.

❓ Predict Output

intermediate

Opaque type with conditional return

What will be printed by this Swift code using some keyword with conditional return?

Swift

protocol Animal {
    func sound() -> String
}

struct Dog: Animal {
    func sound() -> String { "Woof" }
}

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

func makePet(_ isDog: Bool) -> some Animal {
    if isDog {
        return Dog()
    } else {
        return Dog() // Note: returns Dog in both cases
    }
}

print(makePet(false).sound())

A Runtime error

B Woof

C Compile-time error

D Meow

💡 Hint

Remember that opaque types must always return the same concrete type, even if conditions differ.

Both branches return Dog, so the opaque type is Dog. The sound is "Woof" regardless of the input.

🔧 Debug

advanced

Identify the error with opaque type mismatch

What error does this Swift code produce and why?

Swift

protocol Vehicle {
    func wheels() -> Int
}

struct Bike: Vehicle {
    func wheels() -> Int { 2 }
}

struct Car: Vehicle {
    func wheels() -> Int { 4 }
}

func makeVehicle(_ useBike: Bool) -> some Vehicle {
    if useBike {
        return Bike()
    } else {
        return Car()
    }
}

A Compile-time error: Function with opaque return type must return same concrete type in all paths

B Runtime error: Cannot cast Bike to Car

C No error, compiles and runs fine

D Compile-time error: Protocol Vehicle not conformed by Bike

💡 Hint

Opaque types require the same concrete type returned in every return path.

The function returns Bike in one branch and Car in another. This violates the opaque type rule causing a compile-time error.

🧠 Conceptual

advanced

Why use opaque types with some keyword?

Which of the following best explains the main advantage of using some keyword for opaque return types in Swift?

A It disables type checking for the returned value

B It forces the function to return only protocol types without any concrete implementation

C It allows returning multiple different types from the same function dynamically

D It hides the concrete return type while preserving type safety and allows the compiler to optimize code

💡 Hint

Think about abstraction and performance benefits.

Opaque types hide the concrete type but keep static type safety, enabling optimizations unlike returning protocol types directly.

❓ Predict Output

expert

Output of nested opaque types with some keyword

What is the output of this Swift code using nested opaque types with some keyword?

Swift

protocol Container {
    associatedtype Item
    func getItem() -> Item
}

struct Box<T>: Container {
    var item: T
    func getItem() -> T { item }
}

func makeBox() -> some Container {
    Box(item: 42)
}

func wrapBox() -> some Container {
    makeBox()
}

print(wrapBox().getItem())

A 42

B Compile-time error: Opaque type mismatch

C Optional(42)

D Runtime error: Cannot convert Box<Int> to Container

💡 Hint

Opaque types can be nested if the concrete type is consistent.

Both functions return Box as the concrete type, so the code compiles and prints 42.