some P (tipos de resultado opacos): ocultar tipos concretos

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

// Opaque factory: callers know it's a Shape, not which one
func makeUnitCircle() -> some Shape {
    Circle(r: 1.0)    // concrete type is hidden
}

let sh = makeUnitCircle()
print(String(format: "%.2f", sh.area()))  // 3.14

// Each function using "some Shape" chooses one hidden concrete type.
// Within the same function, it must always be the same concrete type.
func makeSquare(side: Double) -> some Shape {
    Square(s: side)   // fixed to Square for this function
}

let a = makeUnitCircle()
let b = makeUnitCircle()
print(a.area() == b.area())  // true for two unit circles

let q = makeSquare(side: 2)
print(q.area())              // 4.0

// ❌ This would NOT compile, because different branches return different concrete types:
// func makeShape(flag: Bool) -> some Shape {
//     if flag {
//         return Circle(r: 1)
//     } else {
//         return Square(s: 1) // error: underlying type must be the same
//     }
// }
// Rule: an opaque-returning function must always produce the same concrete type.

// A generic decorator that also conforms to Shape
struct Scaled<S: Shape>: Shape {
    let base: S
    let k: Double
    func area() -> Double { base.area() * k * k }
}

// Factory still hides the concrete generic type
func makeScaledUnitCircle(k: Double) -> some Shape {
    Scaled(base: Circle(r: 1.0), k: k)
}

let s1 = makeScaledUnitCircle(k: 2)
print(s1.area())  // 4 * π