Beqiyos sintaksisi. Birinchi ko'rinish

yosh o'zgaruvchi = 25

o'zgaruvchi yosh = 25

// Egalik o'tadi
s1 satr = "salom"
s2 satr = s1  // s1 endi yaroqsiz

uzunlikni_ol funksiya(matn: &satr) -> butun {
    matn.uzunlik()
}

natija tanla {
    Muvaffaq(qiymat) => qiymat,
    Xato(xabar) => 0
}

ism Tanlov<satr> = Ba'zi("Ali")
// yoki
ism Tanlov<satr> = Hech

agar qiymat Muvaffaq(son) {
    // bu yerda son avtomatik ishlatiladi
    chop(son)
}

fayl_ochish funksiya() {
    fayl = och("data.txt")
    kechiktir fayl.yop()  // Funksiya tugaganda bajariladi

    // fayl bilan ishlash
}

// Bu oddiy izoh

o'zgaruvchi yosh: butun = 25  // Yosh o'zgaruvchisi

/*
  Bu funksiya ikki sonni qo'shadi.
  Parametrlar: a va b
  Natija: ularning yig'indisi
*/
qo;shish funksiya(a: butun, b: butun) -> butun {
    a + b
}

/*
  Tashqi izoh boshlanadi
  /*
    Ichki izoh
    Bu juda qulay!
  */
  Tashqi izoh davom etadi
*/

/*
// Bu kod vaqtincha o'chirilgan
funksiya eski_algoritm() {
    /* Bu yerda ko'p narsa bor */
}
*/

/// Ikki sonning yig'indisini hisoblaydi
///
/// # Parametrlar
/// - `a`: Birinchi son
/// - `b`: Ikkinchi son
///
/// # Qaytaradi
/// Ikkala sonning yig'indisi
///
/// # Misol
/// ```
/// natija qiymat = qoshish(5, 3)
/// tekshir!(natija == 8)
/// ```
///
/// # Eslatma
/// Bu funksiya integer overflow'ni tekshirmaydi
qoshish funksiya(a: butun, b: butun) -> butun {
    a + b
}

/**
Geometrik shakllar bilan ishlash uchun modul

Bu modul quyidagi shakllarni qo'llab-quvvatlaydi:
- Doira
- To'rtburchak
- Uchburchak

Har bir shakl uchun yuza va perimetr hisoblash
imkoniyatlari mavjud.
*/
modul geometriya {
    // ...
}

//! # Matematik kutubxona
//!
//! Bu kutubxona asosiy matematik amallarni bajarish uchun
//! funksiyalar to'plamini taqdim etadi.
//!
//! ## Xususiyatlar
//! - Arifmetik amallar
//! - Trigonometrik funksiyalar
//! - Statistik hisoblashlar
//!
//! ## Foydalanish
//! ```
//! manba matem::*
//!
//! natija qiymat = qoshish(10, 20)
//! ```

modul matem {
    // funksiyalar
}

/// # Murakkab hisoblash funksiyasi
///
/// Bu funksiya quyidagi formulani ishlatadi:
///
/// ```math
/// result = (a² + b²) / (a + b)
/// ```
///
/// ## Diqqat
///
/// > **Ogohlantirish:** `a + b` nolga teng bo'lmasligi kerak!
///
/// ## Misol
///
/// | a | b | Natija |
/// |---|---|--------|
/// | 3 | 4 | 5.0    |
/// | 5 | 12| 13.0   |
///
/// ```beqiyos
/// natija1 qiymat = hisoblash(3, 4)
/// natija2 qiymat = hisoblash(5, 12)
/// ```
hisoblash funksiya(a: haqiqiy, b: haqiqiy) -> haqiqiy {
    (a * a + b * b) / (a + b)
}

// Foydalanuvchi balini 0-100 oralig'ida normalizatsiya qilish
natija qiymat = (ball * 100) / maksimal_ball

// Natijani hisoblash
natija qiymat = (ball * 100) / maksimal_ball  // Nima uchun?

yosh o'zgaruvchi: butun = 25
ism o'zgarmas: satr = "Ali"

// Tabiiy o'qiladi: "Yosh o'zgaruvchi 25 ga teng"
yosh o'zgaruvchi = 25

