Lanzamento da linguaxe de programación Rust 1.59 con soporte para insercións de montaxe

Publicouse o lanzamento da linguaxe de programación de propósito xeral Rust 1.59, 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 utilizar insercións en linguaxe ensamblador, que son demandadas en aplicacións que precisan controlar a execución a un nivel baixo ou poder utilizar instrucións de máquina especializadas. As insercións de conxunto engádense usando macros "asm!" e "global_asm!" usando unha sintaxe de formato de cadea para nomear rexistros semellante á utilizada para substitucións de cadea en Rust. O compilador admite instrucións de montaxe para arquitecturas x86, x86-64, ARM, AArch64 e RISC-V. Exemplo de inserción: use std::arch::asm; // Multiplica x por 6 usando desprazamentos e sumas let mut x: u64 = 4; inseguro { asm!( "mov {tmp}, {x}", "shl {tmp}, 1", "shl {x}, 2", "engadir {x}, {tmp}", x = inout(reg ) x, tmp = out(reg) _, ); } assert_eq!(x, 4 * 6);
• Engadido soporte para asignacións desestruturadas (paralelas), nas que se especifican varios trazos, porcións ou estruturas no lado esquerdo da expresión. Por exemplo: sexa (a, b, c, d, e); (a, b) = (1, 2); [c, .., d, _] = [1, 2, 3, 4, 5]; Estrutura { e, .. } = Estrutura { e: 5, f: 3 }; assert_eq!([1, 2, 1, 4, 5], [a, b, c, d, e]);
• É posible especificar valores predeterminados para os xenéricos const: struct ArrayStorage { arr: [T; N], } impl ArrayStorage { fn new(a: T, b: T) -> ArrayStorage { ArrayStorage { arr: [a, b], } } }
• O xestor de paquetes Cargo proporciona avisos sobre o uso de estruturas non válidas en dependencias que se procesan debido a erros no compilador (por exemplo, debido a un erro, permitíronse tomar prestados campos de estruturas empaquetadas en bloques seguros). Tales construcións xa non serán compatibles nunha versión futura de Rust.
• Cargo e Rustc teñen unha capacidade integrada para xerar ficheiros executables sen datos de depuración (strip = "debuginfo") e símbolos (strip = "symbols"), sen necesidade de chamar a unha utilidade separada. A configuración de limpeza realízase mediante o parámetro "strip" en Cargo.toml: [profile.release] strip = "debuginfo", "symbols"
• A compilación incremental está desactivada por defecto. Dise que o motivo é unha solución temporal a un erro no compilador que provoca fallos e erros de deserialización. Xa se preparou unha corrección de erros e incluirase na próxima versión. Para devolver a compilación incremental, pode usar a variable de ambiente RUSTC_FORCE_INCREMENTAL=1.
• Unha nova parte da API trasladouse á categoría de estable, incluíndo os métodos e implementacións de trazos estabilizados:
  • std::thread::available_parallelism
  • Resultado::copiado
  • Resultado::clonado
  • arco::asm!
  • arch::global_asm!
  • ops::ControlFlow::is_break
  • ops::ControlFlow::is_continue
  • TryFrom para u8
  • char::TryFromCharError (Clonar, Depurar, Mostrar, PartialEq, Copiar, Eq, Erro)
  • iter::zip
  • NonZeroU8::é_poder_de_dous
  • NonZeroU16::é_poder_de_dous
  • NonZeroU32::é_poder_de_dous
  • NonZeroU64::é_poder_de_dous
  • NonZeroU128::é_poder_de_dous
  • DoubleEndedIterator para a estrutura ToLowercase
  • DoubleEndedIterator para a estrutura ToUppercase
  • TryFrom para [T; N]
  • UnwindSafe para a estrutura Once
  • RefUnwindSafe por unha vez
  • funcións de soporte de armv8 neon integradas no compilador para aarch64
• O atributo "const", que determina a posibilidade de usalo en calquera contexto en lugar de constantes, úsase nas funcións:
  • mem::MaybeUninit::as_ptr
  • mem::MaybeUninit::assume_init
  • mem::MaybeUninit::assume_init_ref
  • ffi::CStr::from_bytes_with_nul_unchecked

Fonte: opennet.ru