Rust 1.35

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

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

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

Entriamo nei dettagli:

• Nella nuova versione sono state aggiunte le implementazioni dei trait Fn, FnOnce, FnMut, per Box, Box, Box, rispettivamente.
  Ora questo 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 unsafe fn.
  Attualmente, questo 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 a questo macro si passa un'espressione, il macro 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 in questo modo:
  fn main() {
  let condition = true;

  if condition {
  dbg!();
  }
  }

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

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

    Queste funzioni copiano il segno da 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 è facile 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 un vincolo: T: Drop — per le funzioni generiche:
  fn foo(x: T) {}

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

• Molto è stato migliorato e corretto in Cargo (il gestore di pacchetti del linguaggio), l'elenco completo delle modifiche

Fonte: linux.org.ru