Rust 1.35

Rust udviklerteam er glade for at præsentere den nye version af deres sprog: 1.35. Rust er et programmeringssprog, der muliggør skrivning af pålidelige og effektive programmer.

Hvis du allerede har installeret Rust via rustup, kan du opdatere med kommandoen:
$ rustup update stable

Det vigtigste i opdateringen er implementeringen af træk ved lukningerne Fn, FnOnce, FnMut til henholdsvis Box<dyn Fn>, Box<dyn FnOnce>, Box<dyn FnMut>. Det er nu muligt at konvertere lukninger til pegepinde til usikre funktioner, og kaldet af makroen dbg!() kan nu gøres uden argumenter, og stabiliseringen af standardbiblioteket er blevet gennemført.

Til detaljerne:

• I den nye version er der tilføjet implementeringer af træk ved Fn, FnOnce, FnMut til henholdsvis Box<dyn Fn>, Box<dyn FnOnce>, Box<dyn FnMut>.
  Nu vil sådan kode fungere:
  fn foo(x: Box<dyn Fn(u8) -> u8>) -> Vec<u8> {
  vec![1, 2, 3, 4].into_iter().map(x).collect()
  }

  Desuden kan man kalde lukningen direkte fra Box<dyn FnOnce>:
  fn foo(x: Box<dyn FnOnce()>) {
  x()
  }

• Nu kan lukninger konverteres til pegepinde til unsafe fn.
  Nu er sådan kode gyldig:
  /// 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!();
  });
  }
  }

• Muligheden for at kalde makroen dbg!() uden argumenter er blevet tilføjet.
  Hvis du giver denne makro et udtryk, vil makroen vise dets resultat. Eksempel:
  fn main() {
  let mut x = 0;

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

  dbg!(x);
  }

  Når du kører denne kode, vil du se:
  [src\/main.rs:4] x == 1 = false
  [src\/main.rs:8] x = 0

  Nu kan du skrive sådan her:
  fn main() {
  let condition = true;

  if condition {
  dbg!();
  }
  }

  Når denne kode køres, vil du se:
  [src\/main.rs:5]
  

• Nogle dele af standardbiblioteket er blevet stabiliseret
  • Nye metoder til f32 og f64:
    • f32::copysign
    • f64::copysign

    Disse funktioner kopierer tegnet fra et andet tal. Eksempel:
    fn main() {
    assert_eq!(3.5_f32.copysign(-0.42), -3.5);
    }

  • Nye metoder er blevet tilføjet til Range-typer
    • Range::contains
    • RangeFrom::contains
    • RangeTo::contains
    • RangeInclusive::contains
    • RangeToInclusive::contains

    Med disse metoder kan du nemt kontrollere, om en bestemt værdi findes i sekvensen:
    fn main() {
    if (0..=10).contains(&5) {
    println!("Five is included in zero to ten.");
    }
    }

  • Den komplette liste af stabiliserede API'er kan findes her
• I denne opdatering har Clippy (et program, der checker din kode for mange fejl) tilføjet en ny kontrol for drop_bounds. Denne kontrol aktiveres, når du angiver begrænsningen: T: Drop — for generiske funktioner:
  fn foo<T: Drop>(x: T) {}

  At have begrænsningen T: Drop er oftest en fejl, da den straks udelukker visse typer som f.eks. u8. (Du kan læse mere om det) her)

• Der er foretaget mange forbedringer og rettelser i Cargo (sprogpakkeadministratoren), den fulde ændringsliste

Kilde: linux.org.ru