Opaque Type: यह क्या है, Swift में some और any

func makeInt() -> some Equatable {
    return 42
}

func makeString() -> some Equatable {
    return "Hello"
}

// कंपाइलर जानता है कि makeInt Int लौटाता है
// makeInt() == makeString() — ❌ त्रुटि, विभिन्न प्रकार

// Generic: कॉलर प्रकार चुनता है
func identity<T>(_ value: T) -> T { value }
let x: Int = identity(42)

// Opaque: फ़ंक्शन प्रकार छिपाता है
func makeSomeEquatable() -> some Equatable { 42 }
let y = makeSomeEquatable()

func areEqual(_ a: some Equatable, _ b: some Equatable) -> Bool {
    // a और b — संभावित रूप से विभिन्न प्रकार, == सीधे काम नहीं करेगा
    return isEqual(a, b)
}

func isEqual<T: Equatable>(_ a: T, _ b: T) -> Bool {
    return a == b
}

protocol Drawable {
    func draw()
}

// some: स्थैतिक प्रकार ज्ञात है
func makeDrawable() -> some Drawable {
    return Circle() // एकल रिटर्न प्रकार
}

// any: गतिशील, विभिन्न प्रकार संग्रहीत कर सकता है
var shapes: [any Drawable] = [Circle(), Square()]
shapes.append(Triangle())

func makeReversedCollection<T>(
    of array: [T]
) -> some Collection {
    return array.reversed()
}

let result = makeReversedCollection(of: [1, 2, 3])
// result — ReversedCollection>, hidden from caller
for item in result {
    print(item)
}

struct ContentView: View {
    var body: some View {
        VStack {
            Text("नमस्ते")
                .font(.title)
            Button("मुझे टैप करें") {
                print("टैप किया गया")
            }
        }
        .padding()
    }
}