dexblog.ro
RS

Învață Rust: comenzi explicate cu exemple

376 de comenzi 50 de categorii

Rust este limbajul care oferă viteza lui C și C++, dar previne la compilare erorile de memorie, datorită sistemului de ownership. Este folosit pentru unelte de sistem, servere, WebAssembly și chiar în nucleul Linux.

Mai jos găsești cuvintele cheie și conceptele de bază (ownership, borrowing, lifetimes, pattern matching), comenzile Cargo, macro-urile (println!, vec!) și cele mai folosite părți din std: String, Vec, HashMap, iteratori, Option și Result, trait-uri, pointeri inteligenți, fire de execuție, fișiere și timp.

Toate exemplele au fost compilate cu ediția 2024 (cu avertismentele tratate ca erori) și rulate; rezultatul afișat este cel real.

Bazele limbajului Rust 5 comenzi

Tipuri de date de bază 5 comenzi

Structuri de control și pattern matching 8 comenzi

Ownership, borrowing și lifetimes 3 comenzi

Structuri, enum-uri și trait-uri 8 comenzi

Closures și operatorul ? 2 comenzi

Module, macro-uri, atribute și teste 6 comenzi

Cod unsafe, FFI și async 3 comenzi

Cargo și rustup 13 comenzi

Macro-uri de afișare și formatare 6 comenzi

Macro-uri de verificare și panică 8 comenzi

Macro-uri evaluate la compilare 6 comenzi

String 19 comenzi

&str: metode pentru text 23 de comenzi

char: un caracter Unicode 9 comenzi

Formatare: fmt::Write și Formatter 3 comenzi

Vec: creare și modificare 14 comenzi

Vec și slice-uri: acces, căutare, sortare 14 comenzi

VecDeque: coada cu două capete 3 comenzi

HashMap: dicționare cheie-valoare 11 comenzi

Entry API: inserare și actualizare într-un pas 5 comenzi

HashSet: mulțimi 5 comenzi

BTreeMap și BTreeSet: colecții sortate 6 comenzi

BinaryHeap și Reverse: cozi de priorități 3 comenzi

Iteratori: trait-uri și colectare 5 comenzi

Adaptoare de iteratori (leneșe) 18 comenzi

Consumatori: rezultate din iteratori 16 comenzi

Crearea iteratorilor: std::iter și Range 5 comenzi

Closures: Fn, FnMut, FnOnce 1 comandă

Option: valori care pot lipsi 14 comenzi

Result: operații care pot eșua 8 comenzi

Erori, panică și ieșire din program 6 comenzi

Trait-uri de bază: Clone, Copy, Debug, Display, Default 5 comenzi

Comparare, ordonare și Hash 8 comenzi

Conversii între tipuri 6 comenzi

Operatori, Deref și Drop 4 comenzi

Trait-uri marker și tipuri speciale 4 comenzi

Pointeri inteligenți: Box, Rc, Arc 5 comenzi

Mutabilitate interioară: Cell și RefCell 3 comenzi

Sincronizare: Mutex, RwLock, atomice, OnceLock 6 comenzi

Fire de execuție și canale 6 comenzi

std::mem: mutare, înlocuire, dimensiuni 5 comenzi

Fișiere: std::fs, File, OpenOptions 12 comenzi

Intrare și ieșire: std::io 10 comenzi

Mediul programului și procese 8 comenzi

Căi: Path și PathBuf 6 comenzi

Timp: Instant, Duration, SystemTime 4 comenzi

Numere întregi: i32 10 comenzi

Numere zecimale: f64 10 comenzi

Octeți: u8 3 comenzi

Toate funcțiile

Lista completă a cuvintelor cheie, macro-urilor, tipurilor și metodelor din biblioteca standard Rust incluse în această secțiune. Cele cu link au o pagină dedicată.

Cuvinte cheie, construcții și Cargo (77)

