A fost publicată versiunea 1.53 a limbajului de programare sistemică Rust, inițial dezvoltat de proiectul Mozilla, dar acum continuat sub auspiciile organizației non-profit Rust Foundation. Limbajul se concentrează pe o manipulare sigură a memoriei, asigură management automat al memoriei și oferă instrumente pentru a atinge un grad înalt de paralelism în execuția sarcinilor, fără a utiliza un colector de gunoi și un runtime (runtime-ul se limitează la inițializarea de bază și la întreținerea bibliotecii standard).
Managementul automat al memoriei în Rust își scapă dezvoltatorii de erorile care apar în manipularea pointerilor și îi protejează de problemele cauzate de lucrul la nivel jos cu memoria, precum accesarea unei zone de memorie după ce a fost eliberată, dereferințierea pointerilor nuli, depășirea limitelor unui buffer etc. Pentru distribuirea bibliotecilor, asigurarea construcției și gestionarea dependențelor, proiectul dezvoltă managerul de pachete Cargo. Pentru găzduirea bibliotecilor este suportat depozitul crates.io.
Noutăți principale:
- Pentru array-uri a fost implementat trait-ul IntoIterator, care permite parcurgerea elementelor array-ului după valori: for i in [1, 2, 3] { .. }
A fost, de asemenea, introdusă posibilitatea de a transmite array-uri în metode care acceptă iteratori, de exemplu: let set = BTreeSet::from_iter([1, 2, 3]); for (a, b) in some_iterator.chain([1]).zip([1, 2, 3]) { .. }
Anterior, IntoIterator era implementat doar pentru referințe la array-uri, adică pentru a parcurge după valori era necesară utilizarea referințelor („&[1, 2, 3]”) sau „[1, 2, 3].iter()”. Implementările IntoIterator pentru array-uri erau blocate din cauza problemelor de compatibilitate cauzate de transformarea anterioară din compilator a metodei array.into_iter() în (&array).into_iter(). Problemele menționate au fost rezolvate pe o cale indirectă — compilatorul va continua să transforme array.into_iter() în (&array).into_iter(), ca și cum nu ar exista implementarea trait-ului IntoIterator, dar doar atunci când metoda este apelată folosind sintaxa „.into_iter()” și fără a afecta apelurile în forma „in [1, 2, 3]”, „iter.zip([1, 2, 3])”, „IntoIterator::into_iter([1, 2, 3])”.
- A fost oferită posibilitatea de a specifica expresii „|” (operație logică OR) în orice parte a sablonului, de exemplu, în loc de „Some(1) | Some(2)” acum se poate scrie „Some(1 | 2)”: match result { Ok(Some(1 | 2)) => { .. } Err(MyError { kind: FileNotFound | PermissionDenied, .. }) => { .. } _ => { .. } }
- Utilizarea simbolurilor non-ASCII în identificatori este permisă, inclusiv orice simboluri naționale definite în specificația Unicode UAX 31, cu excepția simbolurilor emoji. Atunci când se utilizează simboluri diferite, dar asemănătoare ca aspect, compilatorul va emite un avertisment. const BLÅHAJ: &str = «🦈»; struct 人 { 名字: String, } let α = 1; let ｓos = 2; warning: identifier pair considered confusable between ‘ｓ’ and ‘s’
- Nouă rundă de API-uri a fost clasificată ca stabilă, inclusiv stabilizările pentru:
- array::from_ref
- array::from_mut
- AtomicBool::fetch_update
- AtomicPtr::fetch_update
- BTreeSet::retain
- BTreeMap::retain
- BufReader::seek_relative
- cmp::min_by
- cmp::min_by_key
- cmp::max_by
- cmp::max_by_key
- DebugStruct::finish_non_exhaustive
- Duration::ZERO
- Duration::MAX
- Duration::is_zero
- Duration::saturating_add
- Duration::saturating_sub
- Duration::saturating_mul
- f32::is_subnormal
- f64::is_subnormal
- IntoIterator pentru array-uri
- {integer}::BITS
- io::Error::Unsupported
- NonZero*::leading_zeros
- NonZero*::trailing_zeros
- Option::insert
- Ordering::is_eq
- Ordering::is_ne
- Ordering::is_lt
- Ordering::is_gt
- Ordering::is_le
- Ordering::is_ge
- OsStr::make_ascii_lowercase
- OsStr::make_ascii_uppercase
- OsStr::to_ascii_lowercase
- OsStr::to_ascii_uppercase
- OsStr::is_ascii
- OsStr::eq_ignore_ascii_case
- Peekable::peek_mut
- Rc::increment_strong_count
- Rc::decrement_strong_count
- slice::IterMut::as_slice
- AsRef<[T]> pentru slice::IterMut
- impl SliceIndex pentru (Bound<usize>, Bound<usize>)
- Vec::extend_from_within
- A fost implementat un al treilea nivel de suport pentru platforma wasm64-unknown-unknown. Al treilea nivel implică suport de bază, dar fără testare automată, publicarea pachetelor oficiale și verificarea posibilității de compilare a codului.
- Managerul de pachete Cargo a fost setat implicit să folosească numele „main” pentru ramura principală a repositoarelor Git (HEAD). Pentru dependențele găzduite în repositoare care utilizează numele main în loc de master, nu mai este necesară specificarea în setările branch = „main”.
- Cerinele minime de versiune LLVM în compilator au fost ridicate la LLVM 10.
De asemenea, merită menționat finanțarea activităților de dezvoltare a integrării în nucleul Linux a instrumentelor pentru dezvoltarea componentelor în limbajul Rust. Lucrările vor avea loc în cadrul proiectului Prossimo sub egida organizației ISRG (Internet Security Research Group), care este fondatoarea proiectului Let’s Encrypt și facilitează promovarea HTTPS și dezvoltarea tehnologiilor pentru îmbunătățirea securității internetului. Finanțarea va fi oferită de Google, care va acoperi costul muncii lui Miguel Ojeda, autorul proiectului Rust-for-Linux. Anterior, ISRG și Google au finanțat deja crearea unui backend HTTP alternativ pentru utilitarul curl și dezvoltarea unui nou modul TLS pentru serverul http Apache.
Conform datelor companiilor Microsoft și Google, aproximativ 70% din vulnerabilități sunt cauzate de gestionarea nesigură a memoriei. Se consideră că utilizarea limbajului Rust pentru dezvoltarea componentelor nucleului, cum ar fi driverele de dispozitive, va reduce riscul apariției vulnerabilităților cauzate de gestionarea nesigură a memoriei și va elimina apariția unor erori precum accesarea unei zone de memorie după ce aceasta a fost eliberată și depășirea limitelor buffer-ului.
Funcționarea sigură a memoriei este asigurată în Rust în timpul compilării prin verificarea referințelor, urmărirea deținerii obiectelor și gestionarea duratei de viață a obiectelor (zona de vizibilitate), precum și prin evaluarea corectitudinii accesului la memorie în timpul execuției codului. Rust oferă, de asemenea, instrumente pentru protecția împotriva depășirilor de numere întregi, necesită 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) în mod implicit și oferă o tipizare statică puternică pentru a minimiza erorile logice.
Sursa: opennet.ro
