Rust dasturlash tili

Rust
Изображение логотипа
Tilning turi dasturlash tili
Paydo bo‘lgan yili 2006
Muallifi Greydon Xor[ma’lumot]
Ishlab chiquvchi Mozilla, Greydon Xor[ma’lumot] va Rust Foundation[ma’lumot]
Fayl kengaytmasi fayllarining .rs
Chiqarilgan sana
Ta’sir ko‘rsatgan tillar Alef[ma’lumot], C++, C#, Cyclone, Erlang, Haskell, Limbo, Newsqueak[ma’lumot], OCaml, Ruby, Scheme, SML va Swift
Litsenziya Apache License 2.0 va MIT litsenziyasi
Veb-sayt rust-lang.org (inglizcha)
Platformalar Windows, Linux, macOS, FreeBSD, iOS, Android, turli platformalarda ishlash imkoniyati, WebAssembly va Redox
operatsion tizimi turli platformalarda ishlash imkoniyati
Логотип Викисклада Vikimedia omboridagi mediafayllar
Ferris (Ferris) — Rust tilining norasmiy maskoti (ramziy qahramoni)

Rust (Rast, [rʌst]; rust so‘zi ingliz tilida — «zang» ma’nosini anglatadi) — ko‘p paradigmali kompilyatsiya qilinadigan dasturlash tili bo‘lib, umumiy maqsadlarga mo‘ljallangan hamda o‘zida funksional va protsedurali dasturlash paradigmalarini hamda obyektlar tiziminibirlashtiradi. Bu tizim treytlarga (traits)asoslanadi. Xotirani boshqarish «egalik» (ownership) mexanizmi hamda affin turlar (affine types)[inglizcha]yordamida amalga oshiriladi. Bu dasturni bajarish vaqtida xotirani avtomatik tozalash (garbage collection) tizimiga ehtiyoj qoldirmaydi. Rust kafolatlaydigan muhim xususiyat — xotira bilan xavfsiz ishlash . Bunga kompilyatorga o‘rnatilgan statik havolalarni tekshirish tizimi (borrow checker) xizmat qiladi. Shuningdek, tilda obyektga yo‘naltirilgan dasturlash usullaridan foydalanish imkoniyati mavjud.

Tilning asosiy ustuvorliklari — xavfsizlik, tezkorlik va parallel bajarish. Rust tizimli dasturlash uchun mos keladi. Jumladan, u operatsion tizim yadrolariniyaratishda istiqbolli til hisoblanadi. Rust tezligi va imkoniyatlari jihatidan C/C++tillari bilan taqqoslanadi, biroq xotira bilan ishlashda yuqoriroq xavfsizlikni ta’minlaydi. Bunga tildagi havolalarni nazorat qilish mexanizmlari yordam beradi. Rust dasturlarining yuqori unumdorligiga «nol xarajatli abstraksiyalar» (zero-cost abstractions) ham hissa qo‘shadi.

Bir necha yillik faol ishlab chiqishdan so‘ng birinchi barqaror versiya (1.0) 15-may 2015-yilda chiqarildi. Shundan keyin yangi versiyalar har 6 haftada taqdim etila boshlandi. 1.0 versiyasidan keyingi versiyalar uchun orqaga moslik e’lon qilingan.

Til 2010-yillardan boshlab Mozilla Research hamjamiyati tomonidan ishlab chiqilgan va Mozilla Foundationjamg‘armasi tomonidan moliyalashtirilgan. 2020-yildan boshlab tilga oid intellektual mulk, uni rivojlantirish va moliyalashtirish jarayonlarini Rust Foundation tashkilotiga o‘tkazish rejalashtirilgan edi. 8-fevral 2021-yilda besh ta’sischi kompaniya (AWS, Huawei, Google, Microsoft va Mozilla) Rust Foundation tashkil etilganini rasman e’lon qildi.

2016-yildan 2025-yilgacha ketma-ket o‘n yil davomida Rust dasturchilar o‘rtasidagi har yillik Stack Overflow Developer Survey so‘rovi natijalariga ko‘ra, eng ko‘p yoqtiriladigan («Most loved programming languages» / «Most admired programming languages») dasturlash tillari reytingida birinchi o‘rinni egalladi.

Tarixi

Til ustidagi ishlarni Mozilla xodimi Greydon Xor 2006-yilda boshlagan. Muallifning aytishicha, Rust loyihasi nomi quyidagi zamburug‘lar oilasi bilan bog‘liq: zang zamburug‘lari (inglizcha rust fungi).

