Opaque types with some keyword in Swift - Interactive Code Practice

Practice - 5 Tasks

1fill in blank

easy

Complete the code to declare a function that returns some View.

Swift

func makeView() -> [1] {
    Text("Hello")
}

Drag options to blanks, or click blank then click option'

AView

Bsome View

Cany View

DOpaque View

Attempts:

3 left

💡 Hint

Common Mistakes

Using just the protocol name without 'some' causes errors.

Using 'any' instead of 'some' changes the meaning.

The some keyword declares an opaque return type, meaning the function returns a specific type conforming to View but hides the exact type.

2fill in blank

medium

Complete the code to declare a variable with an opaque type conforming to Equatable.

Swift

var value: [1] = 5

Drag options to blanks, or click blank then click option'

Asome Equatable

Bany Equatable

CEquatable

DOpaque Equatable

Attempts:

3 left

💡 Hint

Common Mistakes

Using just the protocol name without 'some' is not allowed for variables.

Using 'any' instead of 'some' changes the meaning to an existential type.

Using some Equatable declares an opaque type that conforms to Equatable, hiding the exact type but guaranteeing conformance.

3fill in blank

hard

Fix the error in the function return type to use opaque types correctly.

Swift

func getNumber() -> [1] {
    return 42
}

Drag options to blanks, or click blank then click option'

AInt

Bsome Int

CNumeric

Dsome Numeric

Attempts:

3 left

💡 Hint

Common Mistakes

Returning a concrete type without 'some' when an opaque type is expected.

Using 'some Int' is invalid because Int is a concrete type, not a protocol.

The function should return some Numeric to use an opaque type conforming to the Numeric protocol, hiding the exact type.

4fill in blank

hard

Fill both blanks to create a function returning an opaque type conforming to CustomStringConvertible.

Swift

func describe() -> [1] {
    return [2](value: 10)
}

struct Wrapper: CustomStringConvertible {
    var value: Int
    var description: String { "Value is \(value)" }
}

Drag options to blanks, or click blank then click option'

Asome CustomStringConvertible

BWrapper

CCustomStringConvertible

Dsome Wrapper

Attempts:

3 left

💡 Hint

Common Mistakes

Returning the protocol type directly instead of an opaque type.

Returning a type that does not conform to the protocol.

The function returns some CustomStringConvertible to hide the exact type but guarantee protocol conformance. The returned value is a Wrapper instance.

5fill in blank

hard

Fill all three blanks to create a dictionary comprehension with opaque types and a condition.

Swift

let filteredLengths = ["apple", "banana", "cherry"].reduce(into: [:]) { dict, word in
    if word.count [1] 5 {
        dict[word] = word.count [2] 2
    }
}

func makeOpaque() -> [3] {
    return filteredLengths
}

Drag options to blanks, or click blank then click option'

A>

B*

Csome Collection

D<

Attempts:

3 left

💡 Hint

Common Mistakes

Using wrong comparison operators causing logic errors.

Returning a concrete type without 'some' keyword.

The condition checks if the word count is greater than 5. The dictionary value is the word count multiplied by 2. The function returns an opaque type some Collection.

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