// vs C uslubi: "int yosh teng 25"
int yosh = 25  // notabiiy

// Nomlar chap tomonda - darhol ko'rinadigan
yosh o'zgaruvchi = 25
ism o'zgarmas = "Ali"
balansi o'zgaruvchi: haqiqiy = 1000.50

// C uslubida nomlarni topish qiyinroq
int yosh = 25;
const string ism = "Ali";
double balansi = 1000.50;

// Tur avtomatik aniqlanadi
yosh o'zgaruvchi = 25           // butun
narx o'zgarmas = 99.99          // haqiqiy
ism o'zgarmas = "Ali"           // satr
faol o'zgaruvchi = rost         // mantiqiy

// Aniq tur kerak bo'lganda
yosh o'zgaruvchi: b8 = 25       // 8-bitli butun
narx o'zgarmas: h32 = 99.99     // 32-bitli float

// Nom avval, keyin tur (funksiya)
qoshish funksiya(a: butun, b: butun) -> butun {
    a + b
}

Odam struktura {
    ism: satr,
    yosh: butun,
    email: satr
}

ali odam: Odam = Odam {
    ism: "Ali Valiyev",
    yosh: 25,
    email: "ali@example.uz"
}

// Parametr nomi avval, turi keyin
malumot_yuborish funksiya(
    qabul_qiluvchi: satr,
    xabar: satr,
    muhimlik: butun = 0
) -> Natija<(), Xato> {
    // ...
}

royxat o'zgaruvchi: Vek<butun> = Vek::yangi()
malumot o'zgarmas: Lugat<satr, butun> = Lugat::yangi()

asosiy funksiya() {
    // Dastur kodi shu yerda
}

