È stato pubblicato il rilascio del linguaggio di programmazione generale Rust 1.82, originariamente sviluppato da Mozilla, ora mantenuto da un'organizzazione non profit indipendente chiamata Rust Foundation. Il linguaggio si concentra sulla sicurezza della gestione della memoria e fornisce strumenti per ottenere un'elevata concorrenza nell'esecuzione dei compiti, senza utilizzare un garbage collector e un runtime (il runtime si limita a una base di inizializzazione e supporto per la libreria standard).
I metodi di gestione della memoria in Rust liberano gli sviluppatori dagli errori di manipolazione dei puntatori e li proteggono da problemi derivanti da operazioni a basso livello con la memoria, come l'accesso a aree di memoria dopo il loro rilascio, la dereferenziazione di puntatori nulli, l'uscita dai limiti del buffer, ecc. Per la distribuzione delle librerie, l'assicurazione della compilazione e la gestione delle dipendenze, il progetto promuove il gestore di pacchetti Cargo. È supportato un repository per l'hosting delle librerie su crates.io.
La gestione sicura della memoria in Rust è garantita durante la compilazione attraverso il controllo dei riferimenti, il tracciamento della proprietà degli oggetti, la considerazione del tempo di vita degli oggetti (ambiti di visibilità) e la valutazione della correttezza dell'accesso alla memoria durante l'esecuzione del codice. Rust fornisce anche strumenti per proteggere da overflow interi, richiede l'inizializzazione obbligatoria 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 minimizzare gli errori logici.
Novità principali:
- È stata aggiunta al gestore di pacchetti cargo il comando "info" per fornire informazioni sui pacchetti nel repository.
- È stato aggiunto il supporto per la sintassi "use" in "impl Trait", definendo informazioni sui tipi nascosti. Ad esempio, "impl Trait + use" indica che nel tipo nascosto sono consentiti 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 una vita ‘static’ all'interno di blocchi extern con il flag "unsafe" (in precedenza, tutti gli elementi in "unsafe extern" potevano avere solo il flag "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 non sicuri e richiedono un'esplicita annotazione con il flag "unsafe", ad esempio: #[unsafe(no_mangle)] pub fn my_global_function() { }
- Nella corrispondenza dei pattern è ora permesso ignorare i tipi vuoti, come "enum Void {}" o strutture con un campo visibile vuoto. use std::convert::Infallible; pub fn unwrap_without_panic(x: Result) -> T { let Ok(x) = x; // "Err" può essere ignorato x }
- Nei tipi per numeri a virgola mobile (f32 e f64) è stata standardizzata la gestione dei valori non numerici NaN (0.0/0.0), e sono inoltre consentite operazioni in virgola mobile in const fn.
- Nelle inserzioni in assembler è possibile utilizzare operandi con il flag «const» per utilizzare direttamente valori interi senza doverli prima salvare nel registro. const MSG: &str = «Hello, world!\n»; unsafe { core::arch::asm!( «mov rdx, {LEN} / sarà generata l'istruzione ‘mov rdx, 14′», LEN = const MSG.len(), … ); }
- È consentito l'indirizzamento di espressioni con il flag «static» in un contesto sicuro senza la definizione di un blocco unsafe (gli operatori «&raw mut» e «&raw const» non influenzano il valore dell'operando e creano solo un puntatore ad 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 trasformata in versioni stabili, inclusi i metodi stabilizzati e le implementazioni delle trait:
- 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
