È stato pubblicato il rilascio del linguaggio di programmazione general-purpose Rust 1.59, 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:
- È possibile utilizzare inserti in linguaggio assembly, richiesti in applicazioni che necessitano di controllare l'esecuzione a basso livello o di essere in grado di utilizzare istruzioni macchina specializzate. Gli inserti di assieme vengono aggiunti utilizzando le macro "asm!" e "global_asm!" utilizzando una sintassi di formattazione delle stringhe per denominare i registri simile a quella utilizzata per le sostituzioni di stringhe in Rust. Il compilatore supporta le istruzioni di assemblaggio per le architetture x86, x86-64, ARM, AArch64 e RISC-V. Esempio di inserimento: use std::arch::asm; // Moltiplica x per 6 utilizzando turni e addizioni let mut x: u64 = 4; unsafe { asm!( "mov {tmp}, {x}", "shl {tmp}, 1", "shl {x}, 2", "add {x}, {tmp}", x = inout(reg ) x, tmp = out(reg) _, ); } assert_eq!(x, 4 * 6);
- Aggiunto supporto per assegnazioni destrutturate (parallele), in cui diversi tratti, sezioni o strutture sono specificati sul lato sinistro dell'espressione. Ad esempio: sia (a, b, c, d, e); (a, b) = (1, 2); [c, .., d, _] = [1, 2, 3, 4, 5]; Struct { e, .. } = Struct { e: 5, f: 3 }; assert_eq!([1, 2, 1, 4, 5], [a, b, c, d, e]);
- È stata fornita la possibilità di specificare valori predefiniti per i generici const: struct ArrayStorage { arr: [T; N], } impl ArrayStorage { fn nuovo(a: T, b: T) -> ArrayStorage { ArrayStorage { arr: [a, b], } } }
- Il gestore dei pacchetti Cargo fornisce avvisi sull'uso di strutture non valide nelle dipendenze che vengono elaborate a causa di errori nel compilatore (ad esempio, a causa di un errore, i campi delle strutture compresse potevano essere presi in prestito in blocchi sicuri). Tali costrutti non saranno più supportati nelle future versioni di Rust.
- Cargo e rusticc hanno la capacità incorporata di generare file eseguibili privati dei dati di debug (strip = "debuginfo") e dei simboli (strip = "symbols"), senza la necessità di chiamare un'utilità separata. L'impostazione della pulizia è implementata tramite il parametro “strip” in Cargo.toml: [profile.release] strip = “debuginfo”, “symbols”
- La compilazione incrementale è disabilitata per impostazione predefinita. Si dice che il motivo sia una soluzione temporanea per un bug nel compilatore che porta a arresti anomali ed errori di deserializzazione. Una correzione del bug è già stata preparata e sarà inclusa nella prossima versione. Per restituire la compilazione incrementale, è possibile utilizzare la variabile di ambiente RUSTC_FORCE_INCREMENTAL=1.
- Una nuova porzione dell'API è stata spostata nella categoria stabile, inclusi i metodi e le implementazioni dei tratti sono stati stabilizzati:
- std::thread::available_parallelismo
- Risultato::copiato
- Risultato::clonato
- arco::asm!
- arch::global_asm!
- ops::ControlFlow::is_break
- ops::ControlFlow::is_continue
- ProvaDa per u8
- char::TryFromCharError (Clone, Debug, Visualizzazione, PartialEq, Copia, Eq, Errore)
- iter::zip
- NonZeroU8::is_power_of_two
- NonZeroU16::is_power_of_two
- NonZeroU32::is_power_of_two
- NonZeroU64::is_power_of_two
- NonZeroU128::is_power_of_two
- DoubleEndedIterator per la struttura ToLowercase
- DoubleEndedIterator per la struttura ToUppercase
- ProvaDa<&mut [T]> per [T; N]
- UnwindSafe per la struttura Once
- RefUnwindSafe per una volta
- funzioni di supporto neon armv8 integrate nel compilatore per aarch64
- L'attributo "const", che determina la possibilità di utilizzarlo in qualsiasi contesto al posto delle costanti, viene utilizzato nelle funzioni:
- mem::ForseUninit::as_ptr
- mem::ForseUninit::assume_init
- mem::ForseUninit::assume_init_ref
- ffi::CStr::from_bytes_with_nul_unchecked
Fonte: opennet.ru