Rost 1.35

Rust-utvecklingsteamet är glada att kunna presentera en ny version av sitt språk: 1.35. Rust är ett programmeringsspråk som låter dig skriva pålitliga och effektiva program.

Om du redan har Rust installerat via rustup kan du uppdatera med kommandot:
$ rustup uppdatering stabil

Huvudsaken i uppdateringen är implementeringen av stängningsegenskaperna Fn, FnOnce, FnMut, for Box ,Låda ,Låda , respektive. Att lägga till möjligheten att casta stängningar till pekare till osäkra funktioner, anropa makrot dbg!() är nu möjligt utan argument, och standardbiblioteket har stabiliserats.

Till detaljerna:

• I den nya versionen lade vi till implementeringar av egenskaperna Fn, FnOnce, FnMut för Box ,Låda ,Låda , respektive.
  Nu kommer den här koden att fungera:
  fn foo(x: Box u8>) -> Vec {
  vec![1, 2, 3, 4].into_iter().map(x).collect()
  }

  Du kan också ringa en nedläggning direkt från Box :
  fn foo(x: Box ) {
  x()
  }

• Stängningar kan nu kastas till pekare till osäker fn.
  Nu är denna kod giltig:
  /// Säkerhetsinvarianterna är de för den `osäkra fn`-pekaren som passerats.
  osäker fn call_unsafe_fn_ptr(f: osäker fn()) {
  f()
  }

  fn main() {
  // SÄKERHET: Det finns inga invarianter.
  // Stängningen är statiskt förhindrad från att göra osäkra saker.
  osäker {
  call_unsafe_fn_ptr(|| {
  dbg!();
  });
  }
  }

• Lade till möjligheten att anropa makrot dbg!() utan argument.
  Om du skickar något uttryck till detta makro kommer makrot att skriva ut resultatet. Exempel:
  fn main() {
  låt mut x = 0;

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

  dbg!(x);
  }

  När du kör den här koden ser du:
  [src/main.rs:4] x == 1 = falskt
  [src/main.rs:8] x = 0

  Nu kan du skriva så här:
  fn main() {
  låt villkor = sant;

  if condition {
  dbg!();
  }
  }

  När du kör den här koden ser du:
  [src/main.rs:5]
  

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

    Egentligen kopierar funktioner tecknet för ett annat tal. Exempel:
    fn main() {
    assert_eq!(3.5_f32.copysign(-0.42), -3.5);
    }

  • Lade till nya metoder för intervalltyper
    • Range::innehåller
    • RangeFrom::innehåller
    • RangeTo::innehåller
    • RangeInclusive::innehåller
    • RangeToInclusive::innehåller

    Med dessa metoder kan du enkelt kontrollera om ett visst värde är i en sekvens:
    fn main() {
    if (0..=10).contains(&5) {
    println!("Fem ingår i noll till tio.");
    }
    }

  • Du kan hitta en komplett lista över stabiliserade API:er här
• I den här uppdateringen lade Clippy (det här är ett program som kontrollerar din kod för många fel) en ny kontroll för drop_bounds. Denna kontroll utlöses när du ställer in en begränsning: T: Släpp - för generaliserade funktioner:
  fn foo (x:T){}

  Att ha en T: Släppbegränsning är oftast ett misstag, eftersom vissa typer omedelbart utesluts, till exempel u8 (Du kan läsa mer om detta här)

• Många förbättringar och korrigeringar i Cargo (språkpakethanterare), fullständig lista över ändringar

Källa: linux.org.ru