Lansarea Rust 1.82. Un nou browser pe Rust. Utilizarea Rust în Volvo.

A fost lansată versiunea 1.82 a limbajului de programare de uz general Rust, dezvoltat inițial de Mozilla, dar acum întreținut de organizația nonprofit Rust Foundation. Limbajul se concentrează pe gestionarea sigură a memoriei și oferă instrumente pentru realizarea unui înalt grad de paralelism în executarea sarcinilor, fără a folosi un colector de gunoi și un runtime (runtime-ul se limitează la inițializarea de bază și la gestionarea bibliotecii standard).

Metodele de gestionare a memoriei în Rust scutesc dezvoltatorul de erori în manipularea pointerilor și protejează împotriva problemelor care apar din lucrul de nivel scăzut cu memoria, cum ar fi accesarea unui spațiu de memorie după ce acesta a fost eliberat, dereferința pointerilor nuli, depășirea limitelor buffer-ului etc. Pentru distribuirea bibliotecilor, asigurarea construirii și gestionarea dependențelor, se dezvoltă managerul de pachete Cargo. Pentru găzduirea bibliotecilor, suportul este oferit prin intermediul repository-ului crates.io.

Lucrul sigur cu memoria este asigurat în Rust în timpul compilării prin verificarea referințelor, urmărirea proprietății obiectelor, luarea în considerare a timpului de viață al obiectelor (domeniul de vizibilitate) și evaluarea corectitudinii accesului la memorie în timpul execuției codului. Rust oferă, de asemenea, instrumente pentru protejarea împotriva suprasaturării numerice, impune inițializarea obligatorie a valorilor variabilelor înainte de utilizare, gestionează mai bine erorile în biblioteca standard, aplică conceptul de referințe și variabile imutabile (immutable) din oficiu și oferă o tipizare statică puternică pentru a minimiza erorile logice.

Noutăți principale:

• În managerul de pachete cargo a fost adăugată comanda „info” pentru a afișa informații despre pachet în depozit.
• A fost adăugată suport pentru sintaxa „use<..>” în „impl Trait”, care definește informații despre tipurile ascunse. De exemplu, „impl Trait + use<‘x, T>” indică că în tipul ascuns sunt permise doar parametrii „x” și „T”.
• A fost propusă o sintaxă separată pentru crearea pointerilor raw, înlocuind macrocomenzile folosite anterior: în locul macrocomenzii „addr_of!(expr)” a apărut operatorul „&raw const expr”, iar în locul macrocomenzii „addr_of_mut!(expr)” a venit operatorul „&raw mut expr”. struct Packed { not_aligned_field: i32, } fn main() { let p = Packed { not_aligned_field: 1_82 }; // Vechea metodă de creare a unui pointer raw let ptr = std::ptr::addr_of!(p.not_aligned_field); // Noua metodă de creare a unui pointer raw let ptr = &raw const p.not_aligned_field; let val = unsafe { ptr.read_unaligned() }; }
• A fost oferită posibilitatea de a defini funcții și constante sigure (safe) cu durata de viață 'static' în blocuri extern cu marcajul „unsafe” (anterior toate elementele din „unsafe extern” puteau avea doar marcajul „unsafe”): unsafe extern { pub safe static TAU: f64; pub safe fn sqrt(x: f64) -> f64; pub unsafe fn strlen(p: *const u8) -> usize; }
• Atributele no_mangle, link_section și export_name, care pot duce la comportamente nedeterminate, sunt acum considerate nesigure și necesită marcaj explicit cu „unsafe”, de exemplu: #[unsafe(no_mangle)] pub fn my_global_function() { }
• În corelarea cu un model, este permis să se sară tipurile goale, cum ar fi „enum Void {}” sau structuri cu un câmp vizibil gol. use std::convert::Infallible; pub fn unwrap_without_panic<T>(x: Result<T, Infallible>) -> T { let Ok(x) = x; // „Err” poate fi sărit x }
• În tipurile pentru numere cu virgulă mobilă (f32 și f64) se standardizează comportamentul la procesarea valorilor non-numerice NaN (0.0/0.0) și se permite utilizarea operațiunilor cu virgulă mobilă în const fn.
• În inserțiile de asamblare, a fost oferită posibilitatea de a utiliza operanzi cu semnul „const” pentru utilizarea directă a valorilor numerice întregi fără a le salva anterior în registru. const MSG: &str = „Hello, world!\n”; unsafe { core::arch::asm!( „mov rdx, {LEN} // va fi formată instrucțiunea ‘mov rdx, 14′”, LEN = const MSG.len(), … ); }
• Este permisă adresarea expresiilor cu semnul „static” în context sigur fără a defini un bloc unsafe (operatoarele „&raw mut” și „&raw const” nu influențează valoarea operandului și creează doar un pointer către acesta): static mut STATIC_MUT: Type = Type::new(); extern „C” { static EXTERN_STATIC: Type; } fn main() { let static_mut_ptr = &raw mut STATIC_MUT; let extern_static_ptr = &raw const EXTERN_STATIC; }
• O nouă porțiune de API a fost transformată în stabilitate, inclusiv metode și implementări ale tiparelor stabilize.
  • std::thread::Builder::spawn_unchecked
  • std::str::CharIndices::offset
  • std::option::Option::is_none_or
  • [T]::is_sorted
  • [T]::is_sorted_by
  • [T]::is_sorted_by_key
  • Iterator::is_sorted
  • Iterator::is_sorted_by
  • Iterator::is_sorted_by_key
  • std::future::Ready::into_inner
  • std::iter::repeat_n
  • impl DoubleEndedIterator for Take
    
    Sursa: opennet.ro