Swiftda some va any — Opaque va Existential Types

// ═══════════════════════════════════════
//  SOME — "bitta aniq tur, lekin yashiraman"
// ═══════════════════════════════════════

protocol Shakl {
    func chiz() -> String
}

struct Doira: Shakl {
    func chiz() -> String { "⭕ Doira" }
}

struct Kvadrat: Shakl {
    func chiz() -> String { "⬜ Kvadrat" }
}

// some Shakl — bitta ANIQ tur qaytaradi
// Compiler biladi bu Doira — lekin chaqiruvchi faqat Shakl ni ko'radi
func yaratShaklni() -> some Shakl {
    return Doira()  // ✅ Har doim Doira qaytaradi
}

// ❌ XATO — turli turlar qaytarib bo'lmaydi!
// func xatoFunksiya(shart: Bool) -> some Shakl {
//     if shart { return Doira() }
//     else { return Kvadrat() }  // ❌ Ikki turli tur!
// }


// ═══════════════════════════════════════
//  SWIFTUI DA SOME VIEW
// ═══════════════════════════════════════
// var body: some View {
//     // Bu yerda HAR DOIM bitta aniq View turi qaytadi
//     // Compiler: bu ModifiedContent<Text, _PaddingLayout> turini biladi
//     Text("Salom").padding()
// }

// ═══════════════════════════════════════
//  ANY — "istalgan tur bo'lishi mumkin"
// ═══════════════════════════════════════

// any Shakl — istalgan Shakl turini saqlaydi
// Runtime da aniqlanadi — sekinroq lekin moslashuvchan
func yasaTasodifiy() -> any Shakl {
    if Bool.random() {
        return Doira()    // ✅ Doira
    } else {
        return Kvadrat()  // ✅ Kvadrat — turli turlar mumkin!
    }
}


// ═══════════════════════════════════════
//  MASSIVDA TURLI TURLAR
// ═══════════════════════════════════════
// some — massivda FAQAT bitta tur
let faqatDoiralar: [some Shakl] = [Doira(), Doira()]  // ✅ hammasi Doira

// any — massivda TURLI turlar
let aralash: [any Shakl] = [Doira(), Kvadrat(), Doira()]  // ✅ aralash
// Massivda turli turlar bo'lganda any KERAK

// ═══════════════════════════════════════
//  TEZLIK FARQI
// ═══════════════════════════════════════

// some — compile-time aniqlanadi
// Compiler aniq turni biladi → optimizatsiya qiladi
// Stack da saqlanadi → tez
func tezShaklYarat() -> some Shakl {
    Doira()  // Compiler: "bu Doira" → inline, devirtualize
}

// any — runtime da aniqlanadi
// Compiler turni bilmaydi → existential container (box)
// Heap da saqlanadi → sekinroq
func sekinShaklYarat() -> any Shakl {
    Bool.random() ? Doira() : Kvadrat()
    // Compiler: "nima kelishini bilmayman" → box yaratish
}


// ═══════════════════════════════════════
//  QACHON NIMA ISHLATISH
// ═══════════════════════════════════════

// ✅ some — funksiya har doim BIR TUR qaytarsa
// ✅ some — SwiftUI body, computed property
// ✅ some — tezlik muhim bo'lsa

// ✅ any — massivda TURLI turlar
// ✅ any — funksiya TURLI turlar qaytarsa
// ✅ any — moslashuvchanlik muhim bo'lsa

// ═══════════════════════════════════════
//  SWIFT 5.7+ — some Collection<Int>
// ═══════════════════════════════════════

// Eski usul — aniq tur ko'rsatish kerak
func sonlarniOl() -> [Int] {
    [1, 2, 3, 4, 5]
}

// some bilan — aniq tur yashiringan
// lekin element turi ko'rsatilgan
func sonlarniOlSome() -> some Collection<Int> {
    [1, 2, 3, 4, 5]
    // Array, Set yoki boshqa Collection bo'lishi mumkin
    // Chaqiruvchi faqat "Int elementli Collection" ni biladi
}

// any bilan
func sonlarniOlAny() -> any Collection<Int> {
    if Bool.random() {
        return [1, 2, 3]      // Array
    } else {
        return Set([4, 5, 6]) // Set
    }
}