È stato pubblicato il rilascio del linguaggio di programmazione general-purpose Rust 1.73, originariamente sviluppato da Mozilla e oggi gestito da una fondazione indipendente e no-profit, la Rust Foundation. Il linguaggio è focalizzato sulla gestione sicura della memoria e offre strumenti per raggiungere un alto livello di parallelismo nell'esecuzione dei compiti, il tutto senza l'uso di un garbage collector e con un runtime ridotto 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 rielaborata la formattazione dei messaggi restituiti dal gestore di arresto anomalo predefinito (panic). Il testo specificato nel macro «panic!» viene ora visualizzato su una riga separata senza virgolette, migliorando la leggibilità del messaggio ed evitando confusione in caso di virgolette annidate o di suddivisione su più righe. fn main() { let file = «ferris.txt»; panic!(«oh no! {file:?} non trovato!»); } Prima thread ‘main’ panicked at ‘oh no! «ferris.txt» non trovato!’, src/main.rs:3:5 Diventato thread ‘main’ panicked at src/main.rs:3:5: oh no! «ferris.txt» non trovato!
È stata anche rielaborata la visualizzazione dei messaggi mostrati quando vengono attivati i macro «assert_eq» e «assert_ne». fn main() { assert_eq!(«🦀», «🐟», «ferris non è un pesce»); } Prima thread ‘main’ panicked at ‘assertion failed: `(left == right)` left: `»🦀»`, right: `»🐟»`: ferris non è un pesce’, src/main.rs:2:5 Diventato thread ‘main’ panicked at src/main.rs:2:5: assertion `left == right` fallita: ferris non è un pesce left: «🦀» right: «🐟»
- In conformità con il RFC 3184, è stata aggiunta la possibilità di manipolare direttamente le chiavi locali per il thread (thread_local) nello storage LocalKey<Cell<T>> e LocalKey<RefCell<T>> utilizzando i metodi get(), set(), take() e replace(), invece di utilizzare la chiusura «with(|inner| …)», riducendo la necessità di eseguire codice aggiuntivo di inizializzazione per i valori predefiniti specificati per i nuovi thread tramite il macro «thread_local!». thread_local! { static THINGS: Cell<Vec<i32>> = Cell::new(Vec::new()); } fn f() { // prima THINGS.with(|i| i.set(vec![1, 2, 3])); // diventato THINGS.set(vec![1, 2, 3]); // … // prima let v = THINGS.with(|i| i.take()); // diventato let v: Vec<i32> = THINGS.take(); }
- Una nuova serie di API è stata traslata nella categoria stabile, stabilizzando i metodi e le implementazioni dei tipi:
- Unsigned {integer}::div_ceil
- Unsigned {integer}::next_multiple_of
- Unsigned {integer}::checked_next_multiple_of
- std::ffi::FromBytesUntilNulError
- std::os::unix::fs::chown
- std::os::unix::fs::fchown
- std::os::unix::fs::lfchown
- LocalKey::<Cell<T>>::get
- LocalKey::<Cell<T>>::set
- LocalKey::<Cell<T>>::take
- LocalKey::<Cell<T>>::replace
- LocalKey::<RefCell<T>>::with_borrow
- LocalKey::<RefCell<T>>::with_borrow_mut
- LocalKey::<RefCell<T>>::set
- LocalKey::<RefCell<T>>::take
- LocalKey::<RefCell<T>>::replace
- L'indicatore «const», che determina la possibilità di utilizzo in qualsiasi contesto al posto delle costanti, è stato applicato nelle funzioni:
- rc::Weak::new
- sync::Weak::new
- NonNull::as_ref
- Nel compilatore è stata implementata la registrazione delle informazioni sulla versione nella sezione «.comment» in modo simile a GCC e Clang.
- È stato realizzato un terzo livello di supporto per le piattaforme aarch64-unknown-teeos, csky-unknown-linux-gnuabiv2, riscv64-linux-android, riscv64gc-unknown-hermit, x86_64-unikraft-linux-musl e x86_64-unknown-linux-ohos. Il terzo livello prevede un supporto base, ma senza test automatizzati, pubblicazione di build ufficiali e verifica della possibilità di compilare il codice.
- È stato implementato un secondo livello di supporto per la piattaforma target wasm32-wasi-preview1-threads. Il secondo livello di supporto garantisce la possibilità di compilazione.
Fonte: opennet.ru
