Rust 1.35

Het Rust-ontwikkelingsteam is blij om de nieuwe versie van hun taal te introduceren: 1.35. Rust is een programmeertaal die het mogelijk maakt om betrouwbare en efficiënte programma's te schrijven.

Als je Rust al via rustup hebt geïnstalleerd, kun je bijwerken met het commando:
$ rustup update stable

Het belangrijkste in deze update is de implementatie van de closure traits Fn, FnOnce, FnMut, voor Box<dyn Fn>, Box<dyn FnOnce>, Box<dyn FnMut>, respectievelijk. Er is een mogelijkheid toegevoegd om closures om te zetten naar pointers naar onveilige functies, en het aanroepen van de macro dbg!() is nu mogelijk zonder argumenten. Er is stabilisatie van de standaardbibliotheek uitgevoerd.

Wat de details betreft:

• In de nieuwe versie zijn implementaties van de traits Fn, FnOnce, FnMut toegevoegd voor Box<dyn Fn>, Box<dyn FnOnce>, Box<dyn FnMut>, respectievelijk.
  Nu zal deze code werken:
  fn foo(x: Box<dyn Fn(u8) -> u8>) -> Vec<u8> {
  vec![1, 2, 3, 4].into_iter().map(x).collect()
  }

  Je kunt ook de closure rechtstreeks vanuit Box<dyn FnOnce> aanroepen:
  fn foo(x: Box<dyn FnOnce()>) {
  x()
  }

• Nu kunnen closures worden omgezet naar pointers naar unsafe fn.
  Momenteel is deze code geldig:
  /// 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!();
  });
  }
  }

• Er is een mogelijkheid toegevoegd om de macro dbg!() zonder argumenten aan te roepen.
  Als je deze macro een uitdrukking doorgeeft, zal de macro het resultaat afdrukken. Voorbeeld:
  fn main() {
  let mut x = 0;

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

  dbg!(x);
  }

  Bij het uitvoeren van deze code zie je:
  [src/main.rs:4] x == 1 = false
  [src/main.rs:8] x = 0

  Je kunt nu het volgende schrijven:
  fn main() {
  let condition = true;

  if condition {
  dbg!();
  }
  }

  Bij het uitvoeren van deze code zie je:
  [src/main.rs:5]
  

• Sommige delen van de standaardbibliotheek zijn gestabiliseerd.
  • Nieuwe methoden voor f32 en f64:
    • f32::copysign
    • f64::copysign

    De functies kopiëren feitelijk het teken van een ander getal. Voorbeeld:
    fn main() {
    assert_eq!(3.5_f32.copysign(-0.42), -3.5);
    }

  • Er zijn nieuwe methoden toegevoegd voor Range-types.
    • Range::contains
    • RangeFrom::contains
    • RangeTo::contains
    • RangeInclusive::contains
    • RangeToInclusive::contains

    Met deze methoden kun je eenvoudig controleren of een bepaalde waarde in een reeks zit:
    fn main() {
    if (0..=10).contains(&5) {
    println!("Vijf is inbegrepen van nul tot tien.");
    }
    }

  • Een volledige lijst van gestabiliseerde API's kun je vinden. here
• In deze update is er in Clippy (een programma dat je code op veel fouten controleert) een nieuwe controle toegevoegd voor drop_bounds. Deze controle wordt uitgevoerd wanneer je een beperking instelt: T: Drop — voor generieke functies:
  fn foo<T: Drop>(x: T) {}

  Het hebben van een beperking T: Drop is vaak een fout, omdat hierdoor bepaalde types zoals u8 worden uitgesloten. (Meer hierover kun je lezen) here)

• Er zijn veel verbeteringen en correcties aangebracht in Cargo (de pakketbeheerder van de taal), volledige lijst van wijzigingen

Bron: linux.org.ru