È stato pubblicato il rilascio del linguaggio di programmazione general-purpose Rust 1.82, fondato dal progetto Mozilla, ma ora sviluppato sotto gli auspici dell'organizzazione no-profit indipendente Rust Foundation. Il linguaggio si concentra sulla sicurezza della memoria e fornisce i mezzi per ottenere un elevato parallelismo del lavoro evitando l'uso di un Garbage Collector e del runtime (il runtime è ridotto all'inizializzazione di base e alla manutenzione della libreria standard).
I metodi di gestione della memoria di Rust salvano lo sviluppatore da errori durante la manipolazione dei puntatori e proteggono dai problemi che sorgono a causa della gestione della memoria di basso livello, come l'accesso a un'area di memoria dopo che è stata liberata, la dereferenziazione di puntatori nulli, sovraccarichi del buffer, ecc. Per distribuire le librerie, fornire build e gestire le dipendenze, il progetto sviluppa il gestore di pacchetti Cargo. Il repository crates.io è supportato per l'hosting di librerie.
La sicurezza della memoria viene fornita in Rust in fase di compilazione attraverso il controllo dei riferimenti, tenendo traccia della proprietà dell'oggetto, tenendo traccia della durata dell'oggetto (scopi) e valutando la correttezza dell'accesso alla memoria durante l'esecuzione del codice. Rust fornisce anche protezione contro gli overflow di numeri 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, offre una forte tipizzazione statica per ridurre al minimo gli errori logici.
Principali innovazioni:
- Il comando "info" è stato aggiunto al gestore dei pacchetti cargo per visualizzare le informazioni su un pacchetto nel repository.
- Aggiunto il supporto per la sintassi "use<..>" in "impl Trait", che specifica informazioni sui tipi nascosti. Ad esempio, "impl Trait + use<'x, T>" specifica che solo i parametri "x" e "T" possono essere utilizzati in un tipo nascosto.
- È stata proposta una sintassi separata per la creazione di puntatori grezzi, in sostituzione delle macro utilizzate in precedenza: la macro “addr_of!(expr)” è stata sostituita dall'operatore “&raw const expr” e la macro “addr_of_mut!(expr)” è stata sostituita dall'operatore “&raw mut" expr". struct Packed { not_aligned_field: i32, } fn main() { let p = Packed { not_aligned_field: 1_82 }; // Il vecchio modo di creare un puntatore grezzo let ptr = std::ptr::addr_of!(p.not_aligned_field); // Nuovo modo per creare un puntatore grezzo let ptr = &raw const p.not_aligned_field; let val = unsafe { ptr.read_unaligned() }; }
- È possibile definire funzioni e costanti sicure con una durata 'statica' all'interno di blocchi extern con l'attributo "unsafe" (in precedenza, tutti gli elementi in un "unsafe extern" potevano avere solo l'attributo "unsafe"): unsafe extern { pub safe TAU statico: f64; pubsafe 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 esplicito flag "unsafe", ad esempio: #[unsafe(no_mangle)] pub fn my_global_function() { }
- La corrispondenza dei modelli consente di ignorare i tipi vuoti, come "enum Void {}" o strutture con un campo vuoto visibile. usa std::convert::Infallibile; pub fn unwrap_without_panic (x: risultato ) -> T { sia Ok(x) = x; // "Err" può essere saltato x }
- I tipi per i numeri in virgola mobile (f32 e f64) hanno un comportamento standardizzato durante l'elaborazione di valori NaN non numerici (0.0/0.0) e consentono anche l'uso di operazioni in virgola mobile in const fn.
- Gli inserti assembly forniscono la possibilità di utilizzare operandi con l'attributo “const” per utilizzare direttamente valori numerici interi senza prima memorizzarli in un registro. const MSG: &str = "Ciao mondo!\n"; unsafe { core::arch::asm!( “mov rdx, {LEN} // verrà generata l'istruzione 'mov rdx, 14′”, LEN = const MSG.len(), … ); }
- L'indirizzamento delle espressioni con l'attributo “static” è consentito 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 ad esso): static mut STATIC_MUT: Tipo = Tipo::new( ); extern "C" { statico EXTERN_STATIC: tipo; } fn main() { let static_mut_ptr = &raw mut STATIC_MUT; let extern_static_ptr = &raw const EXTERN_STATIC; }
- Una nuova porzione dell'API è stata spostata nella categoria stabile, inclusi i metodi e le implementazioni dei tratti sono stati stabilizzati:
- std::thread::Builder::spawn_unchecked
- std::str::CharIndices::offset
- std::opzione::Opzione::is_none_or
- [T]::è_ordinato
- [T]::è_ordinato_per
- [T]::è_ordinato_per_chiave
- Iteratore::è_ordinato
- Iteratore::è_ordinato_per
- Iteratore::is_sorted_by_key
- std::future::Ready::into_inner
- std::iter::repeat_n
- impl DoubleEndedIterator per Take
Fonte: opennet.ru
