Opaque Types in Swift
Opaque types in Swift are a feature introduced to enable returning a specific type without revealing its concrete implementation. This is particularly useful when defining public APIs where the implementation details should remain hidden.
Suppose we have a protocol Shape
representing geometric shapes:
protocol Shape {
func area() -> Double
}
Now, let’s define two concrete types that conform to this protocol:
struct Circle: Shape {
var radius: Double
func area() -> Double {
return Double.pi * radius * radius
}
}
struct Square: Shape {
var side: Double
func area() -> Double {
return side * side
}
}
Now, let’s say we have a function that returns a Shape
. We want to return either a Circle
or a Square
based on some condition, but we want the caller of the function to only know that it's getting a Shape
, not necessarily whether it's a circle or a square.
func randomShape() -> some Shape {
if Bool.random() {
return Circle(radius: Double.random(in: 1...10))
} else {
return Square(side: Double.random(in: 1...10))
}
}
Here, randomShape
returns either a Circle
or a Square
conforming to the Shape
protocol. However, the caller of randomShape
only knows that it's getting a Shape
; it doesn't know the concrete type (Circle
or Square
). This is because we've used some Shape
as the return type, indicating that it will be a specific type conforming to Shape
, but we're not revealing which type exactly.
Now, let’s use this function:
let shape = randomShape()
print("Area of the shape: \(shape.area())")
Even though we don’t know the concrete type of shape
, we can still call area()
on it because we know it conforms to the Shape
protocol. This is the power of opaque types in Swift – they allow us to hide implementation details while providing a consistent interface to work with.
Follow me Rahul Goel for further updates.