Why Opaque types with some keyword in Swift? - Purpose & Use Cases

The Big Idea

Discover how hiding type details can make your Swift code simpler and safer!

The Scenario

Imagine you want to write a function that returns a shape, but you want to hide the exact type of shape it returns. Without opaque types, you might have to reveal the exact type or use a very general type that loses important details.

The Problem

Manually handling this means either exposing too much detail or losing type information, which can cause bugs or force you to write extra code to check types. It's like giving someone a wrapped gift but telling them exactly what's inside, ruining the surprise and flexibility.

The Solution

Using the some keyword in Swift lets you return a value of some type that conforms to a protocol without revealing the exact type. This keeps your code flexible and safe, while hiding unnecessary details.

Before vs After

✗ Before

func makeShape() -> Shape { return Circle() }

✓ After

func makeShape() -> some Shape { return Circle() }

What It Enables

This lets you write cleaner, safer code by hiding implementation details while keeping strong type guarantees.

Real Life Example

Think of a drawing app that returns different shapes but only exposes that it returns some kind of shape, so the app can change shapes internally without breaking other parts of the code.

Key Takeaways

Opaque types hide exact return types while keeping type safety.

The some keyword makes code more flexible and easier to maintain.

It helps separate what a function does from how it does it.

Practice

1. What does the some keyword do when used in a Swift function's return type?

easy

A. It forces the function to return a specific concrete type.

B. It hides the exact return type but guarantees it conforms to a protocol.

C. It makes the function return any type without restrictions.

D. It allows the function to return multiple different types at runtime.

Solution

1. Step 1: Understand the purpose of some keyword

   The some keyword in Swift is used to declare an opaque return type, which means the exact type is hidden but it must conform to a specified protocol.

2. Step 2: Compare with other options

   The other options describe behaviors that do not match the opaque type concept: forcing a concrete type, returning any type freely, or allowing multiple types at runtime.

3. Final Answer:

   It hides the exact return type but guarantees it conforms to a protocol. -> Option B

4. Quick Check:

   Opaque types = hidden concrete type with protocol conformance [OK]

Hint: Remember: some hides type but keeps protocol rules [OK]

Common Mistakes:

• Thinking some allows any return type without constraints
• Confusing some with generics
• Believing some returns multiple types dynamically

2. Which of the following is the correct syntax to declare a function returning an opaque type conforming to View protocol?

easy

A. func makeView() -> some View { Text("Hello") }

B. func makeView() -> any View { Text("Hello") }

C. func makeView() -> View { Text("Hello") }

D. func makeView() -> some View() { Text("Hello") }

Solution

1. Step 1: Identify correct syntax for opaque return type

   The correct syntax uses some followed by the protocol name without parentheses: -> some View.

2. Step 2: Check each option

   func makeView() -> some View { Text("Hello") } matches the correct syntax. func makeView() -> any View { Text("Hello") } uses any which is for existential types, not opaque. func makeView() -> View { Text("Hello") } returns the protocol type directly, which is not allowed. func makeView() -> some View() { Text("Hello") } incorrectly adds parentheses after View.

3. Final Answer:

   func makeView() -> some View { Text("Hello") } -> Option A

4. Quick Check:

   Opaque type syntax = -> some Protocol [OK]

Hint: Use some without parentheses for opaque types [OK]

Common Mistakes:

• Using any instead of some for opaque types
• Adding parentheses after protocol name
• Returning protocol type directly instead of opaque type

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

protocol Shape {
    func area() -> Double
}

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

func makeShape() -> some Shape {
    Circle(radius: 2)
}

print(makeShape().area())

medium

A. 0.0

B. 4.0

C. 12.56

D. Error: Cannot use 'some' here

Solution

1. Step 1: Understand the code flow

   The function makeShape() returns an opaque type conforming to Shape, specifically a Circle with radius 2.

2. Step 2: Calculate the area

   The area of the circle is calculated as 3.14 * 2 * 2 = 12.56.

3. Final Answer:

   12.56 -> Option C

4. Quick Check:

   Circle area = π * r² = 12.56 [OK]

Hint: Calculate area using radius 2 and π=3.14 [OK]

Common Mistakes:

• Confusing some with errors in return type
• Using wrong formula for area
• Assuming runtime error due to opaque type

4. Identify the error in this Swift code using opaque types:

protocol Animal {
    func sound() -> String
}

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

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

func makeAnimal(_ type: String) -> some Animal {
    if type == "dog" {
        return Dog()
    } else {
        return Cat()
    }
}

medium

A. Function returns different concrete types violating opaque type rules.

B. Missing protocol conformance in structs.

C. Incorrect function return type syntax.

D. No error; code is correct.

Solution

1. Step 1: Understand opaque type restrictions

   Functions returning some Protocol must always return the same concrete type, even if hidden.

2. Step 2: Analyze the function's return paths

   This function returns Dog or Cat depending on input, which breaks the opaque type rule.

3. Final Answer:

   Function returns different concrete types violating opaque type rules. -> Option A

4. Quick Check:

   Opaque type = single hidden type only [OK]

Hint: Opaque return must be one concrete type, not multiple [OK]

Common Mistakes:

• Returning different types for opaque return
• Confusing opaque types with protocol types
• Ignoring compiler error about inconsistent return types

5. You want to write a function that returns an opaque type conforming to Collection protocol, but the collection should be filtered to only even numbers from an input array. Which of these implementations correctly uses some keyword and returns the filtered collection?

hard

A. func evenNumbers(from numbers: [Int]) -> some Collection {
return numbers.sorted()
}

B. func evenNumbers(from numbers: [Int]) -> some Collection {
return numbers.map { $0 * 2 }
}

C. func evenNumbers(from numbers: [Int]) -> [Int] {
numbers.filter { $0 % 2 == 0 }
}

D. func evenNumbers(from numbers: [Int]) -> some Collection {
numbers.filter { $0 % 2 == 0 }
}

Solution

1. Step 1: Understand the requirement

   The function must return an opaque type conforming to Collection that contains only even numbers filtered from the input.

2. Step 2: Evaluate each option

   func evenNumbers(from numbers: [Int]) -> some Collection { numbers.filter { $0 % 2 == 0 } } returns the filtered array using filter, which is a Collection and matches the requirement with some Collection. func evenNumbers(from numbers: [Int]) -> some Collection { return numbers.map { $0 * 2 } } returns doubled numbers, not filtered evens. func evenNumbers(from numbers: [Int]) -> [Int] { numbers.filter { $0 % 2 == 0 } } returns a concrete array type, not opaque. func evenNumbers(from numbers: [Int]) -> some Collection { return numbers.sorted() } returns sorted numbers but not filtered evens.

3. Final Answer:

   func evenNumbers(from numbers: [Int]) -> some Collection { numbers.filter { $0 % 2 == 0 } } -> Option D

4. Quick Check:

   Filter evens + opaque return = func evenNumbers(from numbers: [Int]) -> some Collection { numbers.filter { $0 % 2 == 0 } } [OK]

Hint: Use filter and some Collection for opaque filtered result [OK]

Common Mistakes:

• Returning wrong filtered or mapped collection
• Returning concrete type instead of opaque
• Not filtering for even numbers