any P (egzystencjalny): kompromisy i dynamiczne wywołania

Czym jest typ egzystencjalny?

Kolekcja heterogeniczna

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 } }

// Heterogeneous array using ANY Shape
let shapes: [any Shape] = [Circle(r: 1), Square(s: 2), Circle(r: 0.5)]
let total = shapes.reduce(0) { $0 + $1.area() }   // dynamic dispatch
print(String(format: "%.2f", total))

Granica interfejsu

extension Circle { func diameter() -> Double { 2 * r } }

let mixed: [any Shape] = [Circle(r: 1), Square(s: 3)]
print(mixed[0].area())            // OK: in protocol
// print(mixed[0].diameter())     // ❌ Not visible via any Shape (commented)
// You'd need a type check / downcast:
if let c = mixed[0] as? Circle { print(c.diameter()) }

Zastrzeżenie dotyczące typu powiązanego

// Protocols with associated types/Self constraints can be hard to use as existentials.
protocol Parser {
    associatedtype Output
    func parse(_ s: String) -> Output
}

// let p: any Parser = ...     // ❌ Not directly usable: Output is unknown
// Workarounds: type erasure or constrain Output to a specific type in wrappers.

Wybór stylu parametrów

// Existential: accepts any mix of Shapes (dynamic dispatch)
func totalAreaExistential(_ xs: [any Shape]) -> Double {
    xs.reduce(0) { $0 + $1.area() }
}

// Generic (homogeneous): static dispatch; one concrete Shape type per call
func totalAreaGeneric<S: Sequence, T: Shape>(_ xs: S) -> Double
where S.Element == T {
    xs.reduce(0) { $0 + $1.area() }
}

print(totalAreaExistential([Circle(r:1), Square(s:2)]))  // mixed OK
print(totalAreaGeneric([Circle(r:1), Circle(r:2)]))      // homogeneous only
// totalAreaGeneric([Circle(r:1), Square(s:2)])          // ❌ different types

Kiedy używać any P

Korzyść typu egzystencjalnego

Podsumowanie