Rust

#[derive] (Debug, Clone, PartialEq)

#[derive(...)] i thotë kompajlerit të shkruajë vetë implementimin e disa trait-eve të zakonshme për struct-in tënd — Debug (për {:?}), Clone, PartialEq (për ==), Default, Hash.

Arc<Mutex<T>>

Për të ndryshuar të njëjtën vlerë nga disa thread-e, e mbështjell me Mutex (që vetëm një ta ndryshojë në një kohë) dhe me Arc (që ta ndajnë të gjithë). .lock() e kyç dhe zhkyçet vetë në fund të bllokut.

Arrays & slices (Rust)

Vargjet dhe slice-t në Rust

Një array në Rust ka madhësi të fiksuar ([i32; 3]), dhe një slice (&[i32]) është një pamje e huazuar mbi një pjesë të një array-i ose Vec-i. Rust-i kontrollon kufijtë — s'del dot jashtë.

Associated types

Tipet e shoqëruara

Një trait mund të ketë një tip „të shoqëruar“ që e vendos çdo implementim — p.sh. Iterator ka type Item, që tregon çfarë lloj elementesh jep. Kështu s'ke pse e shkruan si gjenerik kudo.

async / await (Rust)

Rust-i ka async/await si JavaScript-i, por me një dallim: një Future s'bën asgjë derisa një „runtime“ (si Tokio) ta ekzekutojë. Kështu programet mund të presin mijëra lidhje rrjeti me pak thread-e.

Bevy (game engine)

Bevy-ja është një motor lojërash falas në Rust, i ndërtuar mbi idenë ECS (Entity Component System): çdo gjë në lojë është një entitet me komponentë, dhe sistemet i përpunojnë. Shpejt po rritet.

Binary vs library crates

Crate-t binare dhe librari

Një projekt Rust me src/main.rs ndërtohet si program që ekzekutohet (binary crate); me src/lib.rs si librari që e përdorin të tjerët. Një projekt mund t'i ketë të dyja.

Borrow checker

Kontrolluesi i huazimeve

Borrow checker-i është pjesa e kompajlerit që kontrollon rregullat e pronësisë dhe huazimit. Ai i kap gabimet si „dangling pointer“ dhe race conditions para se programi të nisë. Fillestarët „luftojnë“ me të në fillim — pastaj e falënderojnë.

Borrowing & references (&, &mut)

Huazimi

Në vend që ta japësh vlerën, mund ta „huazosh“ me &: funksioni e lexon, por pronari mbetet ti. Me &mut e huazon për ta ndryshuar. Rregulli: shumë huazime për lexim, ose vetëm një për shkrim — kurrë të dyja njëherësh.

Box<T>

Box<T> e vendos një vlerë në heap dhe mban një pointer drejt saj. Përdoret për tipe rekursive (si pemët) dhe për objekte trait (Box<dyn Trait>). Lirohet vetë kur Box-i del nga blloku.

Cargo

Cargo-ja është mjeti që e bën gjithçka në Rust: krijon projekte (cargo new), i ndërton (cargo build), i ekzekuton (cargo run), shkarkon libraritë dhe ekzekuton testet. Është si npm-ja dhe Maven-i në një.

Cargo features

Feature-t e Cargo-s e lejojnë një crate të ketë pjesë opsionale që ndizen vetëm kur i kërkon — p.sh. serde = { features = ["derive"] }. Kështu programi s'mbart kod që s'e përdor.

Cargo workspaces

Një workspace bashkon disa crate të lidhura në një repository, me një Cargo.lock dhe një dosje target të përbashkët — si monorepo-t në JavaScript.

Cargo.toml & Cargo.lock

Cargo.toml përshkruan projektin Rust: emrin, versionin, edicionin dhe crate-t që i duhen. Cargo.lock fikson versionet e sakta. Formati TOML është i thjeshtë për t'u lexuar.

Channels (mpsc)

Kanalet në Rust

Një kanal lejon thread-et të dërgojnë mesazhe njëri-tjetrit: njëri dërgon me tx.send(), tjetri merr me rx.recv(). „Mos ndaj memorie për të komunikuar — komuniko për të ndarë memorie.“