2009-yilda Mozilla kompaniyasi Rustni ishlab chiqishni alohida moliyalashtira boshladi. Bir yil o‘tib, til Mozilla Summit 2010 anjumanida rasman taqdim etildi. Dastlabki kompilyator OCamltilida yozilgan edi. Keyinchalik uning o‘rnini Rust tilida yozilgan va mashina kodini yaratishda LLVM dan foydalanadigan yangi kompilyator egalladi; keyingi yili yangi kompilyator birinchi marta muvaffaqiyatli o‘zini o‘zi kompilyatsiya qildi.

Rustning birinchi rasmiy alfa-versiyasi (0.1) 2012-yil yanvarida chiqarildi.

2013-yil aprelida Servo — Mozilla kompaniyasining Rustda brauzer dvijogini yaratishga qaratilgan tajribaviy loyihasi ishga tushirildi.

Rustning birinchi barqaror versiyasi (1.0) 2015-yil mayida chiqarildi. Tilning dasturiy interfeyslari va imkoniyatlari jiddiy qayta ko‘rib chiqildi. Shundan so‘ng standart to‘plamda faqat to‘liq foydalanishga tayyor, kelgusida amalga oshirilishi o‘zgartirilmaydigan imkoniyatlar qoldirildi. Boshqa barcha funksiyalar tajribaviy deb belgilandi va standart to‘plamdan chiqarildi.

2022-yil dekabrida Rust, C va assembler tilidan tashqari birinchi til sifatida Linux yadrosini ishlab chiqishda qo‘llab-quvvatlana boshladi.

Turlar tizimi

Tilda qat’iy statik tiplashqo‘llanadi. Bundan tashqari, umumlashtirilgan dasturlash va parametrik polimorfizmqo‘llab-quvvatlanadi. Shuningdek, turni avtomatik aniqlash mexanizmi mahalliy o‘zgaruvchilar uchun ishlaydi (lekin funksiyalarning parametrlari uchun emas).

Shuningdek, birlik turlar (unit types)[inglizcha] — faqat bitta qiymatga ega va xotiradan joy egallamaydigan ma’lumotlar turlari qo‘llab-quvvatlanadi. Misollar:

  • bo‘sh kortej ();
  • bo‘sh massiv (masalan, [u8; 0]);
  • maydonsiz struktura (masalan, struct Foo);
  • birlik turlardan tashkil topgan struktura (struct Foo([u8; 0], ())).

Shuningdek, bo‘sh turlar (empty types) mavjud. Bunday turlarning qiymatini yaratib bo‘lmaydi; ular hech qanday varianti bo‘lmagan sanab o‘tiluvchi turlar ko‘rinishida ifodalanadi: enum Void {}.

Tildagi barcha ma’lumotlar turlari ikkita asosiy guruhga bo‘linadi: sodda turlar va standart kutubxona turlari.

Sodda turlar (tilning o‘ziga kiritilgan, o‘lchami doimiy turlar) — sonli, mantiqiy, belgili, massiv, kesim, satr kesimi, kortej, havola va funksiyaga ko‘rsatkich. Sodda turlarning ayrimlari bevosita zamonaviy protsessorlarda amalga oshiriladigan «mashina» turlaridir. Bularga sonli, mantiqiy va belgili turlar kiradi. Standart kutubxona taqdim etadigan std (o‘zgaruvchan uzunlikdagi) turlar esa vektor, satr, xesh-jadval va shu kabilarni o‘z ichiga oladi.

Sonli turlar:

  • butun son (integer): i8, u8, i16, u16, i32, u32, i64, u64, i128, u128, shuningdek, joriy platformadagi ko‘rsatkich o‘lchamiga teng isize va usize turlari. u8 «bayt» qiymatlari uchun ishlatiladi. Qiymat namunalari: -5i8, 0x400_u16, 0o100i16, 20_922_789_888u64, b'*' (bayt literali), b'\x1b', 42 (bu qiymatning turi avtomatik aniqlanadi), 0xfff_fc00usize
  • Suzuvchi nuqtali son (float). f32, f64. Misollar: 3.14f32, 6.0221e23f64, 2.,

Mantiqiy tur (bool): true, false.

Belgili tur (char): Unicode belgisini ifodalovchi tur (ma’lumot ichki ko‘rinishda u32 sifatida saqlanadi). Qiymat namunalari: '₽', '\n', '\x7f', '\u{CA0}',

Funksiyaga ko‘rsatkich (function pointer): funksiya obyektining turi uning signaturasi, ya’ni parametrlari va qaytaradigan qiymati bilan belgilanadi. Misol: let f: fn(i32) -> i32 = plus_one;

Havola (umumiy qarzga olish — shared borrow) &T (umumiy foydalaniladigan, o‘zgarmas va resursga egalik qilmaydigan). Havola resursga egalikni o‘ziga olish o‘rniga undan vaqtincha foydalanadi. Resursdan vaqtincha foydalanayotgan nomlar ko‘rinish doirasidan chiqqanda resursni bo‘shatmaydi. Bunda resurs egasi bo‘lgan nomlar ham vaqtincha berilgan holatga o‘tadi.

