Rust 1.35

Il team di sviluppo di Rust è felice di presentare la nuova versione del proprio linguaggio: 1.35. Rust è un linguaggio di programmazione che consente di scrivere programmi affidabili ed efficienti.

Se hai già installato Rust tramite rustup, puoi aggiornare con il comando:
$ rustup update stable

La principale novità in questo aggiornamento è l'implementazione dei trait closure Fn, FnOnce, FnMut per Box, Box, Box, rispettivamente. È stata aggiunta la possibilità di convertire le closure in puntatori a funzioni non sicure, e ora è possibile chiamare il macro dbg!() senza argomenti. È stata stabilizzata la libreria standard.

Per i dettagli:

• Nella nuova versione sono state aggiunte implementazioni dei trait Fn, FnOnce, FnMut per Box, Box, Box, rispettivamente.
  Ora il seguente codice funzionerà:
  fn foo(x: Box u8>) -> Vec {
  vec![1, 2, 3, 4].into_iter().map(x).collect()
  }

  Inoltre, è possibile chiamare una closure direttamente da Box:
  fn foo(x: Box) {
  x()
  }

• Ora le closure possono essere convertite in puntatori a funzioni unsafe.
  Attualmente, il seguente codice è valido:
  /// 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!();
  });
  }
  }

• È stata aggiunta la possibilità di chiamare il macro dbg!() senza argomenti.
  Se passi un'espressione a questa macro, essa ne mostrerà il risultato. Esempio:
  fn main() {
  let mut x = 0;

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

  dbg!(x);
  }

  Quando esegui questo codice vedrai:
  [src/main.rs:4] x == 1 = false
  [src/main.rs:8] x = 0

  Ora puoi scrivere così:
  fn main() {
  let condition = true;

  if condition {
  dbg!();
  }
  }

  Eseguendo questo codice vedrai:
  [src/main.rs:5]
  

• Alcune parti della libreria standard sono state stabilizzate.
  • Nuovi metodi per f32 e f64:
    • f32::copysign
    • f64::copysign

    Queste funzioni copiano il segno di un altro numero. Esempio:
    fn main() {
    assert_eq!(3.5_f32.copysign(-0.42), -3.5);
    }

  • Aggiunti nuovi metodi per i tipi Range
    • Range::contains
    • RangeFrom::contains
    • RangeTo::contains
    • RangeInclusive::contains
    • RangeToInclusive::contains

    Con questi metodi puoi facilmente verificare se un valore specifico è presente nella sequenza:
    fn main() {
    if (0..=10).contains(&5) {
    println!("Cinque è incluso da zero a dieci.");
    }
    }

  • Puoi trovare l'elenco completo delle API stabilizzate qui
• In questo aggiornamento, in Clippy (un programma che controlla il tuo codice per molti errori) è stata aggiunta una nuova verifica per drop_bounds. Questa verifica scatta quando imposti una restrizione: T: Drop — per funzioni generiche:
  fn foo(x: T) {}

  Avere un limite T: Drop è spesso un errore, poiché esclude subito alcuni tipi, come ad esempio u8. (Puoi leggere di più su questo) qui)

• Molte migliorie e correzioni sono state apportate a Cargo (il gestore pacchetti del linguaggio), la lista completa delle modifiche

Fonte: linux.org.ru