// matem.bq faylidan funksiyalarni import qilish
manba matem::{qo'shish, ayirish};

// Butun modulni import qilish
manba standart::io;

asosiy funksiya () {
    o'zgaruvchi natija = qo'shish(5, 3);
}

yosh o'zgarmas = 25
yosh = 26  // ❌ XATO: o'zgarmas o'zgaruvchini o'zgartirish mumkin emas

hisoblagich o'zgaruvchi = 0
hisoblagich = hisoblagich + 1  // ✅ To'g'ri
hisoblagich += 1               // ✅ Qisqaroq

// Ishora bilan
x1 o'zgarmas: b8 = 127        // -128 .. 127
x2 o'zgarmas: b16 = 32767     // -32,768 .. 32,767
x3 o'zgarmas: b32 = 2147483647
x4 o'zgarmas: b64 = 9223372036854775807

// Ishorasiz (faqat musbat)
y1 o'zgarmas: bm8 = 255       // 0 .. 255
y2 o'zgarmas: bm16 = 65535
y3 o'zgarmas: bm32 = 4294967295
y4 o'zgarmas: bm64 = 18446744073709551615

// Arxitekturaga bog'liq
arch_size o'zgarmas: butun = 100    // 32 yoki 64 bit
arch_unsigned o'zgarmas: bm = 100   // ishorasiz

pi o'zgarmas: h32 = 3.14159          // 32-bit (float)
aniq_pi o'zgarmas: h64 = 3.14159265359  // 64-bit (double)

// Ilmiy notatsiya
katta o'zgarmas = 1.5e10    // 15,000,000,000
kichik o'zgarmas = 2.5e-3   // 0.0025

faol o'zgaruvchi: mantiqiy = rost
tugallangan o'zgarmas = yolg

// Mantiqiy operatsiyalar
natija1 qiymat = rost va yolg    // false
natija2 qiymat = rost yoki yolg  // true
natija3 qiymat = !rost            // false

// Bitta belgi (4 byte, Unicode)
harf o'zgarmas: belgi = 'A'
lotin_emas o'zgarmas: belgi = 'Ш'
emoji o'zgarmas: belgi = '🚀'

// Satr (UTF-8)
ism o'zgarmas: satr = "Ali"
matn o'zgarmas = "Salom, dunyo! 🌍"

// Xom satr (escape qilmasdan)
yol o'zgarmas = r"C:\Users\Ali\Documents"

// Ko'p qatorli
shеr o'zgarmas = """
Bahor keldi, gul ochildi,
Bulbul sayradi, kun kuyladi.
"""

// Turli turlarni birlashtirish
shaxs o'zgarmas = ("Ali", 25, rost)
koordinata o'zgarmas: (haqiqiy, haqiqiy) = (10.5, 20.3)

// Ajratib olish
(ism, yosh, erkak) qiymat = shaxs
chop("Ism: {ism}, Yosh: {yosh}")

// Index bilan kirish
birinchi qiymat = shaxs.0  // "Ali"
ikkinchi qiymat = shaxs.1  // 25

// O'lchami kompilyatsiya vaqtida ma'lum
sonlar o'zgarmas: [butun; 5] = [1, 2, 3, 4, 5]
matritsa o'zgaruvchi: [[butun; 3]; 3] = [
    [1, 2, 3],
    [4, 5, 6],
    [7, 8, 9]
]

// Barcha elementlar bir xil qiymat
nollar o'zgarmas = [0; 100]  // 100 ta nol

// Index bilan kirish
birinchi qiymat = sonlar[0]
oxirgi qiymat = sonlar[4]

// Xavfsiz kirish
agar o'zgaruvchi Ba'zi(qiymat) = sonlar.ol(10) {
    chop(qiymat)
} aks_holda {
    chop("Index chiqib ketgan")
}

sonlar o'zgarmas = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

// Qism olish
ilk_uch qiymat = &sonlar[0..3]    // [1, 2, 3]
oxirgi_uch qiymat = &sonlar[7..]  // [8, 9, 10]
o'rtadagi qiymat = &sonlar[3..7]  // [4, 5, 6, 7]

// Yangi bo'sh vektor
ismlar o'zgaruvchi = Vek::yangi()

// Qo'shish
ismlar.qosh("Ali")
ismlar.qosh("Vali")
ismlar.qosh("Gani")

// Macro bilan yaratish
sonlar o'zgaruvchi = vek![1, 2, 3, 4, 5]

// Amallar
uzunlik qiymat = ismlar.uzunlik()
sig'imi qiymat = ismlar.sigim()
birinchi qiymat = ismlar[0]

// O'chirish
olingan qiymat = ismlar.olib_tashla(1)  // "Vali" ni o'chiradi

// Tozalash
ismlar.tozala()

// Yangi lug'at
yoshlar o'zgaruvchi = Lugat::yangi()

// Qo'shish
yoshlar.qoy("Ali", 25)
yoshlar.qoy("Vali", 30)
yoshlar.qoy("Gani", 28)

// Olish
agar o'zgaruvchi Ba'zi(yosh) = yoshlar.ol("Ali") {
    chop("Ali ning yoshi: {yosh}")
}

// Mavjudligini tekshirish
agar yoshlar.mavjud("Vali") {
    chop("Vali ro'yxatda")
}

// Yangilash
yoshlar.qoy("Ali", 26)  // Ali yoshini yangilash

// O'chirish
yoshlar.olib_tashla("Gani")

// Iteratsiya
har (ism, yosh) in yoshlar {
    chop("{ism}: {yosh} yosh")
}

// Ba'zi(T) yoki Hech
topish funksiya(list: &[butun], val: butun) -> Tanlov<butun> {
    har (i, &elem) in list.sanab() {
        agar elem == val {
            return Ba'zi(i)
        }
    }
    Hech
}

// Ishlatish
natija = topish(&[10, 20, 30], 20)
tanla natija {
    Ba'zi(i) => chop("Topildi: {i}"),
    Hech => chop("Yo'q")
}

// Muvaffaq(T) yoki Xato(E)
bolish funksiya(a: butun, b: butun) -> Natija<butun, satr> {
    agar b == 0 {
        return Xato("Nolga bo'lish")
    }
    Muvaffaq(a / b)
}

// ? operatori
fayl_oqi funksiya() -> Natija<satr, Xato> {
    mazmun = ochish("data.txt")?  // auto propagate
    Muvaffaq(mazmun)
}

// Oddiy
agar yosh >= 18 {
    chop("Katta")
} aks_holda {
    chop("Kichik")
}

// Ko'p shartli
agar ball >= 90 {
    "A'lo"
} aks_agar ball >= 70 {
    "Yaxshi"
} aks_holda {
    "Qoniqarsiz"
}

// Ifoda sifatida
holat = agar yosh >= 18 { "katta" } aks_holda { "kichik" }

// Oddiy
kun = 3
kun_nomi = tanla kun {
    1 => "Dushanba",
    2 => "Seshanba",
    3 => "Chorshanba",
    _ => "Noma'lum"
}

// Ko'p qiymat
tanla raqam {
    1 | 3 | 5 | 7 | 9 => "Toq",
    2 | 4 | 6 | 8 => "Juft",
    _ => "Boshqa"
}

// Diapazon
tanla yosh {
    0..=12 => "Bola",
    13..=17 => "O'smir",
    18..=64 => "Katta",
    65.. => "Keksa",
    _ => "Noto'g'ri"
}

// Guard
tanla son {
    n agar n < 0 => "Manfiy",
    n agar n == 0 => "Nol",
    n => "Musbat"
}

// Cheksiz
siklda {
    agar shart {
        tuxt
    }
}

// Shartli
paytki i < 10 {
    chop(i)
    i += 1
}

// For each
har i in 1..=5 {
    chop(i)
}

har (i, val) in list.sanab() {
    chop("{i}: {val}")
}

// Davom va tuxt
har i in 1..=10 {
    agar i == 5 {
        davom  // skip
    }
    agar i == 8 {
        tuxt   // break
    }
    chop(i)
}

// Label
'tashqi: har i in 1..=3 {
    har j in 1..=3 {
        agar i == 2 va j == 2 {
            tuxt 'tashqi
        }
        chop("i={i}, j={j}")
    }
}

salom funksiya() {
    chop("Salom!")
}

// Parametrli
salom_ber funksiya(ism: satr) {
    chop("Salom, {ism}!")
}

// Qaytaradi
qoshish funksiya(a: butun, b: butun) -> butun {
    a + b  // return kerak emas
}

bolish funksiya(a: butun, b: butun) -> (butun, butun) {
    (a / b, a % b)
}

(bolinma, qoldiq) = bolish(17, 5)

salom funksiya(ism: satr, til: satr = "o'zbek") {
    agar til == "o'zbek" {
        chop("Salom, {ism}!")
    } aks_holda {
        chop("Hello, {ism}!")
    }
}

salom("Ali")              // "Salom, Ali!"
salom("John", "ingliz")   // "Hello, John!"

yigindi funksiya(sonlar: ...butun) -> butun {
    jami o'zgaruvchi = 0
    har son in sonlar {
        jami += son
    }
    jami
}

chop(yigindi(1, 2, 3))        // 6
chop(yigindi(10, 20, 30, 40)) // 100

// Funksiyani parametr sifatida
qollash funksiya(list: [butun], f: fn(butun) -> butun) -> [butun] {
    natija o'zgaruvchi = []
    har elem in list {
        natija.qosh(f(elem))
    }
    natija
}

ikkilantir funksiya(n: butun) -> butun {
    n * 2
}

sonlar = [1, 2, 3, 4, 5]
natija = qollash(sonlar, ikkilantir)  // [2, 4, 6, 8, 10]

// Lambda
natija = qollash(sonlar, |n| n * 2)

// Ko'p qatorli lambda
filtr = |x| {
    agar x % 2 == 0 {
        rost
    } aks_holda {
        yolg
    }
}

hisoblagich_yasash funksiya() -> fn() -> butun {
    hisob o'zgaruvchi = 0

    || {
        hisob += 1
        hisob
    }
}

hisoblagich = hisoblagich_yasash()
chop(hisoblagich())  // 1
chop(hisoblagich())  // 2
chop(hisoblagich())  // 3

Odam struktura {
    ism: satr,
    yosh: butun,
    email: satr
}

// Yaratish
ali = Odam {
    ism: "Ali Valiyev",
    yosh: 25,
    email: "ali@example.uz"
}

// Kirish
chop(ali.ism)
chop(ali.yosh)

// Yangilash (o'zgaruvchi bo'lishi kerak)
ali_oz o'zgaruvchi = ali
ali_oz.yosh = 26

Doira struktura {
    radius: haqiqiy
}

tadbiq Doira {
    yangi funksiya(r: haqiqiy) -> Doira {
        Doira { radius: r }
    }

    yuza funksiya(&self) -> haqiqiy {
        3.14159 * self.radius * self.radius
    }

    uzunlik funksiya(&self) -> haqiqiy {
        2.0 * 3.14159 * self.radius
    }

    o'zgartir funksiya(&o'zgaruvchi self, yangi_r: haqiqiy) {
        self.radius = yangi_r
    }
}

// Ishlatish
doira = Doira::yangi(5.0)
chop("Yuza: {}", doira.yuza())
chop("Uzunlik: {}", doira.uzunlik())

doira_oz o'zgaruvchi = doira
doira_oz.o'zgartir(10.0)

Holat enum {
    Kutilmoqda,
    Jarayonda,
    Tugallangan,
    Bekor_qilingan
}

// Qiymatlar bilan
Xabar enum {
    Tuxt,
    Yozish(satr),
    OrniniOzgartir { x: butun, y: butun }
}

// Ishlatish
holat = Holat::Jarayonda

xabar = Xabar::Yozish("Salom")
xabar2 = Xabar::OrniniOzgartir { x: 10, y: 20 }

tanla xabar {
    Xabar::Tuxt => chop("Tuxtadi"),
    Xabar::Yozish(matn) => chop("Yozildi: {matn}"),
    Xabar::OrniniOzgartir { x, y } => chop("Joylashuv: ({x}, {y})")
}

topish funksiya(list: &[satr], qidiruv: &satr) -> Tanlov<usize> {
    har (i, item) in list.sanab() {
        agar item == qidiruv {
            return Ba'zi(i)
        }
    }
    Hech
}

// Match
tanla topish(&ismlar, "Ali") {
    Ba'zi(i) => chop("Topildi: {i}"),
    Hech => chop("Topilmadi")
}

// Agar o'zgaruvchi
agar o'zgaruvchi Ba'zi(i) = topish(&ismlar, "Ali") {
    chop("Index: {i}")
}

// Unwrap (ehtiyotkor!)
index = topish(&ismlar, "Ali").unwrap()  // panic agar Hech

// Yoki standart
index = topish(&ismlar, "Ali").unwrap_yoki(0)

fayl_oqi funksiya(fayl: satr) -> Natija<satr, Xato> {
    agar !fayl_mavjud(&fayl) {
        return Xato("Fayl topilmadi")
    }

    mazmun = fayl_ochish(&fayl)?  // ? - xato tarqatish
    Muvaffaq(mazmun)
}

// Ishlatish
tanla fayl_oqi("data.txt") {
    Muvaffaq(mazmun) => {
        chop("Oqildi: {}", mazmun.uzunlik())
    },
    Xato(xabar) => {
        chop("Xato: {xabar}")
    }
}

// Panic - dastur to'xtaydi
agar muhim_shart_buzilgan {
    panic!("Jiddiy xato yuz berdi!")
}

// Assert
tekshir!(yosh > 0, "Yosh musbat bo'lishi kerak")
tekshir_teng!(2 + 2, 4)
tekshir_noteng!(yosh, 0)

//! Talabalar boshqaruv tizimi

/// Talaba ma'lumotlari
Talaba struktura {
    ism: satr,
    yosh: butun,
    kurs: butun,
    ballari: Vek<haqiqiy>
}

tadbiq Talaba {
    /// Yangi talaba yaratish
    yangi funksiya(ism: satr, yosh: butun, kurs: butun) -> Talaba {
        Talaba {
            ism,
            yosh,
            kurs,
            ballari: Vek::yangi()
        }
    }

    /// Ball qo'shish
    ball_qosh funksiya(&o'zgaruvchi self, ball: haqiqiy) -> Natija<(), satr> {
        agar ball < 0.0 yoki ball > 100.0 {
            return Xato("Ball 0-100 oralig'ida bo'lishi kerak")
        }
        self.ballari.qosh(ball)
        Muvaffaq(())
    }

    /// O'rtacha ball
    ortacha funksiya(&self) -> haqiqiy {
        agar self.ballari.bo'sh() {
            return 0.0
        }

        jami o'zgaruvchi = 0.0
        har ball in &self.ballari {
            jami += ball
        }
        jami / self.ballari.uzunlik() as haqiqiy
    }

    /// Baho
    baho funksiya(&self) -> satr {
        ortacha = self.ortacha()
        tanla ortacha {
            90.0.. => "A'lo",
            80.0..90.0 => "Yaxshi",
            70.0..80.0 => "Qoniqarli",
            _ => "Qoniqarsiz"
        }
    }

    /// Ma'lumotni chop etish
    chop funksiya(&self) {
        chop("=== {} ===", self.ism)
        chop("Yoshi: {}", self.yosh)
        chop("Kurs: {}", self.kurs)
        chop("O'rtacha: {:.2}", self.ortacha())
        chop("Baho: {}", self.baho())
    }
}

/// Talabalar ro'yxatini boshqarish
TalabalarRoyxati struktura {
    talabalar: Vek<Talaba>
}

tadbiq TalabalarRoyxati {
    yangi funksiya() -> TalabalarRoyxati {
        TalabalarRoyxati {
            talabalar: Vek::yangi()
        }
    }

    qosh funksiya(&o'zgaruvchi self, talaba: Talaba) {
        self.talabalar.qosh(talaba)
    }

    eng_yaxshi funksiya(&self) -> Tanlov<&Talaba> {
        agar self.talabalar.bo'sh() {
            return Hech
        }

        eng o'zgaruvchi: Tanlov<&Talaba> = Hech
        eng_ball o'zgaruvchi = 0.0

        har talaba in &self.talabalar {
            ortacha = talaba.ortacha()
            agar ortacha > eng_ball {
                eng_ball = ortacha
                eng = Ba'zi(talaba)
            }
        }

        eng
    }

    barchasini_chop funksiya(&self) {
        chop("\n=== Barcha talabalar ===\n")
        har (i, talaba) in self.talabalar.sanab() {
            chop("{}. {}", i + 1, talaba.ism)
            talaba.chop()
            chop()
        }
    }
}

/// Asosiy funksiya
asosiy funksiya() -> Natija<(), satr> {
    chop("=== Talabalar tizimi ===\n")

    // Talabalar yaratish
    ali o'zgaruvchi = Talaba::yangi("Ali Valiyev", 20, 2)
    ali.ball_qosh(85.0)?
    ali.ball_qosh(90.0)?
    ali.ball_qosh(88.0)?

    vali o'zgaruvchi = Talaba::yangi("Vali Karimov", 19, 1)
    vali.ball_qosh(75.0)?
    vali.ball_qosh(80.0)?
    vali.ball_qosh(78.0)?

    nodira o'zgaruvchi = Talaba::yangi("Nodira Rahimova", 21, 3)
    nodira.ball_qosh(95.0)?
    nodira.ball_qosh(92.0)?
    nodira.ball_qosh(98.0)?

    // Ro'yxatga qo'shish
    royxat o'zgaruvchi = TalabalarRoyxati::yangi()
    royxat.qosh(ali)
    royxat.qosh(vali)
    royxat.qosh(nodira)

    // Natijalarni ko'rsatish
    royxat.barchasini_chop()

    // Eng yaxshisini topish
    tanla royxat.eng_yaxshi() {
        Ba'zi(talaba) => {
            chop("🏆 Eng yaxshi talaba: {}", talaba.ism)
            chop("   O'rtacha balli: {:.2}", talaba.ortacha())
        },
        Hech => chop("Talabalar yo'q")
    }

    Muvaffaq(())
}

// Ownership tizimi xotira xavfsizligini ta'minlaydi
// Null pointer exception'lar yo'q (Option ishlatiladi)
// Data race'lar kompilyatsiya vaqtida aniqlanadi

// Sintaksis O'zbek tiliga mos
yosh o'zgaruvchi = 25
agar yosh >= 18 {
    chop("Katta")
}

// Pattern matching
tanla qiymat {
    Ba'zi(n) agar n > 0 => "Musbat",
    Ba'zi(0) => "Nol",
    Ba'zi(_) => "Manfiy",
    Hech => "Yo'q"
}

// Generics
royxat o'zgaruvchi: Vek<butun> = vek![1, 2, 3]

// Har bir e'lon aniq
o'zgaruvchi vs o'zgarmas
Ba'zi() vs Hech
Muvaffaq() vs Xato()