Funcție Ce face
as Conversie explicită între tipuri numerice (300 as u8 = 44); în use, redenumește un import.
async Marchează o funcție sau un bloc care returnează un Future, rulat de un executor.
await Așteaptă rezultatul unui Future în cod async, fără să blocheze firul.
break Oprește o buclă; în loop poate returna o valoare, iar cu etichetă oprește o buclă exterioară.
const Constantă calculată la compilare, cu tip obligatoriu (const TVA: f64 = 0.21;).
continue Sare peste restul pasului curent și trece la următorul pas al buclei.
crate Unitatea de compilare (program sau bibliotecă); crate:: pornește o cale de la rădăcina ei.
dyn Marchează un trait object (Box<dyn Trait>): tipul exact este ales la rulare.
else Ramura executată când condiția lui if este falsă; else if adaugă alte condiții.
enum Tip cu mai multe variante, fiecare cu propriile date (ca Option și Result).
extern Declară funcții din alte limbaje (unsafe extern „C”) sau funcții Rust apelabile din C.
false Valoarea „fals” a tipului bool.
fn Declară o funcție; ultima expresie fără ; este valoarea returnată.
for Parcurge elementele unui interval, al unei colecții sau al unui iterator.
if Execută un bloc dacă o condiție bool este adevărată; este și expresie (dă o valoare).
impl Adaugă metode unui tip sau implementează un trait pentru el (impl Trait for Tip).
in Separă variabila de colecția parcursă în bucla for x in colectie.
let Creează o variabilă, imuabilă implicit; acceptă tipare (let (a, b) = t;).
loop Buclă infinită, oprită cu break; break valoare face din ea o expresie.
match Compară o valoare cu tipare și execută prima ramură potrivită; trebuie să fie exhaustiv.
mod Declară un modul, în același fișier sau încărcat din nume.rs.
move Face un closure să ia proprietatea variabilelor capturate (necesar pentru thread::spawn).
mut Permite modificarea unei variabile (let mut) sau a valorii printr-o referință (&mut).
pub Face vizibil în afara modulului o funcție, un tip, un câmp sau un modul.
ref Într-un tipar, leagă prin referință în loc să mute valoarea.
return Iese din funcție imediat, cu o valoare; de obicei folosit doar pentru ieșiri timpurii.
self Valoarea pe care se apelează o metodă (&self, &mut self, self) sau modulul curent în căi.
Self Tipul pentru care este scris blocul impl sau trait-ul (fn new() -> Self).
static Element global cu o singură adresă, care trăiește tot programul.
struct Definește un tip cu câmpuri numite (sau tuple struct, unit struct).
super În căi, înseamnă modulul părinte (super::functie()).
trait Set de metode pe care tipurile îl pot implementa, ca interfețele din alte limbaje.
true Valoarea „adevărat” a tipului bool.
type Alias pentru un tip existent (type Rezultat<T> = Result<T, String>) sau tip asociat într-un trait.
unsafe Bloc sau funcție în care sunt permise operații neverificate, ca dereferențierea pointerilor bruți.
use Aduce în domeniu un nume dintr-un modul, ca să nu scrii calea completă.
where Clauză care listează limitele (trait bounds) ale parametrilor generici după semnătură.
while Repetă un bloc cât timp o condiție bool rămâne adevărată.
main Funcția cu care pornește programul; poate returna Result ca să folosească ?.
variabile și mutabilitate Variabilele sunt imuabile implicit; let mut le permite să-și schimbe valoarea.
shadowing Un nou let cu același nume ascunde variabila veche și poate schimba chiar tipul.
tipuri scalare Întregi (i32, u8, usize…), f32/f64, bool și char (caracter Unicode de 4 octeți).
tuple Grup fix de valori de tipuri diferite, accesate cu .0, .1 sau prin desfacere.
array Șir de lungime fixă [T; N], păstrat pe stivă, cu acces verificat după indice.
slice-uri Referință la o parte dintr-un array, Vec sau text (&[T], &str), fără copiere.
ownership Fiecare valoare are un singur proprietar; la atribuire se mută, la ieșirea din bloc se eliberează.
borrowing și referințe Împrumut cu & sau &mut: oricâte referințe de citire sau una singură de modificare.
lifetimes Adnotări ‘a care leagă durata referințelor, ca să nu existe referințe spre memorie eliberată.
closures Funcții anonime |x| x + 1 care pot captura variabilele din jur (Fn, FnMut, FnOnce).
pattern matching Tipare care desfac valori: tupluri, structuri, slice-uri, intervale, @ și ref.
if let și let else Execută cod doar dacă o valoare se potrivește cu un tipar sau iese imediat din funcție.
while let Repetă o buclă cât timp o valoare se potrivește cu un tipar (while let Some(x) = v.pop()).
operatorul ? Dă valoarea din Ok/Some sau returnează imediat eroarea (None) din funcția curentă.
generics Funcții și tipuri scrise o dată pentru orice tip T, cu limite ca T: PartialOrd.
trait objects (dyn Trait) Box<dyn Trait> sau &dyn Trait: valori de tipuri diferite cu același trait, alese la rulare.
impl Trait „Un tip care implementează Trait”: generic în parametri, tip ascuns în rezultat.
macro_rules! Definește macro-uri proprii pe bază de tipare, cu număr variabil de argumente.
module și vizibilitate mod organizează codul, totul e privat implicit, pub îl face vizibil; căi cu crate:: și super::.
atribute (#[derive], #[cfg]) #[derive] generează trait-uri, #[cfg] alege codul compilat, #[allow] schimbă avertismentele.
comentarii și documentație (///) // și /* */ sunt comentarii; /// și //! scriu documentație Markdown cu exemple testate.
teste (#[test]) Funcții marcate #[test], de obicei în mod tests cu #[cfg(test)], rulate cu cargo test.
unsafe și pointeri bruți Pointeri *const T și *mut T, dereferențiați doar în unsafe, cu garanțiile date de tine.
async și await Programare asincronă cu Future: async creează, .await așteaptă, un executor (tokio) rulează.
conversii numerice (as) as convertește între tipuri numerice fără erori, dar poate tăia sau satura valoarea.
cargo new Creează un proiect nou: Cargo.toml, src/main.rs (sau lib.rs cu –lib) și un depozit git.
cargo build Compilează proiectul în target/debug sau, cu –release, optimizat în target/release.
cargo run Compilează dacă e nevoie și rulează programul; argumentele vin după –.
cargo check Verifică rapid dacă proiectul se compilează, fără să producă executabilul.
cargo test Rulează testele #[test], testele din tests/ și exemplele din documentație.
cargo add Adaugă o dependență de pe crates.io în Cargo.toml (cu –features, –dev).
cargo fmt Formatează automat tot codul după stilul oficial (rustfmt); –check doar verifică.
cargo clippy Analizează codul cu sute de reguli și dă sfaturi de corectare și simplificare.
cargo doc Generează documentația HTML din comentariile /// (în target/doc), cu –open o deschide.
cargo update Actualizează versiunile din Cargo.lock la cele mai noi compatibile cu Cargo.toml.
cargo publish Publică o bibliotecă pe crates.io; o versiune publicată nu mai poate fi ștearsă.
Cargo.toml Configurarea proiectului: nume, versiune, ediție, dependențe, features, profiluri.
rustup Instalează și actualizează Rust (stable, beta, nightly), componente și ținte de compilare.

Macro-uri (27)

Funcție Ce face
println! Afișează text formatat pe ieșirea standard și trece la rândul următor.
std::println
print! Afișează text formatat pe ieșirea standard, fără rând nou la final.
std::print
eprintln! Ca println!, dar scrie pe ieșirea de eroare (stderr).
std::eprintln
eprint! Ca print!, dar scrie pe ieșirea de eroare (stderr), fără rând nou.
std::eprint
format! Construiește un String din șablon și valori ({}, {:?}, {:.2}, {:>8}…).
std::format
vec! Creează un Vec cu elementele date (vec![1, 2]) sau cu n copii (vec![0; n]).
std::vec
panic! Oprește firul curent cu un mesaj de eroare; în main, programul se termină cu codul 101.
std::panic
assert! Dă panică dacă o condiție este falsă, cu mesaj opțional.
std::assert
assert_eq! Dă panică dacă două valori nu sunt egale și le afișează pe amândouă (left/right).
std::assert_eq
assert_ne! Dă panică dacă două valori sunt egale.
std::assert_ne
debug_assert! Ca assert!, dar verificat doar în modul debug, nu și în release.
std::debug_assert
dbg! Afișează pe stderr fișierul, linia, expresia și valoarea ei, apoi returnează valoarea.
std::dbg
todo! Ține locul unui cod încă nescris; dă panică „not yet implemented” dacă se ajunge acolo.
std::todo
unimplemented! Marchează o funcționalitate nesuportată; dă panică „not implemented”.
std::unimplemented
unreachable! Marchează cod la care execuția nu ar trebui să ajungă; dă panică dacă ajunge.
std::unreachable
write! Scrie text formatat într-un String, fișier sau Formatter; returnează Result.
std::write
writeln! Ca write!, cu rând nou la final.
std::writeln
matches! Returnează true dacă o valoare se potrivește cu un tipar (matches!(c, ‘a’..=’z’)).
std::matches
include_str! Include la compilare conținutul unui fișier text ca &’static str.
std::include_str
env! Citește la compilare o variabilă de mediu (CARGO_PKG_VERSION); lipsa ei e eroare.
std::env
concat! Lipește literali într-un singur &’static str, la compilare.
std::concat
cfg! Dă true sau false la compilare după configurare (cfg!(windows), cfg!(debug_assertions)).
std::cfg
line! Numărul liniei din codul sursă pe care este scris macro-ul.
std::line
file! Calea fișierului sursă în care este scris macro-ul.
std::file
stringify! Transformă codul primit în text, fără să-l execute.
std::stringify
format_args! Pregătește un fmt::Arguments fără alocare; baza tuturor macro-urilor de formatare.
std::format_args
thread_local! Declară variabile statice cu câte o copie separată pentru fiecare fir de execuție.
std::thread_local

Text: String, &str și char (79)

Funcție Ce face
String Text deținut și modificabil, UTF-8, pe heap; perechea lui &str.
std::string::String
String::new Creează un String gol, fără alocare de memorie.
std::string::String
String::from Creează un String nou dintr-un &str, char sau alt text (copiază conținutul).
std::string::String
String::with_capacity Creează un String gol cu loc rezervat pentru cel puțin n octeți.
std::string::String
String::push Adaugă un singur caracter (char) la finalul textului.
std::string::String
String::push_str Adaugă un &str la finalul textului.
std::string::String
String::pop Scoate și returnează ultimul caracter, ca Option<char>.
std::string::String
String::insert Inserează un caracter la o poziție dată în octeți.
std::string::String
String::insert_str Inserează un text la o poziție dată în octeți.
std::string::String
String::remove Șterge și returnează caracterul de la o poziție în octeți.
std::string::String
String::clear Golește textul, dar păstrează memoria rezervată.
std::string::String
String::len Lungimea textului în octeți (nu în litere: ș, ț ocupă 2 octeți).
std::string::String
String::is_empty Verifică dacă textul nu are niciun octet.
std::string::String
String::capacity Câți octeți încap în memoria rezervată fără realocare.
std::string::String
String::as_str Returnează un &str spre tot textul; util la match.
std::string::String
String::truncate Scurtează textul la primii n octeți (pe granița unui caracter).
std::string::String
String::retain Păstrează doar caracterele pentru care funcția dată returnează true.
std::string::String
String::drain Scoate un interval de octeți și îl returnează ca iterator de caractere.
std::string::String
String::replace_range Înlocuiește pe loc un interval de octeți cu alt text.
std::string::String
String::split_off Taie textul în două la o poziție; returnează partea a doua.
std::string::String
String::into_bytes Transformă String-ul în Vec<u8> cu octeții UTF-8, fără copiere.
std::string::String
String::from_utf8 Creează un String din Vec<u8>, cu eroare dacă octeții nu sunt UTF-8 valid.
std::string::String
String::from_utf8_lossy Creează text din octeți, înlocuind secvențele invalide cu �.
std::string::String
String::chars Parcurge caracterele textului (char), nu octeții.
std::string::String
String::repeat Returnează un String nou cu textul repetat de n ori.
std::string::String
str Bucată de text UTF-8 împrumutată (&str): literali, părți din String, parametri.
tip primitiv str
str::len Lungimea în octeți a unui &str.
tip primitiv str
str::is_empty Verifică dacă &str-ul este gol.
tip primitiv str
str::chars Iterator peste caracterele Unicode; chars().count() dă numărul de litere.
tip primitiv str
str::bytes Iterator peste octeții UTF-8 ai textului (u8).
tip primitiv str
str::char_indices Iterator de perechi (poziție în octeți, caracter).
tip primitiv str
str::lines Împarte textul pe linii (\n sau \r\n), fără sfârșitul de linie.
tip primitiv str
str::split Împarte textul la fiecare separator; păstrează bucățile goale.
tip primitiv str
str::split_whitespace Împarte textul în cuvinte la orice spațiu alb, fără bucăți goale.
tip primitiv str
str::splitn Împarte textul în cel mult n bucăți; ultima conține restul.
tip primitiv str
str::rsplit Ca split, dar dă bucățile de la final spre început.
tip primitiv str
str::split_once Taie la prima apariție a separatorului: Option<(stânga, dreapta)>.
tip primitiv str
str::trim Elimină spațiile albe de la ambele capete.
tip primitiv str
str::trim_start Elimină spațiile albe de la începutul textului.
tip primitiv str
str::trim_end Elimină spațiile albe de la finalul textului.
tip primitiv str
str::trim_matches Elimină de la capete, repetat, caracterele care se potrivesc cu modelul.
tip primitiv str
str::strip_prefix Scoate o dată un prefix: Some(rest) sau None dacă lipsește.
tip primitiv str
str::strip_suffix Scoate o dată un sufix: Some(rest) sau None dacă lipsește.
tip primitiv str
str::starts_with Verifică dacă textul începe cu un text, caracter sau condiție.
tip primitiv str
str::ends_with Verifică dacă textul se termină cu un text, caracter sau condiție.
tip primitiv str
str::contains Verifică dacă textul conține un text, un caracter sau o condiție.
tip primitiv str
str::find Poziția în octeți a primei apariții, ca Option<usize>.
tip primitiv str
str::rfind Poziția în octeți a ultimei apariții, ca Option<usize>.
tip primitiv str
str::replace Returnează un String nou cu toate aparițiile înlocuite.
tip primitiv str
str::replacen Returnează un String nou cu primele n apariții înlocuite.
tip primitiv str
str::to_uppercase Copie cu litere mari după regulile Unicode (ș devine Ș).
tip primitiv str
str::to_lowercase Copie cu litere mici după regulile Unicode.
tip primitiv str
str::to_ascii_uppercase Copie în care doar literele ASCII a-z devin mari; diacriticele rămân.
tip primitiv str
str::to_string Copiază un &str într-un String nou (din trait-ul ToString).
tip primitiv str
str::to_owned Copiază un &str într-un String nou (din trait-ul ToOwned).
tip primitiv str
str::parse Transformă textul în număr, bool sau alt tip FromStr; returnează Result.
tip primitiv str
str::get Tăiere sigură după octeți: Option<&str>, None în loc de panică.
tip primitiv str
str::is_char_boundary Verifică dacă o poziție în octeți este începutul unui caracter.
tip primitiv str
str::eq_ignore_ascii_case Compară două texte ignorând literele mari/mici ASCII.
tip primitiv str
str::matches Iterator cu aparițiile modelului în text; .count() le numără.
tip primitiv str
str::as_bytes Octeții UTF-8 ai textului, ca felie &[u8].
tip primitiv str
char Un caracter Unicode (‘ș’), 4 octeți în memorie, 1-4 octeți în UTF-8.
tip primitiv char
char::is_alphabetic Verifică dacă un caracter este literă, în orice alfabet.
tip primitiv char
char::is_numeric Verifică dacă un caracter este numeric în Unicode (inclusiv ½, ², Ⅻ).
tip primitiv char
char::is_alphanumeric Verifică dacă un caracter este literă sau caracter numeric.
tip primitiv char
char::is_whitespace Verifică dacă un caracter este spațiu alb (spațiu, tab, linie nouă etc.).
tip primitiv char
char::is_uppercase Verifică dacă un caracter este literă mare.
tip primitiv char
char::is_lowercase Verifică dacă un caracter este literă mică.
tip primitiv char
char::to_uppercase Litera mare a caracterului, ca iterator (ß devine SS).
tip primitiv char
char::to_lowercase Litera mică a caracterului, ca iterator.
tip primitiv char
char::to_digit Valoarea unei cifre într-o bază dată (‘f’ în baza 16 dă 15), ca Option<u32>.
tip primitiv char
char::from_digit Caracterul pentru o cifră într-o bază dată, ca Option<char>.
tip primitiv char
char::is_ascii_digit Verifică dacă un caracter este una dintre cifrele 0-9.
tip primitiv char
char::len_utf8 Câți octeți ocupă caracterul în UTF-8 (1-4).
tip primitiv char
char::from_u32 Caracterul cu un anumit cod Unicode, sau None dacă codul nu e valid.
tip primitiv char
fmt::Write Trait pentru scrierea de text formatat cu write!/writeln! într-un String.
std::fmt::Write
fmt::Formatter Destinația și opțiunile ({:>10}, {:.2}, {:#}) primite de fmt() în Display/Debug.
std::fmt::Formatter
fmt::Formatter::write_str Scrie un text fix în Formatter, fără formatare.
std::fmt::Formatter
fmt::Formatter::debug_struct Ajutor pentru Debug manual în formatul Nume { camp: valoare }.
std::fmt::Formatter

Colecții și slice-uri (113)

Funcție Ce face
Vec Vectorul dinamic: listă de elemente de același tip, continuă în memorie, care crește singură.
std::vec::Vec
Vec::new Creează un vector gol, fără memorie alocată până la primul element.
std::vec::Vec
Vec::with_capacity Creează un vector gol cu loc rezervat pentru cel puțin n elemente.
std::vec::Vec
Vec::push Adaugă un element la sfârșitul vectorului.
std::vec::Vec
Vec::pop Scoate ultimul element și îl returnează ca Option (None pentru vector gol).
std::vec::Vec
Vec::insert Inserează un element pe o poziție și mută restul elementelor la dreapta.
std::vec::Vec
Vec::remove Scoate elementul de pe o poziție, îl returnează și mută restul la stânga.
std::vec::Vec
Vec::swap_remove Scoate elementul de pe o poziție și pune ultimul element în locul lui (rapid, schimbă ordinea).
std::vec::Vec
Vec::clear Șterge toate elementele; capacitatea rămâne.
std::vec::Vec
Vec::len Numărul de elemente din vector.
std::vec::Vec
Vec::is_empty Spune dacă vectorul nu are niciun element.
std::vec::Vec
Vec::capacity Câte elemente încap în vector fără o nouă alocare de memorie.
std::vec::Vec
Vec::reserve Rezervă loc pentru cel puțin încă n elemente.
std::vec::Vec
Vec::truncate Păstrează doar primele n elemente și le elimină pe celelalte.
std::vec::Vec
Vec::extend_from_slice Adaugă la final copii ale tuturor elementelor dintr-un slice.
std::vec::Vec
Vec::append Mută toate elementele altui vector la final și îl lasă pe acela gol.
std::vec::Vec
Vec::drain Scoate elementele dintr-un interval de poziții și le dă ca iterator.
std::vec::Vec
Vec::retain Păstrează doar elementele pentru care condiția dată este adevărată.
std::vec::Vec
Vec::dedup Elimină duplicatele alăturate (după sortare, toate duplicatele).
std::vec::Vec
Vec::dedup_by_key Elimină elementele alăturate care au aceeași cheie calculată.
std::vec::Vec
Vec::split_off Taie vectorul la o poziție și returnează partea a doua ca vector nou.
std::vec::Vec
Vec::resize Schimbă lungimea: taie sau completează cu copii ale unei valori.
std::vec::Vec
Vec::sort Sortează crescător, pe loc, păstrând ordinea elementelor egale (stabilă).
std::vec::Vec
Vec::sort_by Sortează pe loc după o funcție de comparare proprie.
std::vec::Vec
Vec::sort_by_key Sortează pe loc după o cheie calculată din fiecare element.
std::vec::Vec
Vec::sort_unstable Sortează crescător, mai rapid, fără garanția ordinii elementelor egale.
std::vec::Vec
Vec::iter Iterator care dă referințe la elemente, fără să consume vectorul.
std::vec::Vec
Vec::iter_mut Iterator care dă referințe mutabile, ca elementele să fie modificate pe loc.
std::vec::Vec
Vec::into_iter Consumă vectorul și dă elementele prin valoare.
std::vec::Vec
Vec::contains Spune dacă vectorul conține un element egal cu valoarea dată.
std::vec::Vec
Vec::first Primul element, ca Option.
std::vec::Vec
Vec::last Ultimul element, ca Option.
std::vec::Vec
Vec::get Elementul (sau bucata) de la o poziție, ca Option, fără panic.
std::vec::Vec
Vec::get_mut Referință mutabilă la elementul de pe o poziție, ca Option.
std::vec::Vec
Vec::binary_search Caută rapid într-un vector sortat: Ok(poziție) sau Err(locul de inserare).
std::vec::Vec
Vec::reverse Inversează pe loc ordinea elementelor.
std::vec::Vec
Vec::windows Iterator de ferestre suprapuse de câte n elemente consecutive.
std::vec::Vec
Vec::chunks Iterator de bucăți separate de câte n elemente (ultima poate fi mai mică).
std::vec::Vec
Vec::concat Lipește o listă de liste sau de texte într-un singur vector sau text.
std::vec::Vec
Vec::join Lipește o listă de liste sau de texte, cu un separator între ele.
std::vec::Vec
Vec::split_at Împarte vectorul în două slice-uri la o poziție, fără copiere.
std::vec::Vec
Vec::starts_with Spune dacă vectorul începe cu elementele date.
std::vec::Vec
Vec::to_vec Copiază un slice într-un Vec nou.
std::vec::Vec
Vec::fill Scrie aceeași valoare în toate pozițiile.
std::vec::Vec
Vec::rotate_left Rotește elementele spre stânga: primele n trec la final.
std::vec::Vec
VecDeque Coadă cu două capete: adăugare și scoatere rapidă la început și la sfârșit.
std::collections::VecDeque
VecDeque::new Creează o coadă VecDeque goală.
std::collections::VecDeque
VecDeque::push_back Adaugă un element la sfârșitul cozii.
std::collections::VecDeque
VecDeque::push_front Adaugă un element la începutul cozii.
std::collections::VecDeque
VecDeque::pop_back Scoate ultimul element, ca Option.
std::collections::VecDeque
VecDeque::pop_front Scoate primul element, ca Option (coadă FIFO).
std::collections::VecDeque
VecDeque::front Primul element, fără să-l scoată.
std::collections::VecDeque
VecDeque::back Ultimul element, fără să-l scoată.
std::collections::VecDeque
VecDeque::len Numărul de elemente din coadă.
std::collections::VecDeque
HashMap Dicționar cheie-valoare cu căutare rapidă după cheie; ordinea nu este garantată.
std::collections::HashMap
HashMap::new Creează un dicționar gol.
std::collections::HashMap
HashMap::with_capacity Creează un dicționar gol cu loc pentru cel puțin n perechi.
std::collections::HashMap
HashMap::insert Pune o pereche cheie-valoare; returnează valoarea veche, dacă exista.
std::collections::HashMap
HashMap::get Valoarea unei chei, ca Option (fără panic pentru cheie lipsă).
std::collections::HashMap
HashMap::get_mut Referință mutabilă la valoarea unei chei, ca Option.
std::collections::HashMap
HashMap::remove Scoate o cheie și returnează valoarea ei, ca Option.
std::collections::HashMap
HashMap::contains_key Spune dacă o cheie există în dicționar.
std::collections::HashMap
HashMap::entry Locul unei chei (Entry), pentru inserare sau actualizare dintr-o singură căutare.
std::collections::HashMap
HashMap::len Numărul de perechi cheie-valoare.
std::collections::HashMap
HashMap::is_empty Spune dacă dicționarul nu are nicio pereche.
std::collections::HashMap
HashMap::keys Iterator peste chei (ordine aleatorie).
std::collections::HashMap
HashMap::values Iterator peste valori (ordine aleatorie).
std::collections::HashMap
HashMap::values_mut Iterator peste valori ca referințe mutabile, pentru modificare.
std::collections::HashMap
HashMap::iter Iterator peste perechile (&cheie, &valoare), în ordine aleatorie.
std::collections::HashMap
HashMap::iter_mut Iterator peste perechile (&cheie, &mut valoare).
std::collections::HashMap
HashMap::clear Șterge toate perechile; memoria rămâne alocată.
std::collections::HashMap
HashMap::retain Păstrează doar perechile pentru care condiția dată este adevărată.
std::collections::HashMap
HashMap::extend Adaugă perechile unui iterator; cheile existente primesc valoarea nouă.
std::collections::HashMap
HashMap::drain Golește dicționarul și dă toate perechile ca iterator.
std::collections::HashMap
Entry Locul unei chei într-un HashMap: Occupied (există) sau Vacant (lipsește).
std::collections::hash_map::Entry
Entry::or_insert Inserează valoarea dacă cheia lipsește și returnează &mut la valoarea cheii.
std::collections::hash_map::Entry
Entry::or_insert_with Ca or_insert, dar valoarea e calculată de un closure doar dacă e nevoie.
std::collections::hash_map::Entry
Entry::or_default Inserează valoarea implicită a tipului (0, vector gol) dacă cheia lipsește.
std::collections::hash_map::Entry
Entry::and_modify Modifică valoarea dacă cheia există; se înlănțuiește cu or_insert.
std::collections::hash_map::Entry
HashSet Mulțime: fiecare valoare o singură dată, verificare rapidă a existenței.
std::collections::HashSet
HashSet::new Creează o mulțime goală.
std::collections::HashSet
HashSet::insert Adaugă o valoare; returnează false dacă exista deja.
std::collections::HashSet
HashSet::contains Spune dacă valoarea se află în mulțime.
std::collections::HashSet
HashSet::remove Scoate o valoare; returnează true dacă exista.
std::collections::HashSet
HashSet::len Numărul de elemente distincte.
std::collections::HashSet
HashSet::union Reuniunea: elementele din oricare dintre cele două mulțimi.
std::collections::HashSet
HashSet::intersection Intersecția: elementele comune ambelor mulțimi.
std::collections::HashSet
HashSet::difference Diferența: elementele din prima mulțime care lipsesc din a doua.
std::collections::HashSet
HashSet::symmetric_difference Elementele care se află în exact una dintre cele două mulțimi.
std::collections::HashSet
HashSet::is_subset Spune dacă toate elementele se află și în cealaltă mulțime.
std::collections::HashSet
HashSet::iter Iterator peste elementele mulțimii, în ordine aleatorie.
std::collections::HashSet
BTreeMap Dicționar cu cheile mereu sortate; permite intervale de chei.
std::collections::BTreeMap
BTreeMap::new Creează un BTreeMap gol.
std::collections::BTreeMap
BTreeMap::insert Pune o pereche cheie-valoare; returnează valoarea veche, dacă exista.
std::collections::BTreeMap
BTreeMap::get Valoarea unei chei, ca Option.
std::collections::BTreeMap
BTreeMap::range Iterator peste perechile cu cheile într-un interval, în ordine.
std::collections::BTreeMap
BTreeMap::first_key_value Perechea cu cea mai mică cheie.
std::collections::BTreeMap
BTreeMap::last_key_value Perechea cu cea mai mare cheie.
std::collections::BTreeMap
BTreeMap::remove Scoate o cheie și returnează valoarea ei, ca Option.
std::collections::BTreeMap
BTreeSet Mulțime cu elementele mereu sortate.
std::collections::BTreeSet
BTreeSet::new Creează un BTreeSet gol.
std::collections::BTreeSet
BTreeSet::insert Adaugă o valoare; returnează false dacă exista deja.
std::collections::BTreeSet
BTreeSet::contains Spune dacă valoarea se află în mulțime.
std::collections::BTreeSet
BTreeSet::range Iterator peste elementele dintr-un interval de valori, în ordine.
std::collections::BTreeSet
BTreeSet::first Cel mai mic element.
std::collections::BTreeSet
BTreeSet::last Cel mai mare element.
std::collections::BTreeSet
BinaryHeap Coadă de priorități: scoate mereu cel mai mare element.
std::collections::BinaryHeap
BinaryHeap::new Creează un BinaryHeap gol.
std::collections::BinaryHeap
BinaryHeap::push Adaugă un element în heap.
std::collections::BinaryHeap
BinaryHeap::pop Scoate și returnează cel mai mare element, ca Option.
std::collections::BinaryHeap
BinaryHeap::peek Arată cel mai mare element, fără să-l scoată.
std::collections::BinaryHeap
BinaryHeap::into_sorted_vec Consumă heap-ul și returnează un vector sortat crescător.
std::collections::BinaryHeap
Reverse Învelitoare care inversează ordinea: min-heap și sortare descrescătoare după cheie.
std::cmp::Reverse

Iteratori și closures (63)

Funcție Ce face
Iterator Trait-ul șirurilor de valori produse pe rând; adaptoarele lui sunt leneșe.
std::iter::Iterator
Iterator::next Dă următoarea valoare în Some, sau None când iteratorul s-a terminat.
std::iter::Iterator
Iterator::map Transformă fiecare element cu o funcție (adaptor leneș).
std::iter::Iterator
Iterator::filter Păstrează doar elementele care îndeplinesc o condiție.
std::iter::Iterator
Iterator::filter_map Transformă și filtrează: păstrează valorile din Some, sare peste None.
std::iter::Iterator
Iterator::flat_map Aplică o funcție care dă o colecție și lipește rezultatele într-un singur șir.
std::iter::Iterator
Iterator::flatten Turtește un iterator de colecții (sau de Option) într-un singur șir de valori.
std::iter::Iterator
Iterator::enumerate Produce perechi (index, element), cu indexul pornind de la 0.
std::iter::Iterator
Iterator::zip Parcurge două șiruri în paralel și produce perechi; se oprește la cel mai scurt.
std::iter::Iterator
Iterator::chain Lipește doi iteratori: întâi elementele primului, apoi ale celui de-al doilea.
std::iter::Iterator
Iterator::rev Parcurge elementele în ordine inversă.
std::iter::Iterator
Iterator::take Produce cel mult primele n elemente.
std::iter::Iterator
Iterator::skip Sare peste primele n elemente.
std::iter::Iterator
Iterator::take_while Produce elemente cât timp condiția este adevărată, apoi se oprește.
std::iter::Iterator
Iterator::skip_while Sare peste elemente cât timp condiția este adevărată, apoi le dă pe toate.
std::iter::Iterator
Iterator::step_by Produce primul element și apoi fiecare al n-lea.
std::iter::Iterator
Iterator::peekable Face iteratorul Peekable, ca să poți vedea următorul element fără să-l consumi.
std::iter::Iterator
Iterator::fold Combină toate elementele într-o valoare, pornind de la o valoare inițială.
std::iter::Iterator
Iterator::reduce Combină elementele folosind primul ca valoare inițială; None pentru gol.
std::iter::Iterator
Iterator::sum Suma elementelor (tipul rezultatului trebuie precizat).
std::iter::Iterator
Iterator::product Produsul elementelor.
std::iter::Iterator
Iterator::count Numărul de elemente, consumând iteratorul.
std::iter::Iterator
Iterator::min Cel mai mic element, ca Option.
std::iter::Iterator
Iterator::max Cel mai mare element, ca Option.
std::iter::Iterator
Iterator::min_by_key Elementul cu cea mai mică cheie calculată.
std::iter::Iterator
Iterator::max_by_key Elementul cu cea mai mare cheie calculată.
std::iter::Iterator
Iterator::min_by Elementul minim după o funcție de comparare (de exemplu pentru f64).
std::iter::Iterator
Iterator::max_by Elementul maxim după o funcție de comparare.
std::iter::Iterator
Iterator::collect Adună elementele într-o colecție: Vec, String, HashMap, Result<Vec<_>, _>.
std::iter::Iterator
Iterator::for_each Apelează o funcție pentru fiecare element (ca o buclă for).
std::iter::Iterator
Iterator::any Spune dacă măcar un element îndeplinește condiția.
std::iter::Iterator
Iterator::all Spune dacă toate elementele îndeplinesc condiția.
std::iter::Iterator
Iterator::find Primul element care îndeplinește condiția, ca Option.
std::iter::Iterator
Iterator::find_map Primul rezultat Some al unei funcții aplicate pe elemente.
std::iter::Iterator
Iterator::position Poziția primului element care îndeplinește condiția, ca Option.
std::iter::Iterator
Iterator::last Ultimul element, ca Option.
std::iter::Iterator
Iterator::nth Elementul de pe poziția n (de la 0), consumându-le pe cele dinainte.
std::iter::Iterator
Iterator::partition Împarte elementele în două colecții, după o condiție.
std::iter::Iterator
Iterator::inspect Se uită la fiecare element care trece prin lanț, fără să-l schimbe (depanare).
std::iter::Iterator
Iterator::cloned Transformă &T în T prin clonare.
std::iter::Iterator
Iterator::copied Transformă &T în T prin copiere (pentru tipuri Copy).
std::iter::Iterator
Iterator::cycle Repetă la nesfârșit elementele iteratorului.
std::iter::Iterator
Iterator::scan Ține o stare și produce o valoare după fiecare element (de exemplu total cumulat).
std::iter::Iterator
Iterator::map_while Transformă elementele cât timp funcția dă Some; se oprește la primul None.
std::iter::Iterator
Iterator::unzip Desparte un iterator de perechi în două colecții.
std::iter::Iterator
Iterator::by_ref Împrumută iteratorul, ca să poată fi folosit în continuare după un adaptor.
std::iter::Iterator
Iterator::try_fold Ca fold, dar se oprește la primul None sau Err.
std::iter::Iterator
Iterator::is_sorted Spune dacă elementele sunt în ordine crescătoare.
std::iter::Iterator
IntoIterator Trait-ul valorilor care pot fi parcurse cu for; dă un iterator cu into_iter().
std::iter::IntoIterator
FromIterator Trait-ul tipurilor care pot fi construite dintr-un iterator; folosit de collect().
std::iter::FromIterator
DoubleEndedIterator Iterator care poate da elemente și de la coadă (next_back), necesar pentru rev().
std::iter::DoubleEndedIterator
iter::repeat Iterator infinit care repetă aceeași valoare.
std::iter::repeat
iter::once Iterator cu un singur element.
std::iter::once
iter::from_fn Iterator construit dintr-un closure care dă Some(valoare) sau None.
std::iter::from_fn
iter::successors Iterator în care fiecare element se calculează din cel dinainte.
std::iter::successors
iter::zip Funcția liberă zip(a, b): parcurge două șiruri în paralel, ca perechi.
std::iter::zip
iter::empty Iterator fără niciun element.
std::iter::empty
Peekable Iterator care permite vederea următorului element fără consumare.
std::iter::Peekable
Peekable::peek Arată următorul element, fără să-l scoată din iterator.
std::iter::Peekable
Fn Trait-ul closure-urilor care doar citesc ce au capturat; pot fi apelate oricât.
std::ops::Fn
FnMut Trait-ul closure-urilor care modifică variabilele capturate.
std::ops::FnMut
FnOnce Trait-ul closure-urilor care consumă ce au capturat; pot fi apelate o singură dată.
std::ops::FnOnce
Range Intervalul a..b (fără b): iterator de numere, folosit în for și la tăierea slice-urilor.
std::ops::Range

Option, Result și tratarea erorilor (47)

Funcție Ce face
Option Valoare care poate lipsi: Some(x) sau None, în locul lui null.
std::option::Option
Option::is_some true dacă opțiunea conține o valoare (Some).
std::option::Option
Option::is_none true dacă opțiunea este goală (None).
std::option::Option
Option::unwrap Scoate valoarea din Some; pentru None programul intră în panică.
std::option::Option
Option::expect Ca unwrap, dar la None panica afișează mesajul tău.
std::option::Option
Option::unwrap_or Valoarea din Some sau, pentru None, valoarea de rezervă dată.
std::option::Option
Option::unwrap_or_else Valoarea din Some sau rezultatul unei funcții, apelată doar pentru None.
std::option::Option
Option::unwrap_or_default Valoarea din Some sau valoarea implicită a tipului (0, „”, vector gol).
std::option::Option
Option::map Transformă valoarea din Some cu o funcție; None rămâne None.
std::option::Option
Option::and_then Înlănțuie un pas care returnează tot Option; primul None oprește lanțul.
std::option::Option
Option::or Opțiunea însăși dacă este Some, altfel alternativa dată.
std::option::Option
Option::or_else Opțiunea însăși dacă este Some, altfel alternativa calculată de o funcție.
std::option::Option
Option::ok_or Transformă Option în Result: None devine Err(eroarea dată).
std::option::Option
Option::ok_or_else Ca ok_or, dar eroarea este construită de o funcție, doar la nevoie.
std::option::Option
Option::filter Păstrează Some(x) doar dacă x respectă condiția, altfel dă None.
std::option::Option
Option::take Scoate valoarea din opțiune și lasă None în loc.
std::option::Option
Option::replace Pune o valoare nouă în opțiune și returnează valoarea veche.
std::option::Option
Option::as_ref Din &Option<T> face Option<&T>, ca să folosești valoarea fără s-o muți.
std::option::Option
Option::as_mut Din &mut Option<T> face Option<&mut T>, pentru modificare pe loc.
std::option::Option
Option::is_some_and true dacă este Some și valoarea respectă condiția dată.
std::option::Option
Option::zip Combină două opțiuni în Some((a, b)), doar dacă ambele sunt Some.
std::option::Option
Option::copied Din Option<&T> face Option<T>, copiind valoarea (pentru tipuri Copy).
std::option::Option
Option::get_or_insert_with Pune o valoare calculată dacă opțiunea e None și dă &mut la valoare.
std::option::Option
Option::iter Iterator cu un element (Some) sau niciunul (None).
std::option::Option
Result Rezultatul unei operații care poate eșua: Ok(valoare) sau Err(eroare).
std::result::Result
Result::is_ok true dacă rezultatul este Ok.
std::result::Result
Result::is_err true dacă rezultatul este Err.
std::result::Result
Result::unwrap Scoate valoarea din Ok; pentru Err programul intră în panică.
std::result::Result
Result::expect Ca unwrap, dar la Err panica afișează mesajul tău și eroarea.
std::result::Result
Result::unwrap_or Valoarea din Ok sau, la eroare, valoarea de rezervă dată.
std::result::Result
Result::unwrap_or_else Valoarea din Ok sau rezultatul unei funcții care primește eroarea.
std::result::Result
Result::unwrap_or_default Valoarea din Ok sau valoarea implicită a tipului.
std::result::Result
Result::map Transformă valoarea din Ok; eroarea trece neschimbată.
std::result::Result
Result::map_err Transformă eroarea din Err; valoarea din Ok trece neschimbată.
std::result::Result
Result::and_then Înlănțuie un pas care poate eșua; prima eroare oprește lanțul.
std::result::Result
Result::or_else La eroare, încearcă o recuperare care returnează alt Result.
std::result::Result
Result::ok Din Result face Option: Ok(x) devine Some(x), eroarea se pierde.
std::result::Result
Result::err Din Result face Option cu eroarea: Err(e) devine Some(e).
std::result::Result
Result::is_ok_and true dacă este Ok și valoarea respectă condiția dată.
std::result::Result
Result::unwrap_err Scoate eroarea din Err; pentru Ok intră în panică (util în teste).
std::result::Result
Result::iter Iterator cu valoarea din Ok sau gol pentru Err.
std::result::Result
Error Trait-ul comun al erorilor: Debug + Display, opțional o cauză (source).
std::error::Error
Error::source Eroarea care a cauzat eroarea curentă, pentru afișarea lanțului de cauze.
std::error::Error
panic::catch_unwind Rulează o funcție și prinde panica ei ca Err, fără să oprească programul.
std::panic::catch_unwind
process::exit Oprește imediat programul cu un cod de ieșire (0 = succes).
std::process::exit
ParseIntError Eroarea de la transformarea textului în întreg; kind() spune motivul.
std::num::ParseIntError
Infallible Tip de eroare fără valori, pentru operații care nu pot eșua.
std::convert::Infallible

Trait-uri standard (33)

Funcție Ce face
Clone Copiere explicită cu .clone(); se obține cu #[derive(Clone)] sau implementare manuală.
std::clone::Clone
Clone::clone Returnează o copie completă și independentă a valorii.
std::clone::Clone
Copy Marker pentru tipurile copiate automat la atribuire, în loc să fie mutate.
std::marker::Copy
fmt::Debug Afișare de depanare cu {:?} și {:#?}; de obicei #[derive(Debug)].
std::fmt::Debug
fmt::Display Afișare pentru utilizator cu {}; se implementează manual și aduce to_string().
std::fmt::Display
Default Valoarea implicită a unui tip; #[derive(Default)] sau implementare manuală.
std::default::Default
Default::default Creează valoarea implicită: 0, text gol, None, vector gol.
std::default::Default
PartialEq Operatorii == și !=; derive compară toate câmpurile.
std::cmp::PartialEq
Eq Marker pentru egalitate completă; cerut de chei în HashMap și de Ord.
std::cmp::Eq
PartialOrd Operatorii <, >, <=, >=; partial_cmp poate returna None (NaN).
std::cmp::PartialOrd
Ord Ordonare totală; necesară pentru sort(), BTreeMap și max().
std::cmp::Ord
Ord::cmp Compară două valori și returnează Ordering (Less, Equal, Greater).
std::cmp::Ord
Ord::max Cea mai mare dintre două valori; la egalitate, a doua.
std::cmp::Ord
Ord::min Cea mai mică dintre două valori; la egalitate, prima.
std::cmp::Ord
Ord::clamp Limitează o valoare la intervalul [min, max].
std::cmp::Ord
Ordering Rezultatul unei comparații: Less, Equal sau Greater; then, reverse.
std::cmp::Ordering
Hash Calculează hash-ul unei valori; necesar pentru chei în HashMap și HashSet.
std::hash::Hash
From Conversie care nu poate eșua: Tinta::from(x); aduce automat into().
std::convert::From
Into Conversie în tipul cerut de context: x.into(); vine automat din From.
std::convert::Into
TryFrom Conversie care poate eșua și returnează Result: u8::try_from(300) dă Err.
std::convert::TryFrom
TryInto x.try_into(): perechea lui TryFrom, cu tipul țintă dat de context.
std::convert::TryInto
AsRef Conversie ieftină în referință; funcții care acceptă String, &str, PathBuf.
std::convert::AsRef
Deref Operatorul * și conversia automată &String -> &str, &Box<T> -> &T.
std::ops::Deref
Drop Cod rulat automat când valoarea iese din domeniu (destructor).
std::ops::Drop
FromStr Face un tip citibil din text, astfel încât „…”.parse::<Tip>() să meargă.
std::str::FromStr
ToString Metoda to_string(), automată pentru orice tip cu Display.
std::string::ToString
Add Operatorul + pentru tipurile tale (type Output, fn add).
std::ops::Add
Index Operatorul container[i] pentru tipurile tale; IndexMut pentru scriere.
std::ops::Index
Send Marker automat: valoarea poate fi mutată în alt fir de execuție.
std::marker::Send
Sync Marker automat: &T poate fi folosit din mai multe fire deodată.
std::marker::Sync
Sized Marker pentru tipuri cu dimensiune cunoscută; ?Sized acceptă str și dyn Trait.
std::marker::Sized
Cow Clone on write: împrumut sau valoare deținută; copiază doar la nevoie.
std::borrow::Cow
Any Aflarea tipului concret la rulare cu downcast_ref::<T>() pe &dyn Any.
std::any::Any

Memorie, pointeri inteligenți și concurență (56)

Funcție Ce face
Box Pointer care deține o valoare pusă în heap; pentru tipuri recursive și Box<dyn Trait>.
std::boxed::Box
Box::new Mută o valoare în heap și returnează box-ul care o deține.
std::boxed::Box
Box::leak Renunță la box fără să elibereze memoria și dă o referință &’static.
std::boxed::Box
Rc Pointer cu numărarea referințelor: mai mulți proprietari, într-un singur fir.
std::rc::Rc
Rc::new Pune o valoare într-un Rc, cu contorul de proprietari 1.
std::rc::Rc
Rc::clone Încă un proprietar pentru aceeași valoare; mărește contorul, nu copiază.
std::rc::Rc
Rc::strong_count Câți proprietari (Rc) are valoarea acum.
std::rc::Rc
Rc::downgrade Creează o referință slabă (Weak) care nu ține valoarea în viață.
std::rc::Rc
Weak Referință slabă spre o valoare din Rc; nu împiedică eliberarea ei.
std::rc::Weak
Weak::upgrade Some(Rc) dacă valoarea mai există, None dacă a fost eliberată.
std::rc::Weak
Arc Varianta lui Rc care poate fi împărțită între fire (contor atomic).
std::sync::Arc
Arc::new Pune o valoare într-un Arc, cu contorul de proprietari 1.
std::sync::Arc
Arc::clone Încă un proprietar pentru aceeași valoare, de trimis în alt fir.
std::sync::Arc
Arc::strong_count Câți proprietari (Arc) are valoarea acum.
std::sync::Arc
RefCell Mutabilitate interioară: regulile de împrumut se verifică la rulare.
std::cell::RefCell
RefCell::new Creează un RefCell care ține valoarea dată.
std::cell::RefCell
RefCell::borrow Împrumut de citire (Ref); panică dacă există un împrumut de scriere.
std::cell::RefCell
RefCell::borrow_mut Împrumut de scriere (RefMut); panică dacă există alt împrumut.
std::cell::RefCell
Cell Mutabilitate interioară pentru valori Copy, fără împrumuturi și fără panică.
std::cell::Cell
Cell::new Creează o celulă care ține valoarea dată.
std::cell::Cell
Cell::get Returnează o copie a valorii din celulă.
std::cell::Cell
Cell::set Înlocuiește valoarea din celulă, prin referință comună.
std::cell::Cell
Mutex Protejează o valoare: un singur fir are acces la un moment dat.
std::sync::Mutex
Mutex::new Creează un mutex care protejează valoarea dată (const, poate fi static).
std::sync::Mutex
Mutex::lock Așteaptă accesul exclusiv și returnează un guard; Err dacă e otrăvit.
std::sync::Mutex
RwLock Lacăt cu mai mulți cititori simultan sau un singur scriitor.
std::sync::RwLock
RwLock::new Creează un RwLock care protejează valoarea dată.
std::sync::RwLock
RwLock::read Guard de citire; pot exista mai mulți în același timp.
std::sync::RwLock
RwLock::write Guard de scriere, exclusiv; așteaptă să plece toți cititorii.
std::sync::RwLock
OnceLock Celulă scrisă o singură dată, sigur între fire; pentru valori globale.
std::sync::OnceLock
OnceLock::new Creează un OnceLock gol (const, poate fi static).
std::sync::OnceLock
OnceLock::get_or_init Inițializează valoarea la primul apel și o returnează la fiecare apel.
std::sync::OnceLock
LazyLock Valoare (de obicei static) calculată automat la prima accesare.
std::sync::LazyLock
LazyLock::new Creează un LazyLock cu funcția care va produce valoarea.
std::sync::LazyLock
mpsc::channel Creează un canal (Sender, Receiver) pentru mesaje între fire.
std::sync::mpsc::channel
Sender Capătul de trimitere al canalului; se poate clona pentru mai mulți producători.
std::sync::mpsc::Sender
Sender::send Trimite o valoare prin canal; Err dacă receptorul a dispărut.
std::sync::mpsc::Sender
Receiver Capătul de primire al canalului; poate fi parcurs cu for.
std::sync::mpsc::Receiver
Receiver::recv Așteaptă următorul mesaj; Err când toți expeditorii au dispărut.
std::sync::mpsc::Receiver
Receiver::try_recv Ia un mesaj fără să aștepte: Ok, Err(Empty) sau Err(Disconnected).
std::sync::mpsc::Receiver
AtomicUsize usize care poate fi modificat din mai multe fire fără Mutex.
std::sync::atomic::AtomicUsize
AtomicUsize::new Creează un contor atomic cu valoarea dată (const, poate fi static).
std::sync::atomic::AtomicUsize
AtomicUsize::fetch_add Adună atomic și returnează valoarea de dinainte.
std::sync::atomic::AtomicUsize
AtomicUsize::load Citește valoarea atomică.
std::sync::atomic::AtomicUsize
AtomicUsize::store Scrie atomic o valoare nouă.
std::sync::atomic::AtomicUsize
thread::spawn Pornește un fir nou și returnează un JoinHandle.
std::thread::spawn
thread::scope Pornește fire care pot împrumuta date locale; le așteaptă automat.
std::thread::scope
thread::sleep Oprește firul curent cel puțin cât durata dată.
std::thread::sleep
JoinHandle Mânerul unui fir pornit cu spawn, prin care îl aștepți.
std::thread::JoinHandle
JoinHandle::join Așteaptă firul și dă Ok(rezultat) sau Err dacă a intrat în panică.
std::thread::JoinHandle
thread::available_parallelism Câte fire pot rula în paralel pe calculator (estimare).
std::thread::available_parallelism
mem::swap Interschimbă valorile din două locuri &mut.
std::mem::swap
mem::replace Pune o valoare nouă într-un loc &mut și o returnează pe cea veche.
std::mem::replace
mem::take Ia valoarea dintr-un loc &mut și lasă valoarea implicită în urmă.
std::mem::take
mem::drop Distruge o valoare imediat (eliberează memorie, lacăte, fișiere).
std::mem::drop
mem::size_of Câți octeți ocupă un tip în memorie (fără datele din heap).
std::mem::size_of

Fișiere, intrare/ieșire, timp și sistem (113)

Funcție Ce face
fs::read_to_string Citește tot fișierul text într-un String.
std::fs::read_to_string
fs::write Scrie conținutul într-un fișier, creându-l sau înlocuindu-l.
std::fs::write
fs::read Citește tot fișierul ca octeți (Vec<u8>).
std::fs::read
fs::create_dir_all Creează un director cu toți părinții lipsă; nu dă eroare dacă există.
std::fs::create_dir_all
fs::remove_file Șterge definitiv un fișier.
std::fs::remove_file
fs::remove_dir_all Șterge definitiv un director cu tot conținutul lui.
std::fs::remove_dir_all
fs::read_dir Iterator peste intrările unui director (ordine negarantată).
std::fs::read_dir
fs::metadata Informații despre fișier: dimensiune, tip, permisiuni, data modificării.
std::fs::metadata
fs::copy Copiază un fișier și returnează numărul de octeți copiați.
std::fs::copy
fs::rename Redenumește sau mută un fișier ori un director.
std::fs::rename
File Un fișier deschis, citit și scris prin Read și Write.
std::fs::File
File::open Deschide un fișier existent doar pentru citire.
std::fs::File
File::create Creează un fișier pentru scriere sau îl golește dacă există.
std::fs::File
File::options Începe un OpenOptions, pentru deschidere cu opțiuni alese.
std::fs::File
File::metadata Informații despre un fișier deja deschis.
std::fs::File
File::sync_all Forțează scrierea datelor și metadatelor pe disc.
std::fs::File
OpenOptions Deschiderea unui fișier cu opțiuni: append, create, create_new, truncate.
std::fs::OpenOptions
OpenOptions::new Creează un set de opțiuni gol, de completat prin metode.
std::fs::OpenOptions
OpenOptions::append Scrierile se adaugă la sfârșitul fișierului.
std::fs::OpenOptions
OpenOptions::create Creează fișierul dacă nu există.
std::fs::OpenOptions
OpenOptions::open Deschide fișierul cu opțiunile alese și returnează un File.
std::fs::OpenOptions
io::stdin Intrarea standard (tastatura sau datele trimise programului).
std::io::stdin
io::stdout Ieșirea standard ca obiect Write, cu flush și lock.
std::io::stdout
io::Stdin Tipul intrării standard, returnat de io::stdin().
std::io::Stdin
io::Stdin::read_line Citește o linie (cu \n) și o adaugă la un String.
std::io::Stdin
io::Stdin::lines Iterator peste liniile intrării standard, fără \n.
std::io::Stdin
io::BufRead Trait pentru cititori cu buffer: citire pe linii.
std::io::BufRead
io::BufRead::lines Iterator peste liniile unui cititor cu buffer.
std::io::BufRead
io::BufRead::read_line Adaugă următoarea linie la un String; 0 la sfârșit.
std::io::BufRead
io::BufReader Buffer peste un cititor: citiri rapide și metodele BufRead.
std::io::BufReader
io::BufReader::new Împachetează un cititor (de obicei un File) într-un BufReader.
std::io::BufReader
io::BufWriter Buffer peste un scriitor: strânge scrierile mici în bucăți mari.
std::io::BufWriter
io::BufWriter::new Împachetează un scriitor într-un BufWriter.
std::io::BufWriter
io::Read Trait pentru surse de octeți: fișiere, stdin, rețea.
std::io::Read
io::Read::read_to_string Citește tot ce a rămas și adaugă la un String.
std::io::Read
io::Read::read_to_end Citește toți octeții rămași și îi adaugă la un Vec<u8>.
std::io::Read
io::Write Trait pentru destinații de octeți; permite write! și writeln!.
std::io::Write
io::Write::write_all Scrie tot bufferul, repetând până termină.
std::io::Write
io::Write::flush Trimite imediat datele aflate în buffere.
std::io::Write
io::Error Eroarea operațiilor de intrare/ieșire.
std::io::Error
io::Error::new Creează un io::Error cu o categorie și un mesaj.
std::io::Error
io::Error::kind Categoria erorii (ErrorKind), pentru match.
std::io::Error
io::ErrorKind Categoriile erorilor I/O: NotFound, PermissionDenied, AlreadyExists…
std::io::ErrorKind
io::Result Alias pentru Result<T, io::Error>.
std::io::Result
env::args Argumentele din linia de comandă; primul este numele programului.
std::env::args
env::var Valoarea unei variabile de mediu sau Err dacă lipsește.
std::env::var
env::current_dir Directorul de lucru curent, față de care se rezolvă căile relative.
std::env::current_dir
env::vars Iterator peste toate variabilele de mediu (nume, valoare).
std::env::vars
Command Pregătește pornirea unui alt program (proces copil).
std::process::Command
Command::new Alege programul de pornit, căutat în PATH.
std::process::Command
Command::arg Adaugă un argument comenzii.
std::process::Command
Command::args Adaugă mai multe argumente comenzii.
std::process::Command
Command::output Rulează, așteaptă și strânge codul de ieșire, stdout și stderr.
std::process::Command
Command::status Rulează cu ieșirea direct în terminal și returnează codul de ieșire.
std::process::Command
Command::spawn Pornește procesul și returnează imediat un Child.
std::process::Command
Path Cale împrumutată din sistemul de fișiere (ca &str pentru texte).
std::path::Path
Path::new Privește un text ca pe o cale, fără să atingă discul.
std::path::Path
Path::join Lipește o cale la alta cu separatorul corect și dă un PathBuf.
std::path::Path
Path::exists true dacă la cale există un fișier sau un director.
std::path::Path
Path::extension Extensia fișierului, fără punct (Option).
std::path::Path
Path::file_name Ultima componentă a căii, fără directoare (Option).
std::path::Path
Path::parent Calea fără ultima componentă sau None pentru rădăcină.
std::path::Path
Path::is_file true dacă la cale există un fișier.
std::path::Path
Path::is_dir true dacă la cale există un director.
std::path::Path
PathBuf Cale deținută și modificabilă (ca String pentru texte).
std::path::PathBuf
PathBuf::new Creează o cale goală.
std::path::PathBuf
PathBuf::push Adaugă o componentă la sfârșitul căii.
std::path::PathBuf
PathBuf::set_extension Înlocuiește sau elimină extensia fișierului.
std::path::PathBuf
Instant Moment de timp dintr-un ceas monoton, pentru măsurarea duratelor.
std::time::Instant
Instant::now Momentul de acum, pe ceasul monoton.
std::time::Instant
Instant::elapsed Cât timp a trecut de la acel moment până acum.
std::time::Instant
Instant::duration_since Durata dintre două momente (zero dacă ordinea e inversă).
std::time::Instant
Duration O durată de timp, cu precizie de nanosecundă.
std::time::Duration
Duration::from_secs Creează o durată dintr-un număr de secunde.
std::time::Duration
Duration::from_millis Creează o durată dintr-un număr de milisecunde.
std::time::Duration
Duration::as_secs Secundele întregi din durată (zecimalele sunt tăiate).
std::time::Duration
Duration::as_millis Toată durata în milisecunde, ca u128.
std::time::Duration
Duration::as_secs_f64 Durata în secunde, ca număr zecimal.
std::time::Duration
SystemTime Ora sistemului (ceasul din calendar), poate sări înapoi.
std::time::SystemTime
SystemTime::now Ora sistemului de acum.
std::time::SystemTime
SystemTime::duration_since Durata față de un moment mai vechi; Err dacă ordinea e inversă.
std::time::SystemTime
time::UNIX_EPOCH 1 ianuarie 1970, 00:00:00 UTC, reperul timestamp-urilor Unix.
std::time::UNIX_EPOCH
i32 Întreg cu semn pe 32 de biți, tipul implicit pentru numere întregi.
tip primitiv i32
i32::pow Ridică numărul la o putere întreagă nenegativă (u32).
tip primitiv i32
i32::abs Valoarea absolută; panică în debug pentru i32::MIN.
tip primitiv i32
i32::checked_add Adunare verificată: Some(sumă) sau None la depășire.
tip primitiv i32
i32::saturating_sub Scădere care se oprește la limita tipului.
tip primitiv i32
i32::wrapping_add Adunare cu întoarcere: după MAX urmează MIN.
tip primitiv i32
i32::overflowing_add Adunare cu întoarcere și un bool care spune dacă a depășit.
tip primitiv i32
i32::from_str_radix Citește un text ca număr într-o bază aleasă (2-36).
tip primitiv i32
i32::signum -1, 0 sau 1, după semnul numărului.
tip primitiv i32
i32::rem_euclid Restul împărțirii, mereu nenegativ (spre deosebire de %).
tip primitiv i32
i32::isqrt Rădăcina pătrată întreagă, calculată exact.
tip primitiv i32
i32::count_ones Numărul de biți de 1 din reprezentarea binară.
tip primitiv i32
f64 Număr cu zecimale în virgulă mobilă pe 64 de biți.
tip primitiv f64
f64::sqrt Rădăcina pătrată; NaN pentru numere negative.
tip primitiv f64
f64::powi Putere cu exponent întreg (i32), poate fi negativ.
tip primitiv f64
f64::powf Putere cu exponent zecimal (f64).
tip primitiv f64
f64::round Rotunjește la cel mai apropiat întreg (jumătățile departe de zero).
tip primitiv f64
f64::floor Rotunjește în jos, spre minus infinit.
tip primitiv f64
f64::ceil Rotunjește în sus, spre plus infinit.
tip primitiv f64
f64::trunc Taie zecimalele (rotunjire spre zero).
tip primitiv f64
f64::abs Valoarea absolută a unui număr zecimal.
tip primitiv f64
f64::min Cel mai mic dintre două numere; un NaN este ignorat.
tip primitiv f64
f64::max Cel mai mare dintre două numere; un NaN este ignorat.
tip primitiv f64
f64::is_nan true dacă valoarea este NaN (singurul mod sigur de a-l recunoaște).
tip primitiv f64
f64::to_radians Transformă grade în radiani.
tip primitiv f64
f64::sin Sinusul unui unghi dat în radiani.
tip primitiv f64
f64::mul_add (x * a) + b cu o singură rotunjire, mai precis.
tip primitiv f64
f64::clamp Limitează valoarea la intervalul [min, max].
tip primitiv f64
u8 Întreg fără semn pe 8 biți (0-255): un octet.
tip primitiv u8
u8::is_ascii_digit true dacă octetul este o cifră ASCII (b’0′..=b’9′).
tip primitiv u8
u8::to_ascii_uppercase Literă ASCII mică devine mare; alți octeți rămân neschimbați.
tip primitiv u8