Linguaxe de programación Rust versión 1.40

publicado versión da linguaxe de programación do sistema Ferruxe 1.40, fundada polo proxecto Mozilla. A linguaxe céntrase na seguridade da memoria, ofrece unha xestión automática da memoria e ofrece ferramentas para lograr un alto paralelismo de tarefas sen utilizar un colector de lixo e tempo de execución.

A xestión automática da memoria de Rust libera ao programador da manipulación do punteiro e protexe contra os problemas derivados da manipulación de memoria de baixo nivel, como accesos á memoria despois libres, desreferencias de punteiros nulos, desbordamentos do búfer e similares. Estase a desenvolver un xestor de paquetes para distribuír bibliotecas, garantir a montaxe e xestionar as dependencias do proxecto. Carga, o que lle permite obter as bibliotecas necesarias para o programa cun só clic. Admítese un repositorio para aloxar bibliotecas caixóns.io.

O principal innovacións:

• Engadida a capacidade de marcar estruturas (struct) e enumeracións (enum con bloque Variant) usando o atributo "#[non_exhaustivo]", que permite no futuro, engade novos campos e opcións ás estruturas e enumeracións declaradas. Por exemplo, os desenvolvedores de módulos que teñan estruturas con campos declarados publicamente poden usar "#[non_exhaustive]" para marcar estruturas que poidan engadir novos campos no futuro. Ata agora, nesta situación, o desenvolvedor estaba obrigado a elixir entre declarar campos de forma privada e vincularse a unha lista inmutable de campos. O novo atributo elimina esta limitación e permítelle engadir novos campos no futuro sen o risco de romper o código externo compilado previamente. Nos paquetes de caixas, ao facer coincidir opcións na sección "coincidir", é necesaria unha definición explícita da máscara "_ => {...}", que abarque posibles campos futuros, se non, aparecerá un erro ao engadir novos campos.
• Engadido a capacidade de chamar á macro procedimental mac!() nun contexto de tipo. Por exemplo, agora pode escribir "type Foo = expand_to_type!(bar);" se "expand_to_type" é unha macro de procedemento.
• En bloques "externo { ... }". engadido a capacidade de usar macros procedimentais e de atributos, incluídas macros "bang!()", por exemplo:

  macro_regras! make_item { ($nome:ident) => { fn $nome(); } }

  externo {
  facer_elemento!(alfa);
  make_item!(beta);
  }

  externo "C" {
  #[my_identity_macro] fn foo();
  }

• En macros implementado capacidade de xerar elementos "macro_rules!". Xerando "regras_macro!" posible tanto en macros tipo función (“mac!()”) como en macros en forma de atributos (“#[mac]”).
• No elemento de asignación $m:meta engadido soporte para valores de enumeración de tokens arbitrarios ("[TOKEN_STREAM]", "{TOKEN_STREAM}" e "(TOKEN_STREAM)"), por exemplo:

  macro_regras! accept_meta { ($m:meta) => {} }
  aceptar_meta!( my::path );
  aceptar_meta!( my::path = "lit" );
  aceptar_meta!( my::path ( a b c ) );
  acepta_meta!( my::path [ a b c ] );
  aceptar_meta!( my::path { a b c } );

• No modo Rust 2015, a saída de erros está habilitada para os problemas identificados ao comprobar o préstamo de variables (comprobador de préstamos) mediante a técnica NLL (Non-Lexical Lifetimes). Anteriormente, os avisos substituíronse por erros ao executarse no modo Rust 2018.
  Despois de que o cambio se estendese ao modo Rust 2015, os desenvolvedores finalmente puideron facelo desfacerse do antigo comprobador de préstamos.

  Lembremos que o sistema de verificación baseado nun novo mecanismo para ter en conta a vida útil das variables prestadas permitiu identificar algúns problemas que pasaron desapercibidos polo antigo código de verificación. Dado que a saída de erros para tales comprobacións podería afectar a compatibilidade co código que funcionaba anteriormente, inicialmente emitíronse avisos en lugar de erros.

• O atributo "const", que determina a posibilidade de usalo en calquera contexto en lugar de constantes, úsase para a función is_power_of_two (para enteiros sen signo).
• Moveuse unha nova parte da API á categoría estable, incluíndo a macro todo!() e os métodos slice::repeat, mem::take, BTreeMap::get_key_value, HashMap::get_key_value, estabilizáronse.
  Option::as_deref, Option::as_deref_mut, Option::flatten, UdpSocket::peer_addr, {f32,f64}::to_be_bytes, {f32,f64}::to_le_bytes,{f32,f64}::to_ne_bytes, {f32, f64}::from_be_bytes, {f32,f64}::from_le_bytes e {f32,f64}::from_ne_bytes.

• No xestor de paquetes de carga
  implementado almacenando en caché as advertencias do compilador no disco. Engadiuse a opción "metadatos de carga" ao comando "metadatos de carga".--plataforma-filtro" para mostrar só paquetes vinculados á plataforma de destino especificada na columna de resolución de dependencias. Engadiuse a opción de configuración da versión http.ssl para definir versións de TLS válidas.
  Engadida a posibilidade de publicar a sección "dependencias de desenvolvemento" sen especificar a chave de "versión".

• O compilador rustc ofrece soporte de terceiro nivel para as plataformas de destino thumbv7neon-unknown-linux-musleabihf, aarch64-unknown-none-softfloat, mips64-unknown-linux-muslabi64 e mips64el-unknown-linux-muslabi64. O terceiro nivel implica soporte básico, pero sen probas automatizadas e publicación de compilacións oficiais.

Fonte: opennet.ru