0Opaque types let you hide the exact type details while still showing what kind of value you get. This helps keep your code simple and flexible.
func functionName() -> some ProtocolName { // return a value that conforms to ProtocolName }
The some keyword means the function returns one specific type that conforms to the protocol, but the exact type is hidden.
This is different from returning ProtocolName directly, which can be any type conforming to the protocol.
Circle but hides that detail, only showing it returns something that conforms to Shape.func makeShape() -> some Shape { return Circle(radius: 5) }
Numeric type without revealing it is exactly an Int.func getNumber() -> some Numeric { return 42 }
This program defines a Shape protocol and a Circle struct that follows it. The function makeShape() returns an opaque type using some Shape. The exact type Circle is hidden but it still guarantees the returned value has an area() method.
import Foundation protocol Shape { func area() -> Double } struct Circle: Shape { var radius: Double func area() -> Double { return Double.pi * radius * radius } } func makeShape() -> some Shape { return Circle(radius: 3) } let shape = makeShape() print("Area is \(shape.area())")
Opaque types must always return the same concrete type from the function.
You cannot return different types from the same function when using some.
Opaque types help with abstraction and hiding implementation details.
Opaque types hide the exact return type but guarantee it conforms to a protocol.
Use some keyword to declare an opaque return type.
This keeps code flexible and easier to change later.
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.