Versió del llenguatge de programació Rust 1.61

S'ha publicat el llançament del llenguatge de programació de propòsit general Rust 1.61, fundat pel projecte Mozilla, però ara desenvolupat sota els auspicis de l'organització independent sense ànim de lucre Rust Foundation. El llenguatge se centra en la seguretat de la memòria i proporciona els mitjans per aconseguir un alt paral·lelisme de treballs evitant l'ús d'un col·lector d'escombraries i el temps d'execució (el temps d'execució es redueix a la inicialització bàsica i al manteniment de la biblioteca estàndard).

Els mètodes de gestió de memòria de Rust estalvien al desenvolupador d'errors en manipular els punters i protegeixen dels problemes que sorgeixen a causa del maneig de la memòria de baix nivell, com ara accedir a una àrea de memòria després d'haver-se alliberat, desreferenciar punters nuls, desbordaments de memòria intermèdia, etc. Per distribuir biblioteques, proporcionar compilacions i gestionar dependències, el projecte desenvolupa el gestor de paquets Cargo. El repositori crates.io és compatible per allotjar biblioteques.

La seguretat de la memòria es proporciona a Rust en temps de compilació mitjançant la comprovació de referències, el seguiment de la propietat de l'objecte, el seguiment de la vida útil dels objectes (àmbits) i l'avaluació de la correcció de l'accés a la memòria durant l'execució del codi. Rust també proporciona protecció contra desbordaments d'enters, requereix la inicialització obligatòria dels valors de les variables abans de l'ús, gestiona millor els errors a la biblioteca estàndard, aplica el concepte de referències i variables immutables per defecte, ofereix una escriptura estàtica forta per minimitzar els errors lògics.

Principals innovacions:

• És possible definir els vostres propis codis de retorn des de la funció principal. Originalment, la funció principal de Rust només podia retornar el tipus "()" (unitat), que sempre indicava un estat de sortida satisfactori tret que el desenvolupador cridés explícitament la funció "procés::exit(codi)". A Rust 1.26, utilitzant el tret de terminació inestable a la funció principal, era possible retornar els valors "Ok" i "Err", corresponents als codis EXIT_SUCCESS i EXIT_FAILURE dels programes C. A Rust 1.61, el tret de terminació s'ha fet estable i s'ha proposat un tipus ExitCode separat per representar un codi de retorn específic, que abstraeix els tipus de retorn específics de la plataforma proporcionant constants predefinides SUCCES i FAILURE, i el mètode From. per tornar un codi de retorn personalitzat. utilitzar std::process::ExitCode; fn main() -> ExitCode { if !check_foo () { return ExitCode::from (8); } ExitCode::SUCCESS }
• S'han estabilitzat capacitats addicionals de les funcions definides amb l'expressió "const fn", que es poden anomenar no només com a funcions regulars, sinó que també s'utilitzen en qualsevol context en lloc de constants. Aquestes funcions es calculen en temps de compilació, no en temps d'execució, de manera que estan subjectes a certes restriccions, com ara la capacitat de llegir només a partir de constants. A la nova versió, les operacions bàsiques amb punters de funció es permeten dins de les funcions const (es permet crear, passar i llançar punters, però no cridar una funció per punter); límits de trets per a paràmetres genèrics de funcions const com ara T: Copy; trets distribuïbles dinàmicament (tret dyn); impl Tipus de trets per a arguments de funció i valors de retorn.
• El flux gestiona Stdin, Stdout i Stderr a std::io ara té una vida estàtica ("'estàtica") quan es bloqueja, permetent construccions com "let out = std::io::stdout().lock();" amb aconseguir un mànec i posar un pany en una expressió.
• Una nova part de l'API s'ha mogut a la categoria d'estable, inclosos els mètodes i les implementacions de trets s'han estabilitzat:
  • Pin::static_mut
  • Pin::static_ref
  • Vec::retain_mut
  • VecDeque::retain_mut
  • Escriure per al cursor<[u8; N]>
  • std::os::unix::net::SocketAddr::from_pathname
  • std::process::ExitCode
  • std::process::Terminació
  • std::thread::JoinHandle::is_acabat
• L'atribut "const", que determina la possibilitat d'utilitzar-lo en qualsevol context en lloc de constants, s'utilitza a les funcions:
  • <*const T>::offset i <*mut T>::offset
  • <*const T>::wrapping_offset i <*mut T>::wrapping_offset
  • <*const T>::add i <*mut T>::add
  • <*const T>::sub i <*mut T>::sub
  • <*const T>::wrapping_add i <*mut T>::wrapping_add
  • <*const T>::wrapping_sub i <*mut T>::wrapping_sub
  • <[T]>::as_mut_ptr
  • <[T]>::as_ptr_range
  • <[T]>::as_mut_ptr_range

A més, podeu destacar l'article "Rust: una retrospectiva crítica" amb un resum de les impressions del llenguatge Rust després d'escriure-hi 100 mil línies de codi durant el desenvolupament del sistema operatiu de micronucli Xous utilitzat al firmware. Els desavantatges inclouen la sintaxi difícil d'entendre, la incompletitud i el desenvolupament continuat del llenguatge, la manca de compilacions repetibles, els problemes típics amb la confiança de dependència a Crates.io i la necessitat de mantenir una certa disciplina per escriure codi segur. Les característiques que van superar les expectatives inclouen eines per refactoritzar el codi i reelaborar "hacks" afegits durant el prototipat ràpid.

Font: opennet.ru