clap (command-line apps)

clap-i të ndihmon të ndërtosh programe për terminal në Rust: me #[derive(Parser)] i përshkruan argumentet si struct, dhe ai e bën vetë leximin, kontrollin dhe --help-in. Shumë mjete moderne terminali janë shkruar kështu.

Clippy

Clippy-ja është linter-i i Rust-it: ka qindra rregulla që të sugjerojnë kod më të pastër, më të shpejtë ose më idiomatik. cargo clippy e ekzekuton — shumë i dobishëm për të mësuar „mënyrën e Rust-it“.

Clone & Copy

Për ta mbajtur origjinalin pasi e jep, bën .clone() — një kopje e plotë. Tipet e vogla si numrat dhe bool janë Copy: kopjohen vetë, pa zhvendosje. Mos e mbush kodin me clone() vetëm për ta qetësuar kompajlerin.

Closures (|x| ...)

Closure-t në Rust

Closure-t në Rust janë funksione të shkurtra pa emër të shkruara me vija: |x| x * 2. Mund të marrin variabla nga rrethina; me move i marrin me pronësi — e nevojshme kur i jep një thread-i.

Compile times in Rust

Koha e kompajlimit në Rust

Rust-i kompajlohet më ngadalë se shumë gjuhë, sepse kontrollon shumë gjëra dhe optimizon fort. cargo check vetëm kontrollon gabimet pa krijuar program — shumë më i shpejtë gjatë punës së përditshme.

const & static (Rust)

const krijon një konstante që zëvendësohet kudo ku përdoret; static krijon një vlerë me një adresë të vetme që jeton gjatë gjithë programit. static mut kërkon unsafe — zakonisht shmange.

crates.io

crates.io është depoja e paketave të Rust-it — librari që në Rust quhen „crates“. Me cargo add serde shton një crate në projekt.

Debug & Display

Debug ({:?}) e shfaq një vlerë për programuesin, me të gjitha detajet; Display ({}) e shfaq bukur për përdoruesin dhe duhet ta zbatosh vetë. Si toString() në Java.

Debug vs release builds

Ndërtimi debug dhe release

cargo build krijon një version debug — kompajlohet shpejt por ekzekutohet ngadalë. cargo build --release e optimizon plotësisht dhe mund të jetë 10–100 herë më i shpejtë. Mos mat kurrë shpejtësinë në debug!

