Elegir entre some, any y genéricos

¿Cuándo usar cada opción?

Genéricos: homogéneos

protocol Shape { func area() -> Double }

struct Circle: Shape { let r: Double; func area() -> Double { .pi * r * r } }
struct Square: Shape { let s: Double; func area() -> Double { s * s } }

// Generic: one concrete Shape type per call site (homogeneous)
func totalAreaGeneric<S: Sequence, T: Shape>(_ xs: S) -> Double where S.Element == T {
    xs.reduce(0) { $0 + $1.area() }
}
print(totalAreaGeneric([Circle(r:1), Circle(r:2)]))  // OK
// totalAreaGeneric([Circle(r:1), Square(s:2)])      // ❌ different types

Opacos: ocultos, pero fijos

// Opaque factory hides the concrete type while guaranteeing Shape
func unitShape(flag: Bool) -> some Shape {
    // Must return the SAME underlying type on all paths; pick one.
    Circle(r: 1)
}
let s = unitShape(flag: true)
print(String(format: "%.2f", s.area()))  // 3.14

any P: heterogéneo

// Existential: store mixed conformers
let mixed: [any Shape] = [Circle(r: 1), Square(s: 2)]
let sum = mixed.reduce(0) { $0 + $1.area() }   // dynamic dispatch
print(String(format: "%.2f", sum))

Comparación de las formas de las API

// Three API shapes for the same idea: "make a Shape"

// 1) Generic return — exposes concrete type to caller
func makeGeneric<T: Shape>(_ t: T) -> T { t }

// 2) Opaque return — hides concrete type but fixed
func makeOpaqueCircle() -> some Shape { Circle(r: 1) }

// 3) Existential return — can return any conformer
func makeExistential(_ big: Bool) -> any Shape { big ? Square(s: 3) : Circle(r: 1) }

let g: Circle = makeGeneric(Circle(r: 2))      // caller knows concrete type
let o = makeOpaqueCircle()                      // caller sees only Shape
let e = makeExistential(true)                   // could be Circle or Square at runtime
print(g.area(), o.area(), e.area())

Hoja de referencia

Comprobación de decisión: elegir some/any/genéricos

Resumen