È stato pubblicato il rilascio del linguaggio di programmazione Rust 1.51, originariamente sviluppato da Mozilla, ma ora sotto la gestione della Rust Foundation, un'organizzazione indipendente e senza scopo di lucro. Il linguaggio si concentra sulla gestione sicura della memoria, offre gestione automatica della memoria e fornisce strumenti per raggiungere un elevato parallelismo nell'esecuzione delle attività, il tutto senza ricorrere a un garbage collector e a un runtime (il runtime si limita all'inizializzazione di base e alla manutenzione della libreria standard).
La gestione automatica della memoria in Rust solleva gli sviluppatori dagli errori nella manipolazione dei puntatori e protegge da problemi derivanti dal lavoro a basso livello con la memoria, come l'accesso a aree di memoria già liberate, la dereferenziazione di puntatori nulli, il superamento dei limiti di un buffer, ecc. Per la distribuzione delle librerie, la costruzione e la gestione delle dipendenze, è in fase di sviluppo il gestore di pacchetti Cargo. Per l'hosting delle librerie, è supportato il repository crates.io.
Novità principali:
- La funzionalità relativa all'uso dei generici costanti ("const generics") ha ricevuto lo stato di prodotto minimo vitalmente sostenibile (MVP), aprendo la strada a un'ampia applicazione. I generici costanti consentono di generalizzare i tipi per valori costanti, ovvero di utilizzare argomenti generici vincolati a un intervallo di valori costanti, piuttosto che a tipi e a tempi di vita. Questa possibilità offre l'opportunità di utilizzare tipi parametrici agli interi e di astrarsi nella creazione di trait per array di qualsiasi dimensione, senza la necessità di creare un tipo separato per ogni intervallo di valori consentiti, garantendo così l'assenza di superamenti del limite consentito.
A partire dall'attuale versione, per le matrici con tipo «[T; N]» (tipo T e dimensione N) è possibile astrarre tipo e dimensione utilizzando valori con qualsiasi tipo intero, booleano e carattere (i tipi struct ed enum non sono ancora supportati). I generici costanti semplificano notevolmente lo sviluppo delle librerie; ad esempio, per utilizzare una matrice non legata a un tipo e a una dimensione specifica, si può specificare: struct Array { // ^^^^^^^^^^^^^^^^^^^ definizione del generico costante list: [T; LENGTH] // ^^^^^^ il suo utilizzo }
Nell'utilizzo effettivo con questa definizione «Array», il compilatore genererà una versione monomorfica di Array: struct Array { list: [u8; 32] }
- Stabilito l'API std::array::IntoIter basato su generici costanti, che consente di creare iteratori per valore per qualsiasi matrice: fn main() { let array = [1, 2, 3, 4, 5]; // In precedenza, per iterare il valore bisognava chiamare il metodo .iter() for item in array.iter().copied() { println!(«{}», item); } // Ora è possibile specificare for item in std::array::IntoIter::new(array) { println!(«{}», item); } }
- Nel package manager cargo è stata implementata la supporto per il nuovo campo resolver in Cargo.toml, che consente di abilitare una seconda versione del risolutore delle funzionalità (feature resolver). La nuova versione del risolutore evita la fusione delle funzionalità delle dipendenze elencate nella sezione «[features]», dove non è appropriato, ad esempio, quando si collega una dipendenza che richiede una certa funzionalità standard negli script di build e nei macro, ma si utilizza una funzionalità non standard nel file eseguibile finale.
Fino ad ora, le funzionalità del pacchetto menzionato più volte nella colonna delle dipendenze venivano aggregate. Ad esempio, se un progetto include una dipendenza foo, in cui sono definite le funzionalità A e B, e questo pacchetto è utilizzato in altri pacchetti bar e baz, dove bar dipende da foo con la funzionalità A e baz da foo con la funzionalità B, alla fine cargo unirà queste funzionalità e compilerà foo includendo le funzionalità A e B. Questo metodo potrebbe portare al fatto che una funzionalità inclusa a causa di una dipendenza possa risultare incompatibile con il sistema target per il quale viene effettuata la compilazione finale. Ad esempio, quando è necessario utilizzare una versione di foo con «#![no_std]» in un file eseguibile compilato con «#![no_std]», e allo stesso tempo utilizzare foo con «std» durante la compilazione in build.rs. Specificando resolver="2" in Cargo.toml, il gestore dei pacchetti ora cercherà di gestire correttamente questo conflitto, separando le dipendenze dev-, host- e target-.
- In cargo, the split-debuginfo option has been implemented in the section «[profile]» with the corresponding flag «-Csplit-debuginfo=unpacked» in rustc, introducing a new method for saving debugging information that eliminates the need to call the dsymutil utility and significantly speeds up the build process with debugging information on macOS.
- The macOS features «ptr::addr_of!» and «ptr::addr_of_mut!» have been stabilized, allowing the creation of raw pointers for unaligned fields. use std::ptr; #[repr(packed)] struct Packed { f1: u8, f2: u16, } let packed = Packed { f1: 1, f2: 2 }; // &packed.f2 will create an unaligned pointer, leading to undefined behavior let raw_f2 = ptr::addr_of!(packed.f2); assert_eq!(unsafe { raw_f2.read_unaligned() }, 2);
- A new batch of APIs has been promoted to stable, including the stabilization of the following methods:
- Arc::decrement_strong_count
- Arc::increment_strong_count
- Once::call_once_force
- Peekable::next_if_eq
- Peekable::next_if
- Seek::stream_position
- array::IntoIter
- panic::panic_any
- ptr::addr_of!
- ptr::addr_of_mut!
- slice::fill_with
- slice::split_inclusive_mut
- slice::split_inclusive
- slice::strip_prefix
- slice::strip_suffix
- str::split_inclusive
- sync::OnceState
- task::Wake
- È stato implementato il terzo livello di supporto per le piattaforme i386-unknown-linux-gnu, i486-unknown-linux-gnu, aarch64_be-unknown-linux-gnu, aarch64-unknown-linux-gnu_ilp32 e aarch64_be-unknown-linux-gnu_ilp32. Il terzo livello implica un supporto di base, ma senza testing automatizzato, pubblicazione di build ufficiali e verifica della possibilità di compilare il codice.
Fonte: opennet.ru
