Opaque Type

An opaque type in Swift, denoted by the some keyword, is a language feature that allows a function, method, or property to hide its exact concrete return type while guaranteeing that the returned value conforms to a specific protocol. Often described as “reverse generics,” opaque types shift the determination of the concrete type from the caller to the callee, while allowing the compiler to maintain strict static type identity.

func createEntity() -> some Equatable {
    return "Concrete Type is Hidden"
}

Core Mechanics

Static Type Identity Unlike existential types (denoted by any), an opaque type is resolved at compile time. The compiler knows the exact underlying concrete type, but abstracts it from the caller. Because the type identity is preserved statically, opaque types support protocols with Self requirements or associated types, and they allow the compiler to utilize static dispatch rather than dynamic existential containers.

Type Consistency Enforcement A strict compiler requirement for opaque types is that all return paths within the function or property must return the exact same underlying concrete type.

protocol Shape { }
struct Square: Shape { }
struct Circle: Shape { }

// Valid: The compiler statically resolves the opaque type to 'Square'
func getSquare() -> some Shape {
    return Square()
}

// Invalid: Compilation fails. 
// The underlying type must be identical across all branches.
func getShape(isSquare: Bool) -> some Shape {
    if isSquare {
        return Square() 
    } else {
        return Circle() // Error: Return statements do not have matching underlying types
    }
}

Opaque Types vs. Generics

In standard generics, the caller binds the generic type parameter to a concrete type. With opaque types, the implementation (callee) binds the type.

// Standard Generic: Caller determines 'T'
func genericFunction<T: Shape>(shape: T) -> T {
    return shape
}
let mySquare = genericFunction(shape: Square()) // T is bound to Square by the caller

// Opaque Type: Callee determines the underlying type
func opaqueFunction() -> some Shape {
    return Square() // The implementation binds the type to Square
}
let myShape = opaqueFunction() // Caller only knows it is 'some Shape'

Opaque Types vs. Existentials (any)

The distinction between some (opaque) and any (existential) lies in how the compiler handles type erasure:

• some Protocol (Opaque): Represents a single, specific concrete type that is hidden from the caller but known to the compiler. It preserves type identity, meaning two calls to the same function return the exact same type, allowing for operations like == if the protocol is Equatable.
• any Protocol (Existential): Represents a box (an existential container) that can hold any concrete type conforming to the protocol at runtime. It erases the underlying type identity completely, requiring dynamic dispatch and preventing the use of Self or associated type requirements in many contexts.

// Opaque: Type identity is preserved.
func makeOpaque() -> some Equatable { return 5 }
let a = makeOpaque()
let b = makeOpaque()
print(a == b) // Valid: The compiler knows 'a' and 'b' are the same underlying type (Int).

// Existential: Type identity is erased at compile time.
func makeExistential() -> any Equatable { return 5 }
let x = makeExistential()
let y = makeExistential()
// print(x == y) // Invalid: Binary operator '==' cannot be applied to two 'any Equatable' operands.

Master Swift with Deep Grasping Methodology!

Learn More