Linguaxe de programación Rust versión 1.61

Publicouse o lanzamento da linguaxe de programación de propósito xeral Rust 1.61, fundada polo proxecto Mozilla, pero agora desenvolvida baixo os auspicios da organización independente sen ánimo de lucro Rust Foundation. A linguaxe céntrase na seguridade da memoria e proporciona os medios para conseguir un alto paralelismo de traballos evitando o uso dun colector de lixo e o tempo de execución (o tempo de execución redúcese á inicialización básica e ao mantemento da biblioteca estándar).

Os métodos de manexo da memoria de Rust salvan ao desenvolvedor de erros ao manipular os punteiros e protexen contra os problemas que xurdan debido ao manexo de memoria de baixo nivel, como acceder a unha área de memoria despois de liberarse, desreferenciar punteiros nulos, exceder o búfer, etc. Para distribuír bibliotecas, proporcionar compilacións e xestionar dependencias, o proxecto desenvolve o xestor de paquetes Cargo. O repositorio crates.io é compatible para hospedar bibliotecas.

A seguridade da memoria ofrécese en Rust no momento da compilación mediante a comprobación de referencias, o seguimento da propiedade do obxecto, o seguimento da vida útil dos obxectos (ámbitos) e a avaliación da corrección do acceso á memoria durante a execución do código. Rust tamén ofrece protección contra desbordamentos de enteiros, require a inicialización obrigatoria dos valores variables antes do seu uso, manexa mellor os erros na biblioteca estándar, aplica o concepto de referencias e variables inmutables por defecto, ofrece unha forte escritura estática para minimizar os erros lóxicos.

Principais novidades:

• É posible definir os seus propios códigos de retorno desde a función principal. Orixinalmente, a función principal de Rust só podía devolver o tipo "()" (unidade), que sempre indicaba un estado de saída exitoso a menos que o desenvolvedor chamase explícitamente á función "process::exit(code)". En Rust 1.26, usando o trazo de terminación inestable na función principal, foi posible devolver os valores "Ok" e "Err", correspondentes aos códigos EXIT_SUCCESS e EXIT_FAILURE en programas C. En Rust 1.61, o trazo Termination estableciuse e propúxose un tipo ExitCode separado para representar un código de retorno específico, que abstrae os tipos de retorno específicos da plataforma proporcionando constantes predefinidas SUCCESS e FAILURE e o método From. para devolver un código de devolución personalizado. use std::process::ExitCode; fn main() -> ExitCode { if !check_foo () { return ExitCode::from (8); } Código de saída:: ÉXITO }
• Estabilizáronse capacidades adicionais das funcións definidas mediante a expresión "const fn", que se poden chamar non só como funcións regulares, senón que tamén se usan en calquera contexto en lugar de constantes. Estas funcións calcúlanse en tempo de compilación, non en tempo de execución, polo que están suxeitas a certas restricións, como a capacidade de ler só desde constantes. Na nova versión, as operacións básicas con punteiros de función están permitidas dentro das funcións const (permítese crear, pasar e lanzar punteiros, pero non chamar a función por punteiro); límites de trazo para parámetros xenéricos de funcións const como T: Copy; trazos despachables dinámicamente (dyn Trait); impl Tipos de trazo para argumentos de función e valores de retorno.
• O fluxo xestiona Stdin, Stdout e Stderr en std::io agora ten unha vida útil estática ("'estática") cando se bloquea, permitindo construcións como "let out = std::io::stdout().lock();" con conseguir un asa e establecer un bloqueo nunha expresión.
• Unha nova parte da API trasladouse á categoría de estable, incluíndo os métodos e implementacións de trazos estabilizados:
  • Pin::static_mut
  • Pin::static_ref
  • Vec::retain_mut
  • VecDeque::retain_mut
  • Escribir para o cursor<[u8; N]>
  • std::os::unix::net::SocketAddr::from_pathname
  • std::process::ExitCode
  • std::proceso::Terminación
  • std::thread::JoinHandle::está_terminado
• O atributo "const", que determina a posibilidade de usalo en calquera contexto en lugar de constantes, úsase nas funcións:
  • <*const T>::offset e <*mut T>::offset
  • <*const T>::wrapping_offset e <*mut T>::wrapping_offset
  • <*const T>::add e <*mut T>::add
  • <*const T>::sub e <*mut T>::sub
  • <*const T>::wrapping_add e <*mut T>::wrapping_add
  • <*const T>::wrapping_sub e <*mut T>::wrapping_sub
  • <[T]>::as_mut_ptr
  • <[T]>::as_ptr_range
  • <[T]>::as_mut_ptr_range

Ademais, podes anotar o artigo "Rust: A Critical Retrospective" cun resumo das impresións da linguaxe Rust despois de escribir 100 mil liñas de código nel durante o desenvolvemento do sistema operativo de micronúcleo Xous usado no firmware. As desvantaxes inclúen a sintaxe difícil de entender, a incompletitude e o desenvolvemento continuo da linguaxe, a falta de compilacións repetibles, os problemas típicos coa confianza de dependencia en Crates.io e a necesidade de manter unha certa disciplina para escribir código seguro. As funcións que superaron as expectativas inclúen ferramentas para refactorizar código e reelaborar "hacks" engadidos durante a creación de prototipos rápidos.

Fonte: opennet.ru