some / any / opaque type

// some: opaque type (return value is fixed to one specific concrete type)
func makeShape() -> some Shape {
    return Circle(radius: 5)
}

// any: existential type (can store any type conforming to the protocol)
var shapes: [any Shape] = [Circle(radius: 5), Rectangle(width: 3, height: 4)]

// Primary associated type (Swift 5.7+)
func process(_ values: some Collection<Int>) { }

// Protocol definition
protocol Animal {
    var name: String { get }
    func sound() -> String
}

struct Dog: Animal {
    let name: String
    func sound() -> String { return "Woof" }
}

struct Cat: Animal {
    let name: String
    func sound() -> String { return "Meow" }
}

// some: the return value is a single fixed concrete type (hidden from the caller)
func makeDog() -> some Animal {
    return Dog(name: "Buddy")
}

let dog = makeDog()
print("\(dog.name): \(dog.sound())")

// any: existential type that can hold different concrete types under the same type
let animals: [any Animal] = [
    Dog(name: "Buddy"),
    Cat(name: "Whiskers"),
    Dog(name: "Max")
]

for animal in animals {
    print("\(animal.name): \(animal.sound())")
}

// Difference between some and any
// some: the function always returns the same concrete type (can be optimized by the compiler)
// any: can store any type (incurs overhead due to boxing)

// Primary associated type syntax (Swift 5.7+)
func sumAll(_ numbers: some Collection<Int>) -> Int {
    return numbers.reduce(0, +)
}

print("Total: \(sumAll([1, 2, 3, 4, 5]))")
print("Total: \(sumAll(Set([10, 20, 30])))")

some is an opaque type that "hides the type from the caller, while the compiler knows the concrete type." Use it when a function always returns the same concrete type — it offers good performance. A typical example is body: some View in SwiftUI.

any is an existential type that "can store any type conforming to the protocol." Use it when the type may vary at runtime, such as when mixing different types in an array. Since Swift 5.7, the any keyword is required when using a protocol as a type. Be careful not to confuse it with some.

For generic functions, see Generic Functions / Type Parameters.