O‘zgartiriladigan havola (o‘zgartirib qarzga olish — mutable borrow) &mut T (resursga egalik qilmaydi). Vaqtincha olingan resursni o‘zgartirish imkonini beradi.

Strukturalar (struct):

  • C tilidagiga o‘xshash struktura: struct Color {red: u8, green: u8, blue: u8}
  • kortej-struktura: struct Color (u8, u8, u8);
  • struktura — «birlik» qiymat: struct Electron;

To‘plamlar (kolleksiyalar):

  • Massiv (array) [T; N] — T turidagi elementlardan tashkil topgan, N ta elementli qat’iy o‘lchamli ketma-ketlik. Misollar: [1, 2, 3], [true; 10000].
  • Vektor (vec, vector) Vec<T> — dinamik, kengaytiriladigan massiv. Misollar: vec![0; 10];, Vec::with_capacity(10)
  • Kesim (slice, view) &[T] — boshqa ma’lumotlar tuzilmasiga havola (yoki «proyeksiya»). Kesimlar massivning bir qismidan nusxa olmasdan, unga xavfsiz va samarali kirish zarur bo‘lganda foydalidir. Misol: &a[1..4],
  • Kortej (tuple) (T1, T2, T3, …). Struktura singari, kortej har xil turdagi istalgancha maydonni saqlashi mumkin, lekin bu maydonlarning nomi bo‘lmaydi; ularga indeks orqali murojaat qilinadi (t.0, t.1). Kortejlar nomsiz turlardir: maydonlar soni va turlari bir xil bo‘lgan kortejlar tur jihatidan mos keladi. type kalit so‘zi orqali taxallus nom berish mumkin, ammo bu yangi tur yaratmaydi. Misol: ("Age", 22), ("Europe",),
  • Nol uzunlikdagi kortej ((); bo‘sh kortej) ko‘pincha «birlik qiymat» (unit value)deb ataladi. Shunga mos ravishda bunday qiymatning turi «birlik tur» (unit type)deyiladi. Funksiya hech qanday qiymat qaytarmasa, u () qaytaradi deb hisoblanadi.
  • Xesh-jadval «kalit — qiymat» (HashMap) HashMap<T1, T2> — assotsiativ massivinterfeysini amalga oshiradigan ma’lumotlar tuzilmasi. U (kalit, qiymat) juftliklarini saqlash va uchta amalni bajarish imkonini beradi: yangi juftlik qo‘shish, kalit bo‘yicha qidirish va juftlikni kalit bo‘yicha o‘chirish. Rustdagi xesh-jadvallar vektorlarga o‘xshaydi, biroq qiymatlarni indeks emas, kalit asosida saqlaydi. Misol: HashMap::new();
  • Xesh-jadval — to‘plam (HashSet) HashSet<T> — T turidagi takrorlanmas qiymatlar to‘plami. Elementlarni qo‘shish, o‘chirish va qidirish boshqa kolleksiyalardagiga nisbatan tezroq bajariladi[qaysilarida?].

Satr turlari:

  • Satr (String) (ma’lumotlarning ichki ifodasi Vec<u8>ko‘rinishida) — o‘z mazmuniga egalik qiladigan tur. String dinamik xotirada (heap)joylashgan satrni ifodalaydi. U kengaytirilishi mumkin va UTF-8talablariga mos baytlar ketma-ketligi bo‘lishi kafolatlanadi. String odatda satr kesimini to_string metodi orqali o‘zgartirib yaratiladi. Misollar: "строковый срез".to_string(), String::new().
  • «Satr kesimi» (string slice, string literal) &str, &'static str. Kesimning alohida ko‘rinishi. Satr kesimlari qat’iy o‘lchamga ega va o‘zgartirib bo‘lmaydi. Ular UTF-8 baytlari ketma-ketligiga havoladir. Misol: "строковый срез". &'static str — dastur kodining o‘zida belgilar yordamida yozilgan satr; u ham satr kesimi, faqat statik tarzda joylashtirilgan (kompilyatsiya qilingan dastur tarkibida saqlanadi).
    • «Xom satr kesimi» (yoki xom satr literali), unda boshqaruv ketma-ketliklari talqin qilinmaydi: r"\d{0,5}.*".
    • «Baytli satr» &[u8] — oldiga quyidagi prefiks qo‘yilgan satr literali — «b»: b"white".

