È stato pubblicato il rilascio del linguaggio di programmazione Rust 1.82, originariamente sviluppato da Mozilla, ma ora sotto la gestione della Rust Foundation, un'organizzazione indipendente e no-profit. Il linguaggio si concentra sulla gestione sicura della memoria e fornisce strumenti per raggiungere un alto livello di parallelismo nell'esecuzione delle attività, senza fare uso di garbage collector e runtime (il runtime è limitato all'inizializzazione di base e al supporto della libreria standard).
I metodi di gestione della memoria in Rust liberano gli sviluppatori dagli errori nella manipolazione dei puntatori e li proteggono da problematiche derivanti dal lavoro a basso livello con la memoria, come l'accesso a zone di memoria dopo la loro liberazione, la dereferenziazione di puntatori nulli, il superamento dei limiti del buffer, e così via. Per la distribuzione delle librerie, la gestione della compilazione e delle dipendenze, si è sviluppato un gestore di pacchetti chiamato Cargo. Le librerie sono ospitate nel repository crates.io.
La gestione sicura della memoria in Rust è garantita durante la compilazione tramite il controllo dei riferimenti, il tracciamento della proprietà degli oggetti, la gestione della durata degli oggetti (scope) e la valutazione della correttezza dell'accesso alla memoria durante l'esecuzione del codice. Rust offre anche strumenti per proteggere da overflow interi, richiede l'inizializzazione obbligatoria dei valori delle variabili prima dell'uso, gestisce meglio gli errori nella libreria standard, applica il concetto di riferimenti e variabili immutabili per impostazione predefinita e offre una forte tipizzazione statica per ridurre al minimo gli errori logici.
Novità principali:
- È stata aggiunta al gestore di pacchetti cargo il comando "info" per visualizzare le informazioni sui pacchetti nel repository.
- È stato aggiunto il supporto per la sintassi "use" in "impl Trait", che definisce informazioni sui tipi nascosti. Ad esempio, "impl Trait + use" indica che nel tipo nascosto è permesso utilizzare solo i parametri "x" e "T".
- È stata proposta una sintassi separata per la creazione di puntatori raw, che sostituisce i macro precedentemente utilizzati: il macro "addr_of!(expr)" è stato sostituito dall'operatore "&raw const expr", e il macro "addr_of_mut!(expr)" è stato sostituito dall'operatore "&raw mut expr". struct Packed { not_aligned_field: i32, } fn main() { let p = Packed { not_aligned_field: 1_82 }; // Vecchio modo di creare un puntatore raw let ptr = std::ptr::addr_of!(p.not_aligned_field); // Nuovo modo di creare un puntatore raw let ptr = &raw const p.not_aligned_field; let val = unsafe { ptr.read_unaligned() }; }
- È stata fornita la possibilità di definire funzioni e costanti sicure (safe) con vita 'static' all'interno di blocchi extern contrassegnati come "unsafe" (precedentemente tutti gli elementi in "unsafe extern" potevano avere solo il contrassegno "unsafe"): unsafe extern { pub safe static TAU: f64; pub safe fn sqrt(x: f64) -> f64; pub unsafe fn strlen(p: *const u8) -> usize; }
- Gli attributi no_mangle, link_section ed export_name, che possono portare a comportamenti indefiniti, sono ora considerati insicuri e richiedono una chiara marcatura con il contrassegno "unsafe", ad esempio: #[unsafe(no_mangle)] pub fn my_global_function() { }
- Nella corrispondenza dei modelli, è ora consentito ignorare tipi vuoti, come "enum Void {}" o strutture con un campo visibilmente vuoto. use std::convert::Infallible; pub fn unwrap_without_panic(x: Result) -> T { let Ok(x) = x; // 'Err' può essere ignorato x }
- Il comportamento nel trattare valori non numerici NaN (0.0/0.0) è stato standardizzato per i tipi di numeri in virgola mobile (f32 e f64), e ora è consentito l'uso di operazioni in virgola mobile in const fn.
- Nelle inserzioni di assembly è ora possibile utilizzare operandi contrassegnati come "const" per utilizzare direttamente valori numerici interi senza salvarli preventivamente in registri. const MSG: &str = "Hello, world!\n"; unsafe { core::arch::asm!( "mov rdx, {LEN} // verrà generata l'istruzione 'mov rdx, 14'", LEN = const MSG.len(), … ); }
- È consentito indirizzare espressioni con il contrassegno "static" in un contesto sicuro senza definire un blocco unsafe (gli operatori "&raw mut" e "&raw const" non influenzano il valore dell'operando e creano solo un puntatore a esso): static mut STATIC_MUT: Type = Type::new(); extern "C" { static EXTERN_STATIC: Type; } fn main() { let static_mut_ptr = &raw mut STATIC_MUT; let extern_static_ptr = &raw const EXTERN_STATIC; }
- Una nuova serie di API è stata traslata nella categoria stabile, stabilizzando i metodi e le implementazioni dei tipi:
- std::thread::Builder::spawn_unchecked
- std::str::CharIndices::offset
- std::option::Option::is_none_or
- [T]::is_sorted
- [T]::is_sorted_by
- [T]::is_sorted_by_key
- Iterator::is_sorted
- Iterator::is_sorted_by
- Iterator::is_sorted_by_key
- std::future::Ready::into_inner
- std::iter::repeat_n
- impl DoubleEndedIterator for Take
Fonte: opennet.ru
