Rust 1.35

Rusts utvecklingsteam är glada att presentera den nya versionen av sitt språk: 1.35. Rust är ett programmeringsspråk som möjliggör att skriva pålitliga och effektiva program.

Om du redan har installerat Rust via rustup kan du uppdatera med kommandot:
$ rustup update stable

Huvudpunkten i uppdateringen är implementeringen av traitarna Fn, FnOnce, FnMut för Box<dyn Fn>, Box<dyn FnOnce>, Box<dyn FnMut>, respektive. Dessutom har möjligheten att konvertera closures till pekare på osäkra funktioner lagts till och makrot dbg!() kan nu anropas utan argument. Stabilisering av standardbiblioteket har genomförts.

Detaljer:

• I den nya versionen har implementationer av traitarna Fn, FnOnce, FnMut lagts till för Box<dyn Fn>, Box<dyn FnOnce>, Box<dyn FnMut>, respektive.
  Nu kommer följande kod att fungera:
  fn foo(x: Box<dyn Fn(u8) -> u8>) -> Vec<u8> {
  vec![1, 2, 3, 4].into_iter().map(x).collect()
  }

  Dessutom kan closures nu kallas direkt från Box<dyn FnOnce>:
  fn foo(x: Box<dyn FnOnce()>) {
  x()
  }

• Nu kan closures konverteras till pekare på unsafe fn.
  Nu är följande kod giltig:
  /// 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!();
  });
  }
  }

• Möjligheten att anropa makrot dbg!() utan argument har lagts till.
  Om något uttryck ges till detta makro kommer det att skriva ut resultatet. Exempel:
  fn main() {
  let mut x = 0;

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

  dbg!(x);
  }

  När sådan kod körs ser du:
  [src/main.rs:4] x == 1 = false
  [src/main.rs:8] x = 0

  Nu kan du skriva så här:
  fn main() {
  let condition = true;

  if condition {
  dbg!();
  }
  }

  När sådana kod körs ser du:
  [src/main.rs:5]
  

• Vissa delar av standardbiblioteket har stabiliserats.
  • Nya metoder för f32 och f64:
    • f32::copysign
    • f64::copysign

    Funktionerna kopierar i själva verket tecknet från ett annat tal. Exempel:
    fn main() {
    assert_eq!(3.5_f32.copysign(-0.42), -3.5);
    }

  • Nya metoder för Range-typer har lagts till.
    • Range::contains
    • RangeFrom::contains
    • RangeTo::contains
    • RangeInclusive::contains
    • RangeToInclusive::contains

    Med dessa metoder kan man enkelt kontrollera om ett viss värde finns i en sekvens:
    fn main() {
    if (0..=10).contains(&5) {
    println!("Five is included in zero to ten.");
    }
    }

  • Den fullständiga listan över stabiliserade API:er kan du hitta ). Ett typiskt exempel på användning:
• I denna uppdatering har Clippy (ett program som kontrollerar din kod för många fel) fått en ny kontroll för drop_bounds. Denna kontroll aktiveras när du sätter en begränsning: T: Drop — för generiska funktioner:
  fn foo<T: Drop>(x: T) {}

  Att ha begränsningen T: Drop är oftast ett misstag, eftersom det omedelbart utesluter vissa typer, som exempelvis u8. (Mer om detta kan läsas.) ). Ett typiskt exempel på användning:)

• Många förbättringar och korrigeringar har gjorts i Cargo (pakethanteraren för språket). fullständig ändringslista

Källa: linux.org.ru