Sanab o‘tiluvchi tur (enum): Rustda sanab o‘tiluvchi turning har bir varianti qo‘shimcha ma’lumot bilan bog‘lanishi mumkin. Shu sababli u teglangan birlashma (tagged union) yoki yig‘indi tur (sum type)deb ham ataladi. Variantlarni e’lon qilish sintaksisi strukturalarni e’lon qilishga o‘xshaydi: ma’lumotsiz, nomlangan ma’lumotli va nomsiz ma’lumotli variantlar mavjud:

  • «birlik» qiymatli variant: enum Day {Sunday, Monday, Tuesday, Wednesday, Thursday, Friday, Saturday}
  • aniq qiymatli variant: enum Foo {Bar = 123,}.
  • struktura ko‘rinishidagi variant (nomlangan ma’lumotlar): enum Message {Quit, Move { x: i32, y: i32 }}.
  • kortej-struktura ko‘rinishidagi variant (nomsiz ma’lumotlar): enum Message {Quit, Size(i32)}.

Konstantalar:

  • const — o‘zgarmas qiymatlar. Ular dastur ishlayotgan butun vaqt davomida mavjud bo‘ladi. Aslida ularning xotirada belgilangan aniq manzili bo‘lmaydi, chunki ular ishlatilgan har bir joyga bevosita joylashtiriladi (inline),
  • static — o‘zgartirilishi mumkin bo‘lgan va yashash muddati 'staticga teng qiymat. Statik qiymatlar konstantalarga o‘xshaydi, lekin foydalanilgan har bir joyga alohida kiritilmaydi. Shuning uchun har bir statik qiymatning yagona nusxasi va xotirada aniq manzili bo‘ladi. O‘zgartiriladigan qiymatni e’lon qilishda quyidagi kalit so‘z ishlatiladi: mut. Bunday o‘zgartirishlar faqat unsafe bloklarda ruxsat etiladi.

Tanlashda odatda constga ustunlik berish kerak, chunki konstanta ko‘pincha xotirada muayyan manzilga muhtoj emas, bundan tashqari, const optimallashtirishlarga imkon beradi, masalan, konstantalarni oldindan hisoblash (constant folding).

Xotirani boshqarish

Tilda parallel bajarishning xavfsiz usullariga mo‘ljallangan xotirani boshqarish modeli qo‘llanadi. Bu model xotiraga noto‘g‘ri murojaat qilishning oldini oladi; boshqa dasturlash tillarida bunday xatolar ko‘pincha jiddiy segmentatsiya xatolariga sabab bo‘ladi. Boshlang‘ich qiymat berilmagan yoki allaqachon yo‘q qilingan o‘zgaruvchilardan foydalanish nazorat qilinadi; bir nechta vazifaning umumiy o‘zgaruvchan holatdan birgalikda foydalanishiga yo‘l qo‘yilmaydi; ko‘rsatkichlarning yashash muddati statik tahlil qilinadi va massiv chegarasidan chiqish tekshiriladi (bu doim avtomatik bajariladi, biroq tekshiruvni unsafe-bloklarida maxsus metod orqali chetlab o‘tish mumkin: get_unchecked).

Rustda «ko‘chirish» (Move) semantikasi qo‘llanadi: Rust odatdamoveamalida dinamik xotiradagi obyektga egalik qiluvchi ko‘rsatkichni qiymat tayinlash vaqtida yangi egaga o‘tkazadi; eski o‘zgaruvchi yaroqsiz bo‘lib qoladi. Agar tur Copy treytini amalga oshirsa, bunday holat yuz bermaydi, chunki stekdagi ma’lumotlar nusxalanadi.

let a = "объект с данными в куче".to_string();
// объект передан переменной b
// переменная a становится неинициализированной
let b = a;
// ошибка!
let c = a;
// данные объекта на стеке                                                                                       
let a = 55;
// копия объекта передана переменной b                                                                   
let b = a;
// c = 55                                                                                        
let c = a;

Xotira modelining yana bir xususiyati — vaqtincha foydalanish (qarzga olish,borrow) mexanizmi. Bunda vaqtincha olingan obyektni o‘zgartirish (&mut) yoki o‘zgartirmaslik (&) mumkin. Bu tushunchalar sintaktik va semantik jihatdan havolalarga juda o‘xshaydi, ammo o‘ziga xos jihatlari bor: obyektni vaqtincha berish «Ko‘p o‘quvchi yoki bitta yozuvchi» tamoyiliga asoslanadi: obyektni bir marta o‘zgartirish huquqi bilan yoki bir necha marta o‘zgartirish huquqisiz vaqtincha berish mumkin; olingan havola boshqa foydalanuvchiga qayta berilishi ham mumkin. Oddiy «Ko‘p o‘quvchi yoki bitta yozuvchi» tamoyilidan farqli ravishda bu qoida faqat oqimlarni sinxronlashda emas, balki umumiy holatda qo‘llanadi. Vaqtincha foydalanishning to‘g‘riligi kompilyatsiya vaqtida tekshiriladi va qo‘shimcha bajariladigan kod yaratmaydi (bu nol xarajatli abstraksiyalartamoyilidir). Kompilyator vaqtincha foydalanish va obyektning o‘z yashash muddatlari nisbatini ham nazorat qiladi: vaqtincha olingan havola obyektning o‘zidan uzoq yashay olmaydi, ya’ni uning ko‘rinish doirasidantashqariga chiqa olmaydi. Vaqtincha foydalanish ma’lumotning qayerda saqlanishidan qat’i nazar (stek, mahalliy yoki umumiy dinamik xotira, boshqa maxsus joylar) ishlaydi. Ikki alohida tushunchani farqlash kerak: havolaning o‘zi o‘zgartirilishi (let mut b = &c) va havola ko‘rsatayotgan obyektni o‘zgartirish (let b = &mut c).

