Uscita del linguaggio di programmazione Rust 1.80

È stato rilasciato Rust 1.80, un linguaggio di programmazione di uso generale sviluppato originariamente da Mozilla, ora gestito dalla non profit Rust Foundation. Il linguaggio si concentra sulla gestione sicura della memoria e offre strumenti per raggiungere un elevato parallelismo nell'esecuzione delle attività, evitando l'uso di un garbage collector e di un runtime (il runtime si limita all'inizializzazione di base e alla gestione 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:

• Sono state aggiunte le strutture LazyCell e LazyLock, che consentono di rinviare l'inizializzazione dei dati fino al primo accesso (la funzione di inizializzazione viene chiamata nel momento in cui si tenta di accedere al valore). LazyLock si differenzia da LazyCell per il supporto di strumenti di sincronizzazione da utilizzare nel codice multithreading. use std::sync::LazyLock; use std::time::Instant; static LAZY_TIME: LazyLock = LazyLock::new(Instant::now); fn main() { let start = Instant::now(); std::thread::scope(|s| { s.spawn(|| { println!("Thread lazy time is {:?}", LAZY_TIME.duration_since(start)); }); println!("Main lazy time is {:?}", LAZY_TIME.duration_since(start)); }); }
• Nel compilatore rustc, è stata stabilizzata l'opzione "--check-cfg", che viene utilizzata dal gestore pacchetti per verificare tutti i nomi e i valori definiti tramite cfg, inclusi i nomi presenti in Cargo.toml. fn main() { println!("Hello, world!"); #[cfg(feature = "crayon")] rayon::join( || println!("Hello, Thing One!"), || println!("Hello, Thing Two!"), ); } warning: unexpected `cfg` condition value: `crayon` —> src/main.rs:4:11 | 4 | #[cfg(feature = "crayon")] | ^^^^^^^^^^------- | | | help: there is a expected value with a similar name: `"rayon"`
• Negli schemi, è consentita l'indicazione di intervalli nei formati "a..b" e "..b", che sono analoghi all'uso delle espressioni Range e RangeTo. pub fn size_prefix(n: u32) -> &'static str { const K: u32 = 10u32.pow(3); const M: u32 = 10u32.pow(6); const G: u32 = 10u32.pow(9); match n { ..K => "", K..M => "k", M..G => "M", G.. => "G", } }
• Una nuova serie di API è stata traslata nella categoria stabile, stabilizzando i metodi e le implementazioni dei tipi:
  • impl Default for Rc
  • impl Default for Rc
  • impl Default for Rc
  • impl Default for Arc
  • impl Default for Arc
  • impl Default for Arc
  • impl IntoIterator for Box
  • impl FromIterator for Box
  • impl FromIterator for Box
  • LazyCell
  • LazyLock
  • Duration::div_duration_f32
  • Duration::div_duration_f64
  • Option::take_if
  • Seek::seek_relative
  • BinaryHeap::as_slice
  • NonNull::offset
  • NonNull::byte_offset
  • NonNull::add
  • NonNull::byte_add
  • NonNull::sub
  • NonNull::byte_sub
  • NonNull::offset_from
  • NonNull::byte_offset_from
  • NonNull::read
  • NonNull::read_volatile
  • NonNull::read_unaligned
  • NonNull::write
  • NonNull::write_volatile
  • NonNull::write_unaligned
  • NonNull::write_bytes
  • NonNull::copy_to
  • NonNull::copy_to_nonoverlapping
  • NonNull::copy_from
  • NonNull::copy_from_nonoverlapping
  • NonNull::replace
  • NonNull::swap
  • NonNull::drop_in_place
  • NonNull::align_offset
  • ::split_at_checked
  • ::split_at_mut_checked
  • str::split_at_checked
  • str::split_at_mut_checked
  • str::trim_ascii
  • str::trim_ascii_start
  • str::trim_ascii_end
  • ::trim_ascii
  • ::trim_ascii_start
  • ::trim_ascii_end
  • Ipv4Addr::BITS
  • Ipv4Addr::to_bits
  • Ipv4Addr::from_bits
  • Ipv6Addr::BITS
  • Ipv6Addr::to_bits
  • Ipv6Addr::from_bits
  • Vec::::into_flattened
  • ::as_flattened
  • ::as_flattened_mut
• L'indicatore «const», che determina la possibilità di utilizzo in qualsiasi contesto al posto delle costanti, è stato applicato nelle funzioni:
  • ::last_chunk
  • BinaryHeap::new
• È stato implementato il terzo livello di supporto per la piattaforma x86_64-unknown-linux-none. Il terzo livello prevede un supporto di base, ma senza test automatizzati, pubblicazione di build ufficiali e verifica della capacità di compilare il codice.

Fonte: opennet.ru