What’s the ‘any’ keyword? Understanding Type Erasure in Swift

The concept of Type Erasure is not new to Swift, but was radically improved in Swift 5.7 with the addition of the any prefix keyword (not to be confused with the capitalized Any type!) and improvements to the already existing some Opaque Type keyword. In this article, we’ll explain the concept of type erasure, how it used to be done, what’s different in Swift 5.7, and how these changes work under the hood.

What the hell is Type Erasure?

In programming languages with support for generic types, Type Erasure is the process of abstracting constrained generic types inside an unconstrained non-generic type that can be passed around freely.

If you don’t know why that’s necessary, consider the following example where we define a protocol and a few conforming types:

protocol Shape {}
struct Circle: Shape {}
struct Triangle: Shape {}

Because the Shape protocol is unconstrained, Swift allows us to quite easily refer to Circle and Triangle as their bare conformances:

var userShapes = [Shape]()
func userDidCreate(shape: Shape)
    userShapes.append(shape)
}
userDidCreate(shape: Circle())
userDidCreate(shape: Triangle())
// No problems will arise here. It's fine to refer to these types as just "Shape".

This will not be the case if the protocol has generic requirements. If the protocol has, for example, associated types that each underlying type provides on its own, Swift will strictly forbid you from referring to this protocol if you’re also not providing appropriate generic constraints:

protocol Sequence {
    associatedtype Element
}
var sequences = [Sequence]() // Can't do!
// Error: Protocol 'Sequence' can only be used as a generic constraint
// because it has Self or associated type requirements

The reason you can’t do this is that Swift is designed to be a type-safe language. Even though the compiler has no problem determining the underlying type of a Sequence type in the previous snippet, Swift has these features in order to allow you to ship safer products (runtime-wise). Think of access control properties like public and private; they are good examples of concepts that have absolutely no impact on the final binary. In the end, everything is accessible from everywhere, but inside your IDE, the compiler forces access control conventions to be followed so at the very least you are able to write code that is used the way you intended it to be used.

The issue here with generic constraints is similar. The compiler does know what the underlying type of a particular generic protocol is in runtime, but because Swift is designed to be type-safe, for safety reasons, if it can’t be determined in compile time, it will not let you do it. This is the complete opposite of Objective-C where you could easily do whatever you wanted for the (very big) cost of runtime safety.

Before Swift 5.7, the solution to this problem was to box these objects into unconstrained and generally unsafe “Any” variations of their protocols, like this:

class AnySequence {
    let value: Any

    init<T: Sequence>(_ sequence: T) {
        self.value = shape
    }
}

let erased: any Sequence = MyConcreteSequenceType()

let erased: Sequence = MyConcreteSequenceType()
// Error: Use of protocol 'Sequence' as a type must be written 'any Sequence'

protocol Animal {
    associatedtype Food
    func eat(_ food: Food)
}

protocol FoodProvider {
    func getFood<T: Animal>(for animal: T) -> T.Food
}

func feedAll(_ animals: [Animal], provider: FoodProvider) {
    animals.forEach {
        let food = provider.getFood(for: $0)
        $0.eat(food)
    }
}

final class AnyAnimal {
    var getFood: (FoodProvider) -> Any
    var eatFood: (Any) -> Void

    init<T: Animal>(_ animal: T) {
        self.getFood = { provider in
            provider.getFood(for: animal)
        }
        self.eatFood = { food in
            animal.eat(food as! T.Food)
        }
    }
}

func feedAll(_ animals: [AnyAnimal], provider: FoodProvider) {
    animals.forEach {
        let food = $0.getFood(provider)
        $0.eatFood(food)
    }
}

func feedAll(_ animals: [any Animal], provider: FoodProvider) {
    animals.forEach {
        let food = provider.getFood(for: $0)
        $0.eat(food) // Member 'eat' cannot be used on value of type 'any Animal'
    }
}

func feedAll(_ animals: [any Animal], provider: FoodProvider) {
    animals.forEach {
        feed($0, provider: provider) // Now works!
    }
}

func feed<T: Animal>(_ animal: T, provider: FoodProvider) {
    let food = provider.getFood(for: animal)
    animal.eat(food)
}

func feed<T: Animal>(_ animal: T)

func feed(_ animal: some Animal)

protocol Sequence<Element> { // Element is now a primary associated type
    associatedtype Element
    associatedtype Iterator
}

extension Sequence where Element == Int {
    func grabSomeNumbers() { ... }
}

// or

func grabSomeNumbers<T: Sequence>(_ s: T) where T.Element == Int { ... }

extension Sequence<Int> {
    func grabSomeNumbers() { }
}

// or

func grabSomeNumbers(_ s: Sequence<Int>) { ... }

let intSequences: [any Sequence<Int>]