Quti (Box) — dinamik xotiradagi obyektga egalik qiladigan «aqlli» ko‘rsatkich. Ko‘rinish doirasidan chiqqanda obyektni yo‘q qiladi va xotirani bo‘shatadi.

Katak (Cell, RefCell) katakning o‘zi o‘zgarmas bo‘lganida ham uning tarkibini o‘zgartirish imkonini beradi.

Havolalar hisoblagichiga ega ko‘rsatkichlar (Rc<T>) va atomar havolalar hisoblagichiga ega ko‘rsatkichlar (Arc<T>): havolalarni sanaydigan «aqlli» ko‘rsatkichlar. Hisoblagich nolga tushganda obyektni yo‘q qiladi va xotirani bo‘shatadi. Arc havolalar hisoblagichining oqimlar uchun xavfsizligini ta’minlaydi (obyektning o‘zi uchun emas). Rc va Arc o‘zgarmas obyektni boshqaradi, shuning uchun odatiy foydalanish bir oqimli dasturda Rc<Cell<T>> , ko‘p oqimli dasturda esa Arc<Mutex<T>> ko‘rinishida bo‘ladi.

O‘zgarmas «xom» ko‘rsatkichlar (*const T) va o‘zgartiriladiganlari (*mut T): xavfsizligi kafolatlanmagan ko‘rsatkichlar. Ulardan foydalanish qat’iyan tavsiya etilmaydi.

Bog‘lanishlar odatda o‘zgarmas bo‘ladi. O‘zgaruvchini o‘zgartirish mumkin bo‘lishi uchun quyidagi kalit so‘zdan foydalaniladi: mut.

Misollar:

let x = 80;    // связывание владельца x со значением 80
let mut y = 50;    // изменяемое связывание
let z = &x;    // неизменяемая ссылка на неизменяемое связывание
let w = &mut y;    // неизменяемая ссылка на изменяемое связывание
let r = &mut y;    // ошибка: нельзя создавать вторую ссылку на изменяемое связывание

*w = 90    // y = 90
*z = 30    // ошибка: попытка изменения через ссылку на неизменяемое связывание

let n = Box::new(42);    // упаковка
let m = Rc::new(55);    // счётчик ссылок
let data = Arc::new("test_string")    // атомарный счётчик

Doktorlik dissertatsiyasida Ralf Yung (inglizcha Ralph Jung) quyidagilarni rasmiy ravishda isbotladi — oqimlar xavfsizligini hamda xotirani boshqarish xavfsizligini; buning uchun u ajratish mantig‘ini (separation logic) o‘zi yaratgan RustBelt modeli va Iris vositasi orqali qo‘lladi (Iris quyidagi tizimga asoslangan: Coq).

Sintaksis

Tilning sintaksisi C tiliga va C++tillariga o‘xshaydi; Rust katta-kichik harflarni farqlaydi, kod bloklari figurali qavslar bilan chegaralanadi; boshqaruv tuzilmalari uchun if, else, whileva forkabi odatiy kalit so‘zlar qo‘llanadi. Izohlar ham C tilidagi uslubda yoziladi. Modul nomlari ikkita qo‘sh nuqta (::) bilan ajratiladi. Identifikatorlar lotin harflari, raqamlar va pastki chiziqdan iborat bo‘lishi mumkin. Satr literallarida UTF-8 kodlashidagi istalgan Unicode belgilariga ruxsat etiladi.

Rustdagi operatorlar: arifmetik (* — ko‘paytirish, / — bo‘lish, % — bo‘lishdan qolgan qoldiqni topish, + — qo‘shish, - — ayirish va son ishorasini o‘zgartiruvchi bir o‘rinli prefiks operator - ), bitli (>>, <<, &, | va ^), taqqoslash operatorlari (==, !=, <, >, <=, >=), mantiqiy operatorlar (&& va ||). Rustda turlarni o‘zgartirish uchun ikkilik asoperatoridan foydalaniladi. Turlarni yashirin o‘zgartirish faqat juda kam hollarda amalga oshiriladi.

