Moho 1.35

El equipo de desarrollo de Rust se complace en anunciar una nueva versión de su lenguaje: 1.35. Rust es un lenguaje de programación que te permite escribir programas confiables y eficientes.

Si ya tienes Rust instalado mediante Rustup, puedes actualizar con el comando:
$ actualización oxidada estable

Lo principal de la actualización es la implementación de las características de cierre Fn, FnOnce, FnMut, para Box ,Caja ,Caja , respectivamente. Al agregar la capacidad de emitir cierres a punteros a funciones inseguras, ahora es posible llamar a la macro dbg!() sin argumentos y la biblioteca estándar se ha estabilizado.

A los detalles:

• En la nueva versión agregamos implementaciones de los rasgos Fn, FnOnce, FnMut para Box ,Caja ,Caja , respectivamente.
  Ahora este código funcionará:
  fn foo(x: Caja u8>) -> Vec {
  vec![1, 2, 3, 4].into_iter().map(x).collect()
  }

  También puedes llamar a un cierre directamente desde Box :
  fn foo(x: Caja ) {
  X()
  }

• Ahora se pueden lanzar cierres a punteros a fn inseguro.
  Ahora este código es válido:
  /// Las invariantes de seguridad son las del puntero `unsafe fn` pasado.
  fn inseguro call_unsafe_fn_ptr(f: fn inseguro()) {
  F()
  }

  fn principal() {
  // SEGURIDAD: No hay invariantes.
  // Se impide estáticamente que el cierre haga cosas inseguras.
  inseguro {
  call_unsafe_fn_ptr(|| {
  dbg!();
  });
  }
  }

• Se agregó la capacidad de llamar a la macro dbg!() sin argumentos.
  Si pasa alguna expresión a esta macro, la macro imprimirá su resultado. Ejemplo:
  fn principal() {
  sea ​​mut x = 0;

  si dbg!(x == 1) {
  x + = 1;
  }

  dbg!(x);
  }

  Cuando ejecutes este código verás:
  [src/main.rs:4] x == 1 = falso
  [fuente/main.rs:8] x = 0

  Ahora puedes escribir así:
  fn principal() {
  let condición = verdadero;

  si condición {
  dbg!();
  }
  }

  Cuando ejecutes este código verás:
  [fuente/main.rs:5]
  

• Algunas partes de la biblioteca estándar se han estabilizado.
  • Nuevos métodos para f32 y f64:
    • f32::copiar
    • f64::copiar

    En realidad, las funciones copian el signo de otro número. Ejemplo:
    fn principal() {
    afirmar_eq!(3.5_f32.copysign(-0.42), -3.5);
    }

  • Se agregaron nuevos métodos para los tipos de rango.
    • Rango::contiene
    • RangoDe::contiene
    • RangoA::contiene
    • RangoInclusivo::contiene
    • RangeToInclusive::contiene

    Con estos métodos puedes comprobar fácilmente si un determinado valor está en una secuencia:
    fn principal() {
    si (0..=10).contiene(&5) {
    println!("Cinco está incluido del cero al diez.");
    }
    }

  • Puede encontrar una lista completa de API estabilizadas aquí
• En esta actualización, Clippy (este es un programa que verifica su código en busca de muchos errores) agregó una nueva verificación para drop_bounds. Esta verificación funciona cuando establece una restricción: T: Drop - para funciones generalizadas:
  fn foo (x:T){}

  Tener una restricción T: Drop suele ser un error, ya que algunos tipos se excluyen inmediatamente, como u8 (puedes leer más sobre esto. aquí)

• Muchas mejoras y correcciones en Cargo (administrador de paquetes de idiomas), lista completa de cambios

Fuente: linux.org.ru