Linguaxe de programación Rust versión 1.45

publicado versión 1.45 da linguaxe de programación do sistema Ferrugem, 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 elimina os erros ao manipular os punteiros e protexe contra os problemas derivados da manipulación de memoria de baixo nivel, como acceder a unha rexión de memoria despois de liberarse, desreferencias de punteiros nulos, desbordamentos do búfer, etc. 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:

• Eliminado de longa data defecto ao realizar conversións entre números enteiros e números de coma flotante. Dado que o compilador Rust usa LLVM como backend, as operacións de conversión de tipos realizáronse mediante instrucións de código intermedio de LLVM como fptoui, que teñen unha característica significativa: comportamento indefinido se o valor resultante non encaixa no tipo de destino. Por exemplo, ao converter o valor flotante 300 co tipo f32 ao tipo enteiro u8, o resultado é imprevisible e pode variar en diferentes sistemas. O problema é que esta función aparece no código que non está marcado como "inseguro".

  A partir de Rust 1.45, o comportamento do desbordamento do tamaño do tipo está estrictamente regulado, e o operador de conversión "como" verifica o desbordamento e obriga a converter o valor ao valor máximo ou mínimo do tipo de destino (no exemplo anterior, un valor de 300 converteríase en 255). Para desactivar tales comprobacións, ofrécense chamadas de API adicionais "{f64, f32}::to_int_unchecked", que funcionan en modo non seguro.

  fn cast (x: f32) -> u8 {
  x como u8
  }

  fn main() {
  deixe too_big = 300.0;
  deixe too_small = -100.0;
  deixe nan = f32::NAN;

  sexa x: f32 = 1.0;
  deixe y: u8 = inseguro { x.to_int_unchecked () };

  println!("demasiado_grande_casted = {}", emitir(demasiado_grande)); // saída 255
  println!("demasiado_pequeno_casted = {}", cast (demasiado_pequeno)); // saída 0
  println!("non_un_número_casted = {}", cast(nan)); // saída 0
  }

• Uso estabilizado macros de procedementoexpresións similares a funcións, modelos e instrucións. Anteriormente, tales macros non se podían chamar en todas partes, senón só en determinadas partes do código (como chamada separada, non entrelazada con outro código). Ampliar a forma en que se poden chamar macros, de xeito similar ás funcións, foi un dos requisitos para que o framework web funcione Foguete en lanzamentos estables de Rust. Anteriormente, para conseguir unha flexibilidade adicional na definición de controladores en Rocket requiría activar a función experimental "proc_macro_hygiene", que non está dispoñible nas versións estables de Rust. Esta funcionalidade está agora integrada en versións estables da linguaxe.
• Permítese usar intervalos co tipo "char" para iterar sobre valores de intervalo (ops::{Range, RangeFrom, RangeFull, RangeInclusive, RangeTo}):

  para ch en 'a'..='z' {
  imprimir!("{}", ch);
  }
  imprimirln!(); // Imprimirá "abcdefghijklmnopqrstuvwxyz"

• Unha nova parte das API foi transferida á categoría estable, incluída a estabilizada
  Arc::as_ptr,
  BTreeMap::remove_entry,
  Rc::as_ptr,
  rc::Weak::as_ptr,
  rc::Debil::from_raw,
  rc::Weak::into_raw,
  str::prefixo_stripa,
  str::strip_sufix,
  sync::Weak::as_ptr,
  sync::Weak::from_raw,
  sync::Weak::into_raw,
  char::UNICODE_VERSION,
  Span::resolved_at,
  Span::located_at,
  Span::mixed_site,
  unix::proceso::CommandExt::arg0.

• O compilador rustc engadiu compatibilidade para anular varias funcións da plataforma de destino usando a marca "target-feature", por exemplo, "-C target-feature=+avx2,+fma". Tamén se engadiron novas bandeiras:
  "force-unwind-tables" para xerar táboas de chamadas de desenrolar, independentemente da estratexia de tratamento de fallos; "embed-bitcode" para controlar se o código de bits LLVM está incluído nos rlib xerados. A marca "embed-bitcode" está habilitada de forma predeterminada en Cargo para optimizar o tempo de compilación e o consumo de espazo en disco.

• Proporcionouse un terceiro nivel de soporte para as plataformas mipsel-sony-psp e thumbv7a-uwp-windows-msvc. O terceiro nivel implica soporte básico, pero sen probas automatizadas e publicación de compilacións oficiais.

Ademais, pódese sinalar historia sobre crear o máis sinxelo aplicacións na linguaxe Rust, comezando a usar o cargador de arranque do sistema e listo para cargar de forma autónoma en lugar do sistema operativo.
O artigo é o primeiro dunha serie dedicada a demostrar técnicas que son demandadas na programación de baixo nivel e no desenvolvemento de SO.

Fonte: opennet.ru