0protocol Shape { func area() -> Double } func makeCircle() -> some Shape { struct Circle: Shape { var radius: Double func area() -> Double { 3.14 * radius * radius } } return Circle(radius: 5) }
| Step | Action | Evaluation | Result |
|---|---|---|---|
| 1 | Call makeCircle() | Create Circle(radius: 5) | Circle instance created |
| 2 | Return Circle as some Shape | Hide concrete type | Return value typed as some Shape |
| 3 | Caller receives value | Type is some Shape | Can call area() but not access Circle-specific properties |
| 4 | Call area() on returned value | Compute 3.14 * 5 * 5 | Returns 78.5 |
| 5 | End | No more steps | Execution stops |
| Variable | Start | After Step 1 | After Step 2 | After Step 3 | Final |
|---|---|---|---|---|---|
| circle | nil | Circle(radius: 5) | Hidden as some Shape | some Shape value | some Shape value with area()=78.5 |
Use 'some Protocol' to return an opaque type.
The concrete type is hidden from the caller.
Caller sees only the protocol interface.
Allows type safety with abstraction.
Example: func f() -> some Shape { ... }some keyword do when used in a Swift function's return type?some keywordsome 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.some hides type but keeps protocol rules [OK]some allows any return type without constraintssome with genericssome returns multiple types dynamicallyView protocol?some followed by the protocol name without parentheses: -> some View.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.-> some Protocol [OK]some without parentheses for opaque types [OK]any instead of some for opaque typesprotocol 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())makeShape() returns an opaque type conforming to Shape, specifically a Circle with radius 2.some with errors in return typeprotocol 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()
}
}some Protocol must always return the same concrete type, even if hidden.Dog or Cat depending on input, which breaks the opaque type rule.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?Collection that contains only even numbers filtered from the input.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.filter and some Collection for opaque filtered result [OK]Pass the test and this pattern moves unknown strong while earning +1 Grip toward your certificate.