Rust 1.35

El equipo de desarrolladores de Rust se complace en presentar la nueva versión de su lenguaje: 1.35. Rust es un lenguaje de programación que permite escribir programas fiables y eficientes.

Si ya tienes Rust instalado a través de rustup, puedes actualizarlo con el siguiente comando:
$ rustup update stable

Lo principal de esta actualización es la implementación de los traits de cierre Fn, FnOnce, FnMut, para Box<dyn Fn>, Box<dyn FnOnce>, Box<dyn FnMut>, respectivamente. Se añadió la capacidad de convertir cierres en punteros a funciones inseguras, y ahora se puede invocar el macro dbg!() sin argumentos.

En detalle:

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

  Además, se puede llamar a un cierre directamente desde Box<dyn FnOnce>:
  fn foo(x: Box<dyn FnOnce()>) {
  x()
  }

• Ahora es posible convertir cierres en punteros a funciones inseguras.
  Ahora este código es válido:
  /// The safety invariants are those of the `unsafe fn` pointer passed.
  unsafe fn call_unsafe_fn_ptr(f: unsafe fn()) {
  f()
  }

  fn main() {
  // SAFETY: There are no invariants.
  // The closure is statically prevented from doing unsafe things.
  unsafe {
  call_unsafe_fn_ptr(|| {
  dbg!();
  });
  }
  }

• Se añadió la posibilidad de invocar el macro dbg!() sin argumentos.
  Si le pasas alguna expresión a este macro, mostrará su resultado. Ejemplo:
  fn main() {
  let mut x = 0;

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

  dbg!(x);
  }

  Al ejecutar este código verás:
  [src/main.rs:4] x == 1 = false
  [src/main.rs:8] x = 0

  Ahora puedes escribir de esta forma:
  fn main() {
  let condition = true;

  if condition {
  dbg!();
  }
  }

  Al ejecutar este código verás:
  [src/main.rs:5]
  

• Se estabilizaron algunas partes de la biblioteca estándar.
  • Nuevos métodos para f32 y f64:
    • f32::copysign
    • f64::copysign

    Estas funciones copian el signo de otro número. Ejemplo:
    fn main() {
    assert_eq!(3.5_f32.copysign(-0.42), -3.5);
    }

  • Se añadieron nuevos métodos para los tipos Range.
    • Range::contains
    • RangeFrom::contains
    • RangeTo::contains
    • RangeInclusive::contains
    • RangeToInclusive::contains

    Con estos métodos, es fácil comprobar si un valor determinado está en la secuencia:
    fn main() {
    if (0..=10).contains(&5) {
    println!("Five is included in zero to ten.");
    }
    }

  • Puedes encontrar la lista completa de APIs estabilizadas. aquí
• En esta actualización, en Clippy (un programa que verifica tu código en busca de errores) se añadió una nueva verificación para drop_bounds. Esta verificación se activa cuando estableces una restricción: T: Drop — para funciones genéricas:
  fn foo<T: Drop>(x: T) {}

  Tener la restricción T: Drop suele ser un error, ya que excluye inmediatamente ciertos tipos como u8. (Puedes leer más sobre esto.) aquí)

• Se han mejorado y corregido muchas cosas en Cargo (el gestor de paquetes del lenguaje). lista completa de cambios

Fuente: linux.org.ru