Rust makrota’riflarni (macro definitions) qo‘llab-quvvatlaydi. Ular muntazam ifodalar yordamida almashtirishlarni amalga oshiradigan, kompilyatsiyaga tayyorlash bosqichida ishlaydigan vositalardir va C tilidagilarga nisbatan rivojlangan hamda xavfsizroq. Makrota’riflar (makrokomandalar) — foydalanuvchi belgilaydigan oddiy sintaksis kengaytmalari bo‘lib, ular macro_rules! buyrug‘i yordamida bajariladi. Makrokomandalar shablon bilan moslashtirish (pattern matching) tuzilmasiga o‘xshash uslubda aniqlanadi. Makrosning belgisi — nom oxiridagi undov belgisi. Bundan tashqari, kompilyatsiya vaqtida ixtiyoriy kodni ishga tushira oladigan «protsedurali» makrota’riflar ham qo‘llanadi.

Nomlarni bog‘lash

Kalit so‘z let bog‘lanishni (mahalliy o‘zgaruvchini) belgilaydi.

let x: i32 = 5;

Bu yozuv quyidagini anglatadi: «x — i32 turidagi (32 bitli butun son) besh qiymatiga ega bog‘lanish».

Shablon bilan moslashtirish (match)

Tildagi match tuzilmasi C tilidagi switch tuzilmasining umumlashtirilgan va takomillashtirilgan shaklidir. Bundan tashqari, match Rustda nafaqat bajarilish oqimini, balki ma’lumotlar tuzilmalarini boshqarishning ham eng kuchli, universal va hatto asosiy vositasi deyish mumkin. match ifodalarida |sintaksisi orqali bir nechta shablonni solishtirish mumkin; u mantiqiy «yoki» ma’nosini bildiradi.

let x = 10;

match x {
    1 | 2 => println!("один или два"),
    3 => println!("три"),
    4..=10 => println!("от четырёх до десяти"), // Отработает эта ветка, ведь 10 принадлежит данному диапазону.
    _ => println!("что угодно, не соответствующее условиям выше"), // "_" соответствует любому значению
}

Tuzilmani qismlarga ajratish (destrukturizatsiya)

Murakkab ma’lumotlar turlari (struktura, sanab o‘tiluvchi tur, kortej, massiv) bilan ishlaganda ularni shablon ichida tarkibiy qismlarga ajratish («destrukturizatsiya qilish») mumkin.
Strukturani qismlarga ajratish:

struct Point {
    x: i32,
    y: i32,
}

let point = Point { x: 0, y: 0 }; 

match point {
    Point { x: 0, y } => println!("x - ноль, y равен {}", y), // так как "x" равен нулю, отработает эта ветка.
    Point { x, y: 0 } => println!("x равен {}, y - ноль", x),
    Point { x, y } => println!("x = {}, y = {}", x, y),
}

Sanab o‘tiluvchi turni qismlarga ajratish:

enum Color {
    Rgb(i32, i32, i32),
    Hsv(i32, i32, i32),
}

let color = Color::Hsv(0, 0, 100);

match color {
    Color::Rgb(0, 0, 0) | Color::Hsv(0, 0, 0) => println!("чёрный"),
    Color::Rgb(255, 255, 255) | Color::Hsv(0, 0, 100) => println!("белый"), // отработает эта ветка.
    Color::Rgb(red, green, blue) => {
        println!("красный: {}, зелёный: {}, синий: {}", red, green, blue)
    } // отработает при любых значениях Rgb, которые не соответствуют условиям выше.
    Color::Hsv(hue, saturation, brightness) => println!(
        "тон: {}, насыщенность: {}, яркость: {}",
        hue, saturation, brightness
    ), // то же самое, только с Hsv.
}

Kortejni qismlarga ajratish:

let (a, b) = (1, 2);

println!("{}", a); // 1
println!("{}", b); // 2

Shartli ifodalar (if let)

Sintaksis if let orqali if va let tuzilmalarini qisqaroq shaklda birlashtirish, boshqa shablonlarni e’tiborsiz qoldirgan holda faqat bitta shablonga mos qiymatlarni qayta ishlash mumkin. Bunday sintaksis faqat bitta shablonni moslashtirish kerak bo‘lganda qulay.

let x = Some(10);

if let Some(value) = x {
    // здесь мы деструктурируем x, переменная value хранит значение 10.
    // выполнится эта ветка, так как "x" хранит внутри значение.
    println!("значение = {}", value);
} else {
    // оператор "else" здесь выступает заменой "_" в выражениях match.
    println!("x - пуст");
}

unsafe