Doc comments (///) & rustdoc

Komentet e dokumentimit në Rust

Komentet me /// mbi funksione dhe struct-e bëhen dokumentacion HTML me cargo doc. Shembujt e kodit brenda tyre ekzekutohen si teste — kështu dokumentacioni s'del kurrë jashtë kohe.

docs.rs

docs.rs krijon dhe publikon automatikisht dokumentacionin për çdo crate në crates.io. Kërkon emrin e crate-it dhe sheh të gjitha funksionet, struct-et dhe shembujt.

Drop (RAII in Rust)

Kur një vlerë del nga blloku, Rust-i thërret vetë Drop-in e saj — vendi për të mbyllur skedarë ose lidhje. Është RAII-ja e C++, por e garantuar nga gjuha.

Embedded Rust

Rust në pajisje të integruara

Me #![no_std], Rust-i punon edhe në mikrokontrollues pa sistem operativ — si C-ja, por me sigurinë e Rust-it. Përdoret gjithnjë e më shumë në vetura, pajisje mjekësore dhe IoT.

Enums (Rust)

Enum-et në Rust

Enum-et e Rust-it janë shumë më të fuqishme se në gjuhë të tjera: çdo variant mund të mbajë të dhënat e veta. Bashkë me match, janë mënyra kryesore për të modeluar gjendje të ndryshme.

Error handling crates (thiserror, anyhow)

Trajtimi i gabimeve në Rust

Për gabimet e tua, thiserror të ndihmon të krijosh tipe gabimi të qarta në librari, ndërsa anyhow e bën të lehtë trajtimin e çdo gabimi në aplikacione, me kontekst shtesë.

Expressions vs statements (Rust)

Shprehjet në Rust

Në Rust pothuajse gjithçka është shprehje që kthen vlerë — edhe if dhe blloqet { }. Prandaj shkruan let nota = if pike > 90 { 5 } else { 4 };. Një pikëpresje në fund e kthen shprehjen në urdhër pa vlerë.

Ferris & Rustaceans

Ferris dhe Rustaceanët

Ferris-i, gaforrja portokalli, është maskota jozyrtare e Rust-it, dhe programuesit e Rust-it e quajnë veten „Rustaceans“. Komuniteti është i njohur për mikpritjen ndaj fillestarëve.

Fn, FnMut & FnOnce

Rust-i i ndan closure-t sipas asaj që bëjnë me variablat që kapin: Fn vetëm lexon, FnMut i ndryshon, FnOnce i merr me pronësi dhe mund të thirret vetëm një herë. Kompajleri e zgjedh vetë.

From & Into

From dhe Into janë trait-et e Rust-it për konvertime: po zbatove From<&str> for Emri, mund të shkruash Emri::from("Arta") ose "Arta".into(). Operatori ? i përdor për të konvertuar gabimet vetë.

Functions in Rust (fn)

Funksionet në Rust

Funksionet në Rust krijohen me fn, parametrat kanë gjithmonë tip, dhe tipi i kthimit shkruhet pas ->. Rreshti i fundit pa pikëpresje është vlera që kthehet.

Generics (Rust)

Gjenerikët në Rust

Gjenerikët të lejojnë të shkruash një funksion ose struct që punon me shumë tipe: fn i_pari<T>(v: &[T]) -> Option<&T>. Rust-i krijon një version të veçantë për çdo tip gjatë kompajlimit, prandaj s'ka kosto shpejtësie.

HashMap (Rust)

HashMap ruan çifte çelës–vlerë. Me .entry(çelësi).or_insert(0) numëron diçka elegant — p.sh. sa herë shfaqet çdo fjalë.

if let & while let

if let është një match i shkurtër kur të intereson vetëm një rast: if let Some(emri) = opsioni { ... }. while let përsërit derisa modeli të mos përputhet më, dhe let ... else del herët nëse s'përputhet.

impl blocks & methods (self)

Metodat në Rust

Me impl i shton metoda një struct-i. Metodat marrin &self (lexojnë), &mut self (ndryshojnë) ose self (e marrin pronësinë). Funksionet pa self, si new(), thirren me Tipi::new().

impl Trait

impl Trait në parametra do të thotë „çdo tip që zbaton këtë trait“; në vlerën kthyese do të thotë „kthej një tip që e zbaton, pa e treguar emrin“ — shumë praktike për iteratorë dhe closure.

Integer overflow in Rust

Tejmbushja e numrave në Rust

Në versionin debug, Rust-i bën panic kur një numër tejmbushet; në release, „rrotullohet“ si në C. Për kontroll të qartë përdor checked_add() (kthen Option) ose wrapping_add() kur rrotullimi është i qëllimshëm.

Iterator adaptors (map, filter, collect)

Metodat e iteratorëve

Iteratorët kanë metoda zinxhir si map, filter, enumerate, zip, sum dhe collect. Janë „dembelë“: s'bëjnë asgjë derisa t'i kërkosh rezultatin, dhe kompajlohen aq shpejt sa një cikël i shkruar me dorë.

Iterators (Rust)

Iteratorët në Rust

Një iterator jep elementet një nga një me next(). .iter() huazon elementet, .iter_mut() i huazon për t'i ndryshuar, .into_iter() i merr me pronësi. Ciklet for punojnë mbi iteratorë.

let & mut (immutable by default)

Variablat dhe mut në Rust

Në Rust, variablat s'mund të ndryshohen si parazgjedhje: let x = 5; x = 6; jep gabim. Për ta lejuar, shkruan let mut x. Kështu e di menjëherë cilat vlera ndryshojnë.

Lifetime elision

Lënia jashtë e jetëgjatësive

Për rastet më të zakonshme, Rust-i i nënkupton vetë jetëgjatësitë sipas disa rregullave të thjeshta, që ti të mos i shkruash. Prandaj fn emri(&self) -> &str punon pa asnjë 'a.

Lifetimes ('a)

Jetëgjatësitë

Një lifetime i tregon kompajlerit sa kohë jeton një referencë, që të mos tregojë kurrë te diçka që është fshirë. Shumicën e kohës kompajleri i gjen vetë; vetëm ndonjëherë i shkruan ti me 'a.

Loops in Rust (loop, while, for)

Ciklet në Rust

Rust-i ka tri cikle: loop (pafund, derisa të bësh break — madje mund të kthejë vlerë), while (derisa një kusht është true) dhe for (për çdo element të një range-i ose koleksioni).

Macros (macro_rules!)

Makrot në Rust

Makrot në Rust (me ! në fund, si println! dhe vec!) shkruajnë kod për ty gjatë kompajlimit. Ndryshe nga makrot e C-së, janë të sigurta dhe kuptojnë strukturën e kodit. Makrot procedurale fuqizojnë #[derive].

match (Rust)

match e krahason një vlerë me disa modele dhe ekzekuton krahun e duhur. Kompajleri të detyron t'i mbulosh të gjitha rastet — po harrove një, s'kompajlohet.

Memory safety without GC

Siguria e memories pa garbage collector

Shumica e gjuhëve të sigurta (Java, Python) përdorin garbage collector; C dhe C++ janë të shpejta por të rrezikshme. Rust-i arrin të dyja: siguri pa GC, falë pronësisë dhe borrow checker-it. Prandaj e përdorin Microsoft, Google dhe Linux-i.

Modules (mod, pub, use)

Modulet në Rust

Kodi në Rust ndahet në module me mod. Çdo gjë është private si parazgjedhje — me pub e bën publike. Me use i sjell emrat në skedarin tënd: use crate::modelet::Nxenes;.

Move semantics (Rust)

Zhvendosja e pronësisë

Kur ia jep një String një variable tjetër ose një funksioni, pronësia „zhvendoset“ — e vjetra s'mund të përdoret më. Gabimi „use of moved value“ do të thotë pikërisht këtë. Tipet e vogla si i32 kopjohen në vend të kësaj.

Newtype pattern

Modeli newtype

Një „newtype“ është një struct me një fushë të vetme që mbështjell një tip tjetër: struct Metra(f64);. Kështu kompajleri s'të lejon t'i ngatërrosh metrat me kilometrat, edhe pse të dyja janë f64.

Option<T> (Some, None)

Rust-i s'ka null. Kur një vlerë mund të mungojë, përdor Option<T>: ose Some(vlera), ose None. Kompajleri të detyron ta trajtosh rastin None — kështu zhduket gabimi „null pointer“.

Other collections (HashSet, BTreeMap, VecDeque)

Koleksionet e tjera në Rust

Libraria standarde e Rust-it ka edhe HashSet (vlera unike), BTreeMap (çelësa të renditur), VecDeque (radhë nga të dy anët) dhe BinaryHeap (radhë me përparësi).

Ownership

Pronësia

Ideja kryesore e Rust-it: çdo vlerë ka një pronar të vetëm. Kur pronari del nga blloku, vlera fshihet vetë — pa garbage collector dhe pa free() me dorë. Kështu Rust-i është i shpejtë dhe i sigurt njëkohësisht.

panic!

panic! e ndal programin menjëherë me një mesazh — për gabime që s'duhet të ndodhin kurrë, si një indeks jashtë kufijve. Për gabime të pritshme (skedar që mungon), përdor Result.

PartialEq, Eq, PartialOrd, Ord

Këto trait-e i lejojnë tipet e tua të krahasohen: PartialEq për == dhe !=, PartialOrd për < dhe >, dhe Ord për renditje të plotë (që të mund të përdorësh sort()). Zakonisht i merr me #[derive].

Patterns & destructuring (Rust)

Modelet në Rust

Modelet në Rust e „shpaketojnë“ një vlerë në pjesët e saj — te let, match, if let dhe parametrat e funksioneve. Mund të shtosh edhe kushte (guards): Some(n) if n > 3.

println! & format!

println! shfaq tekst në terminal, dhe format! krijon një String. Pikëçuditja tregon që janë makro, jo funksione. {} shfaq vlerën bukur, {:?} e shfaq për debug.

Ranges (1..10, 1..=10)

Rangjet në Rust

1..10 është rangu nga 1 te 9 (pa 10), dhe 1..=10 përfshin edhe 10-ën. Përdoren në cikle for, për të marrë copa vargjesh (&v[1..3]) dhe në match.

Rayon

Rayon-i e bën paralelizmin shumë të lehtë: ndërron .iter() me .par_iter() dhe puna ndahet vetë mes të gjitha bërthamave të procesorit — pa race conditions, falë rregullave të Rust-it.

Rc & Arc (shared ownership)

Pronësia e përbashkët

Kur një vlerë duhet të ketë disa pronarë, Rc<T> numëron sa e përdorin dhe e fshin kur largohet i fundit. Arc<T> është i njëjti, por i sigurt për përdorim nga disa thread-e.

RefCell & interior mutability

RefCell dhe ndryshueshmëria e brendshme

RefCell<T> të lejon ta ndryshosh një vlerë edhe kur ke vetëm një referencë për lexim — rregullat e huazimit kontrollohen gjatë ekzekutimit në vend të kompajlimit. Shpesh përdoret bashkë me Rc.

reqwest

reqwest-i është libraria më e përdorur për kërkesa HTTP në Rust — si fetch-i në JavaScript ose requests-i në Python. Ka version async dhe version të thjeshtë „blocking“.

Result<T, E> (Ok, Err)

Rust-i s'ka përjashtime. Një funksion që mund të dështojë kthen Result: Ok(vlera) kur shkon mirë, Err(gabimi) kur jo. Kështu gabimet janë pjesë e tipit dhe s'mund t'i harrosh.

Rust-i është një gjuhë po aq e shpejtë sa C++, por që të mbron nga shumë gabime të rrezikshme me memorien që në momentin e kompajlimit. Është më e vështirë për fillestarët, por shumë e dashur nga programuesit.

Rust & WebAssembly (wasm-pack)

Rust dhe WebAssembly

Rust-i është një nga gjuhët më të mira për WebAssembly: me wasm-pack e kthen kodin Rust në një modul që e thërret nga JavaScript-i, për punë të rënda në shfletues — përpunim fotosh, lojëra, llogaritje.

Rust compiler error messages

Mesazhet e gabimit të Rust-it

Mesazhet e gabimit të Rust-it janë të famshme për qartësinë: të tregojnë rreshtin, shpjegojnë pse, dhe shpesh sugjerojnë rregullimin e saktë. Me rustc --explain E0382 lexon një shpjegim të gjatë me shembuj.

Rust data types (i32, u8, f64, usize)

Tipet e të dhënave në Rust

Rust-i i emërton numrat sipas madhësisë: i32 (numër i plotë me shenjë, 32 bit), u8 (pa shenjë, 0–255), f64 (me presje), usize (për indekse dhe madhësi). Ka edhe bool dhe char (çdo shkronjë Unicode).

Rust editions (2018, 2021, 2024)

Edicionet e Rust-it

Rust-i del me version të ri çdo 6 javë, por ndryshimet e mëdha vijnë në „edicione“ çdo tre vjet (2018, 2021, 2024). Çdo crate zgjedh edicionin e vet, dhe crate të edicioneve të ndryshme punojnë bashkë pa problem.

Rust in Linux & Windows

Rust në Linux dhe Windows

Rust-i është gjuha e dytë (pas C-së) që lejohet në kernel-in e Linux-it, dhe Microsoft-i po rishkruan pjesë të Windows-it në Rust. Arsyeja: shumica e dobësive të sigurisë vijnë nga gabime memorieje që Rust-i i parandalon.

Rust Playground

Rust Playground (play.rust-lang.org) të lejon të shkruash dhe ekzekutosh Rust në shfletues, pa instaluar asgjë, dhe ta ndash kodin me një link.

Rust vs C++

Rust kundrejt C++

Të dyja janë shumë të shpejta dhe afër harduerit. C++ ka dekada kod, libra dhe lojëra; Rust-i ofron siguri memorieje të garantuar, mjete moderne (Cargo) dhe mesazhe gabimi më të qarta — por mësohet më ngadalë në fillim.

rust-analyzer

rust-analyzer është „truri“ që i jep editorit (VS Code, Zed, RustRover) plotësimin e kodit, shfaqjen e tipeve dhe gabimet ndërsa shkruan. Instalohet si shtesë dhe e bën Rust-in shumë më të lehtë për t'u mësuar.

rustc

rustc është kompajleri i Rust-it, që e kthen kodin në program të ekzekutueshëm. Zakonisht s'e thërret vetë — Cargo-ja e bën për ty. Mesazhet e tij të gabimit janë ndër më të qartat në çdo gjuhë.

rustfmt

rustfmt e formaton kodin Rust automatikisht në stilin standard të komunitetit. cargo fmt dhe mbaron — s'ka më debate për hapësira dhe kllapa.

Rustlings

Rustlings-i është një koleksion i vogël ushtrimesh që i rregullon në terminal një nga një, derisa kompajlohen. E shoqëron „The Book“ dhe të mëson të lexosh mesazhet e gabimit.

rustup

rustup instalon dhe përditëson Rust-in në kompjuterin tënd. Me të mund të kesh disa versione (stable, beta, nightly) dhe të shtosh mjete si clippy ose kompajlim për WebAssembly.

Send & Sync

Send dhe Sync janë trait-e që kompajleri i vendos vetë: Send do të thotë „mund të kalohet te një thread tjetër“, Sync „mund të ndahet mes thread-eve“. Rc s'është Send — prandaj për thread-e përdor Arc.

Serde

Serde-ja është libraria standarde e Rust-it për serializim: me #[derive(Serialize, Deserialize)] struct-et e tua kthehen në JSON, TOML, YAML e shumë formate të tjera dhe anasjelltas.

Shadowing

Mbulimi i variablës

Në Rust mund ta deklarosh sërish një variabël me të njëjtin emër me let — e reja „mbulon“ të vjetrën, madje mund të ketë edhe tip tjetër. Shumë praktike kur e konverton një vlerë.

SQLx & Diesel

SQLx-i të lejon të shkruash SQL të zakonshëm që kontrollohet nga kompajleri kundrejt databazës së vërtetë; Diesel-i dhe SeaORM-i janë ORM për Rust. Të gjitha kapin gabimet e query-ve para ekzekutimit.

String vs &str

String dhe &str

Rust-i ka dy lloje teksti: String (i yti, mund të rritet dhe ndryshojë) dhe &str (një „pamje“ e huazuar e një teksti që ekziston diku tjetër). Funksionet zakonisht marrin &str dhe kthejnë String.

Structs (Rust)

Struct-et në Rust

Një struct grupon fusha të lidhura në një tip të ri: struct Nxenes { emri: String, nota: u8 }. Rust-i s'ka klasa — sjelljen ua shton struct-eve me impl.

Tauri

Tauri të lejon të ndërtosh programe kompjuteri (dhe mobile) me HTML, CSS dhe JavaScript për pamjen, dhe Rust për pjesën e brendshme. Programet janë shumë më të vogla se me Electron.

Testing in Rust (#[test], cargo test)

Testet në Rust

Testet në Rust shkruhen në të njëjtin skedar me kodin, me #[test] dhe makrot assert! dhe assert_eq!. cargo test i ekzekuton të gjitha — përfshirë shembujt në dokumentacion.

The ? operator

Operatori ?

Pikëpyetja pas një Result ose Option e kthen gabimin menjëherë te thirrësi nëse ka gabim, përndryshe të jep vlerën. E zëvendëson match-in e gjatë dhe e bën kodin me gabime shumë të shkurtër.

The Rust Book

Libri i Rust-it

„The Rust Programming Language“, i quajtur thjesht „The Book“, është libri zyrtar dhe falas online. Shpjegon gjithçka nga e para, me projekte të vogla — vendi i parë ku duhet të nisësh.

The unit type ()

Tipi bosh ()

() — „unit“ — është tipi që s'mban asnjë informacion. Një funksion pa vlerë kthimi kthen (), si void-i në gjuhë të tjera. E sheh shpesh si Result<(), Error> — „s'kthen gjë, por mund të dështojë“.

Threads (std::thread::spawn)

Thread-et në Rust

std::thread::spawn nis një thread të ri, dhe .join() pret ta mbarojë. Falë rregullave të pronësisë, Rust-i s'të lejon të ndash të dhëna mes thread-eve në mënyrë të pasigurt — i ashtuquajturi „fearless concurrency“.

Tokio

Tokio-ja është runtime-i më i përdorur për async në Rust: e ekzekuton kodin async, dhe ka mjete për rrjet, kohëmatës dhe kanale. Shumica e serverëve web në Rust ndërtohen mbi të.

Trait bounds (T: Trait, where)

Kufizimet me trait

Me T: Display ose where T: Clone kufizon një gjenerik: „çfarëdo tipi, mjafton të dijë të bëjë këtë“. Kështu brenda funksionit mund t'i përdorësh metodat e atij trait-i.

Trait objects (dyn Trait)

Objektet trait

Me dyn Trait (shpesh Box<dyn Trait>) mund të mbash në të njëjtën listë tipe të ndryshme që zbatojnë të njëjtin trait — p.sh. forma të ndryshme. Metoda e duhur zgjidhet gjatë ekzekutimit, si te funksionet virtuale të C++.

Traits (Rust)

Trait-et

Një trait përshkruan çfarë di të bëjë një tip — si interfejsat në Java. impl Zeri for Mace e jep atë aftësi, dhe mund ta zbatosh një trait edhe për tipe që s'janë të tuat.

Tuples (Rust)

Tuple-t në Rust

Një tuple grupon disa vlera të tipeve të ndryshme: ("Arta", 5). I lexon me .0, .1 ose duke e shpaketuar me let (emri, nota) = ...

Turbofish (::<>)

„Turbofish“-i ::<> i tregon Rust-it tipin kur s'e kupton dot vetë — p.sh. "5".parse::<i32>() ose .collect::<Vec<_>>(). Emri vjen nga forma që i ngjan një peshku.

unsafe

Brenda një blloku unsafe, mund të bësh gjëra që kompajleri s'i kontrollon dot — pointer-ë të papërpunuar, thirrje në C. S'do të thotë „i rrezikshëm“, por „përgjegjësia është e jotja“. Shumica e kodit Rust s'ka nevojë fare për të.

unwrap & expect

unwrap() e nxjerr vlerën nga një Option ose Result — por nëse është None ose Err, programi bën panic dhe ndalet. expect("mesazh") bën të njëjtën me një mesazh të qartë. Mirë për prototipe; në kod serioz trajtoji gabimet.

Vec<T>

Vec<T> është lista e Rust-it që rritet vetë — si vector-i i C++ ose ArrayList-i i Java-s. Krijohet shpejt me makron vec![1, 2, 3].

Web frameworks (Axum, Actix)

Framework-et web në Rust

Axum dhe Actix Web janë framework-et më të njohura për serverë web në Rust — shumë të shpejtë dhe me pak memorie. Axum-i ndërtohet mbi Tokio dhe është zgjedhja e zakonshme për projekte të reja.

Zero-cost abstractions

Abstraksionet pa kosto

Rust-i premton që mjetet e nivelit të lartë — iteratorët, gjenerikët, closure-t — kompajlohen në kod po aq të shpejtë sa ai që do ta shkruaje me dorë. Shkruan kod të lexueshëm pa paguar me shpejtësi.