Swiftda Comparable

// ═══════════════════════════════════════
//  TAYYOR COMPARABLE TURLAR
//  Int, Double, String, Date — hammasi Comparable
// ═══════════════════════════════════════
let sonlar = [5, 2, 8, 1, 9]
let tartiblangan = sonlar.sorted()  // [1, 2, 5, 8, 9]
let teskari = sonlar.sorted(by: >)  // [9, 8, 5, 2, 1]

let ismlar = ["Vali", "Ali", "Gani"]
let alifbo = ismlar.sorted()  // ["Ali", "Gani", "Vali"]

// min() va max() ham Comparable tufayli ishlaydi
let eng_kichik = sonlar.min()!  // 1
let eng_katta = sonlar.max()!   // 9

// ═══════════════════════════════════════
//  O'Z STRUCT IGA COMPARABLE QO'SHISH
// ═══════════════════════════════════════
struct Talaba: Comparable {
    let ism: String
    let baho: Double

    // Equatable — teng bo'lishni aniqlash (Comparable talab qiladi)
    static func == (lhs: Talaba, rhs: Talaba) -> Bool {
        lhs.ism == rhs.ism && lhs.baho == rhs.baho
    }

    // Comparable — tartibni aniqlash
    // Faqat < yozish yetarli — >, <=, >= avtomatik hosil bo'ladi
    static func < (lhs: Talaba, rhs: Talaba) -> Bool {
        // Bahosi bo'yicha tartiblash
        lhs.baho < rhs.baho
    }
}

let talabalar = [
    Talaba(ism: "Ali", baho: 4.5),
    Talaba(ism: "Vali", baho: 3.8),
    Talaba(ism: "Gani", baho: 4.9),
]

// sorted() endi ishlaydi — Comparable bo'lgani uchun
let bahoBoyicha = talabalar.sorted()
// [Vali(3.8), Ali(4.5), Gani(4.9)]

// Teskari tartib
let engYaxshi = talabalar.sorted(by: >)
// [Gani(4.9), Ali(4.5), Vali(3.8)]

// min/max ishlaydi
let engPast = talabalar.min()!  // Vali(3.8)

struct Xodim: Comparable {
    let ism: String
    let yosh: Int
    let maosh: Double

    static func == (lhs: Xodim, rhs: Xodim) -> Bool {
        lhs.ism == rhs.ism && lhs.yosh == rhs.yosh
    }

    static func < (lhs: Xodim, rhs: Xodim) -> Bool {
        // Avval maosh bo'yicha, teng bo'lsa ism bo'yicha
        if lhs.maosh != rhs.maosh {
            return lhs.maosh < rhs.maosh
        }
        return lhs.ism < rhs.ism  // alifbo tartibida
    }
}

// sorted(by:) bilan bir nechta maydon
let xodimlar: [Xodim] = [/* ... */]

// Yosh bo'yicha, keyin ism bo'yicha
let tartiblangan = xodimlar.sorted {
    if $0.yosh != $1.yosh { return $0.yosh < $1.yosh }
    return $0.ism < $1.ism
}

// ═══════════════════════════════════════
//  ENUM — case tartibi bo'yicha avtomatik Comparable
// ═══════════════════════════════════════
enum Daraja: Comparable {
    case boshlangich   // 0
    case orta          // 1
    case yuqori        // 2
    case ekspert       // 3
}

// Solishtirish ishlaydi — case tartibi bo'yicha
let d1: Daraja = .boshlangich
let d2: Daraja = .ekspert

print(d1 < d2)   // true  — boshlangich < ekspert
print(d2 > d1)   // true

let darajalar: [Daraja] = [.yuqori, .boshlangich, .ekspert, .orta]
let tartiblangan = darajalar.sorted()
// [.boshlangich, .orta, .yuqori, .ekspert]