Kompilyator quyidagi kalit so‘z bilan belgilangan blok va funksiyalarda unsafe (unsafe so‘zi ingliz tilida — «xavfsiz bo‘lmagan» deganidir), faqat beshta qo‘shimcha amalga ruxsat beradi:

  • o‘zgartiriladigan statik (static muto‘zgaruvchilarni o‘qish va yangilash;
  • xom ko‘rsatkichlar orqali qiymatga murojaat qilish;
  • xavfsiz bo‘lmagan (unsafe) funksiyalarni chaqirish;
  • xavfsiz bo‘lmagan treytlarni amalga oshirish;
  • quyidagi tur maydonlariga murojaat qilish — union.

Bunday unsafe imkoniyatdan quyi darajali abstraksiyalarni yaratishda, xususan Rust standart kutubxonasini ishlab chiqishda foydalanishga to‘g‘ri keladi. Oddiy dastur kodida esa quyidagi rejimni ishlatmaslik tavsiya etiladi: unsafe.

Obyektlar tizimi

Rustning obyektlar tizimi treytlar (traits) va strukturalar (structs)ga asoslangan. Treytlar ularni amalga oshiradigan har bir tur (odatda struktura) uchun metod signaturalarini belgilaydi. Treytlarda standart amalga oshirishga ega metodlar ham bo‘lishi mumkin. Muayyan struktura uchun treytni amalga oshirish, shuningdek, strukturaning o‘z metodlarini ta’riflash implkalit so‘zi bilan belgilanadi. Tilda bir necha o‘nlab ichki treyt mavjud. Ularning aksariyati operatorlarni qayta yuklashuchun ishlatiladi, ba’zilari esa alohida ahamiyatga ega.

Rust treytlarga oid meros olish mexanizmini qo‘llab-quvvatlaydi: treyt uni amalga oshiradigan turdan boshqa treytlarni ham amalga oshirishni talab qilishi mumkin. Biroq tilning o‘zida turlardan meros olish va shunga mos ravishda klassik obyektga yo‘naltirilgan dasturlash (OOP)mavjud emas. Turlarning merosxo‘rligi o‘rniga sinflar iyerarxiyasiga o‘xshash tuzilma treytlarni joriy qilish, ajdod strukturani avlod strukturaga kiritish yoki turli strukturalarni birlashtiruvchi sanab o‘tiluvchi turlardan foydalanish orqali amalga oshiriladi.

Til umumlashtirilgan turlarni (generics) qo‘llab-quvvatlaydi. Rustda funksiyalardan tashqari murakkab ma’lumot turlari va strukturalarni hamda sanab o‘tiluvchi turlarni ham umumlashtirish mumkin. Kompilyator Rustdagi umumlashtirilgan funksiyalarni juda samarali kompilyatsiya qiladi: buning uchun monomorfizatsiya (har bir umumlashtirilgan funksiyaning chaqirilish joyiga mos alohida nusxasini yaratish) usulidan foydalaniladi. Shunday qilib, har bir nusxa muayyan argument turlariga moslashtiriladi va shu turlar uchun optimallashtiriladi. Bu jihatdan Rustning umumlashtirilgan funksiyalari quyidagilar bilan deyarli teng unumdorlikka ega: C++ tilidagi shablonlar.

Parallel hisoblashlar

Tilning dastlabki versiyalarida yengil oqimlar qo‘llab-quvvatlangan, lekin keyinchalik ular o‘rniga operatsion tizimning mahalliy oqimlari tanlangan. Bunda oqimlar o‘rtasida ma’lumot almashishning tavsiya etilgan usuli umumiy xotiradan foydalanish emas, xabarlar yuborishdir. Yuqori unumdorlikka erishish uchun ma’lumotlarni nusxalamasdan, ularga egalik qiluvchi ko‘rsatkichlardan (Box<T>) foydalanib yuborish mumkin. Ular obyektning faqat bitta egasi bo‘lishini kafolatlaydi.

Amallarni aniqlash va chaqirish asinxron tarzda tilning o‘z sintaksisi yordamida qo‘llab-quvvatlanadi: async kalit so‘zi asinxron funksiyani yoki blokni e’lon qiladi. Bunday funksiyaning oddiy chaqiruvi Future treytiga ega obyektni — kechiktirib bajariladigan asinxron amal deskriptorini qaytaradi. .await chaqiruvi bitta asinxron amalga boshqa asinxron amal tugashini kutish imkonini beradi. Bunda asinxron amallarni bajarish muhiti (runtime) til yadrosi yoki standart kutubxonaga kirmaydi; uni tashqi kutubxonalar taqdim etadi.

Boshqa xususiyatlar

Modullar tizimi: kompilyatsiya birligi («crate») bir nechta moduldan iborat bo‘lishi mumkin. Modullariyerarxiyasi odatda loyiha kataloglari va fayllari iyerarxiyasiga mos keladi. Modul (odatda) alohida fayl bo‘lib, nomlar makoni (namespace) vazifasini ham bajaradi va identifikatorlarning ko‘rinishini boshqarish vositalaridan biridir. Modulning o‘zida va ichki modullarida barcha identifikatorlar ko‘rinadi, yuqori modullarda esa faqat ommaviy (pub) funksiyalar, turlar, treytlar, konstantalar, ichki modullar va struktura maydonlari ko‘rinadi.

Avtomatlashtirilgan sinov: til modul sinovlarini (unit tests) to‘g‘ridan-to‘g‘ri sinalayotgan modul yoki ichki modulda yaratish imkonini beradi. Sinov metodlari odatiy kompilyatsiyada e’tiborga olinmaydi va faqat test paytida chaqiriladi. Integratsion sinovlar alohida crate sifatida quyidagi katalogda joylashtiriladi: tests.

Avtomatik hujjatlashtirish: rustdoc vositasi manba kodning o‘zidan HTML hujjatlarini yaratadi. Koddagi hujjat izohlari uchta qiya chiziq (/// Пример документации) yoki modul hujjatlari uchun undov belgisi bilan kelgan ikkita qiya chiziq (//! Пример документации модуля) yordamida belgilanadi. Bunda Markdownbelgilash tili qo‘llab-quvvatlanadi. Hujjatga bajariladigan kod ham kiritilishi mumkin (hujjat sinovlari). Bu, jumladan, loyihaga o‘zgartirish kiritilganda hujjatlarning dolzarbligini tekshirish imkonini beradi.

Paketlarni boshqarish tizimi: paket menejeri cargo (loyihalarni yaratish, kompilyatsiya qilish va sinashning asosiy vositasi ham hisoblanadi) manifest fayli Cargo.toml orqali loyihaning bog‘liqliklarini (import qilinadigan crate paketlarini) aniqlaydi va kerakli paketlarni repozitoriydan (crates.io) yuklab oladi.

Identifikatorlarga qo‘yiladigan talablar: kompilyator o‘zgaruvchilar, turlar, funksiyalar va boshqalarning nomlanish qoidalariga (snake_case, UpperCamelCase, SCREAMING_SNAKE_CASE) rioya etilishini, shuningdek, ishlatilmaydigan identifikatorlarni tekshiradi. Ishlatilmaydigan identifikatorlar nomini pastki chiziq bilan boshlash tavsiya etiladi. Konstruktorlar, tur o‘zgartirish metodlari va boshqalarni nomlash bo‘yicha ham muayyan tavsiyalar mavjud.

Misollar

Hello, world!:

fn main() {
    println!("Hello, world!");
}

99 shisha pivo:

fn declension_of_noun(count: u8) -> &'static str {
    // исключения из правил
    if count >= 11 && count <= 14 {
        return "бутылок";
    }

    let remainder = count % 10;
    match remainder {
        1 => return "бутылка",
        2..=4 => return "бутылки",
        _ => return "бутылок",
    }
}

fn main() {
    let mut word = declension_of_noun(99);

    for i in (2..=99).rev() {
        println!("{} {} пива на стене", i, word);
        println!("{} {} пива!", i, word);
        println!("Возьми одну, пусти по кругу");

        word = declension_of_noun(i - 1);

        println!("{} {} пива на стене!\n", i - 1, word);
    }

    println!("1 бутылка пива на стене");
    println!("1 бутылка пива!");
    println!("Возьми одну, пусти по кругу");
    println!("Нет больше бутылок пива на стене!\n");
    println!("Нет бутылок пива на стене!");
    println!("Нет бутылок пива!");
    println!("Пойди в магазин и купи ещё");
    println!("99 бутылок пива на стене!");
}

Boshqa tillar bilan taqqoslash

Rustda xotira bilan ishlash tamoyillari xotiraga to‘liq murojaat qilish imkonini beradigan tillardan ham, chiqindilarni avtomatik yig‘uvchi (garbage collector)xotirani to‘liq boshqaradigan tillardan ham sezilarli farq qiladi. Rustning xotira modeli, bir tomondan, ko‘rsatkich turlarini ajratish va ularning ishlatilishini kompilyatsiya vaqtida nazorat qilish orqali dasturchiga ma’lumot qayerda saqlanishini boshqarish imkonini beradi. Boshqa tomondan, Rustning havolalarni sanash mexanizmi boshqa tillarda dastur ishlayotgan vaqtda xatoga yoki dasturning favqulodda to‘xtashiga olib keladigan holatlarda kompilyatsiya xatolarini aniqlashga intiladi.

Til funksiyalar va kod bloklarini «xavfsiz bo‘lmagan» (unsafe) deb e’lon qilishga ruxsat beradi. Bunday kod sohasida ayrim cheklovlar qo‘llanmaydi, shu bois quyi darajadagi amallarni bajarish mumkin, biroq dasturchi o‘z harakatlarini to‘liq tushunishi kerak.

Adabiyotlar

Havolalar