Rust 1.35

Ekipi i zhvilluesve të Rust është i lumtur të prezantojë versionin e ri të gjuhës së tij: 1.35. Rust është një gjuhë programimi që lejon të shkruani programe të besueshme dhe efikase.

Nëse e keni instaluar tashmë Rust përmes rustup, mund të përditësoni me komandën:
$ rustup update stable

E rëndësishme në këtë përditësim është implementimi i trait-ëve të mbylljes Fn, FnOnce, FnMut, për Box<dyn Fn>, Box<dyn FnOnce>, Box<dyn FnMut>, përkatësisht. Shtimi i mundësisë për të konvertuar mbylljet në tregues për funksione të pasigurta, thirrja e makrosë dbg!() tani është e mundur pa argumente, është stabilizuar biblioteka standarde.

Në detaje:

• Në versionin e ri janë shtuar implementimet e trait-ve Fn, FnOnce, FnMut, për Box<dyn Fn>, Box<dyn FnOnce>, Box<dyn FnMut>, përkatësisht.
  Tani ky kod do të funksionojë:
  fn foo(x: Box<dyn Fn(u8) -> u8>) -> Vec<u8> {
  vec![1, 2, 3, 4].into_iter().map(x).collect()
  }

  Gjithashtu, mund të thirret mbyllja direkt nga Box<dyn FnOnce>:
  fn foo(x: Box<dyn FnOnce()>) {
  x()
  }

• Tani mbylljet mund të konvertohen në tregues për unsafe fn.
  Aktualisht ky kod është valid:
  /// 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!();
  });
  }
  }

• Është shtuar mundësia e thirrjes së makrosë dbg!() pa argumente.
  Nëse i kaloni këtij makrosi një shprehje, makrosi do të nxjerrë rezultatin e saj. Shembull:
  fn main() {
  let mut x = 0;

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

  dbg!(x);
  }

  Kur të ekzekutoni këtë kod, do të shihni:
  [src/main.rs:4] x == 1 = false
  [src/main.rs:8] x = 0

  Tani mund të shkruani kështu:
  fn main() {
  let condition = true;

  if condition {
  dbg!();
  }
  }

  Kur të ekzekutoni këtë kod, do të shihni:
  [src/main.rs:5]
  

• Janë stabilizuar disa pjesë të bibliotekës standarde.
  • Metodat e reja për f32 dhe f64:
    • f32::copysign
    • f64::copysign

    Kështu, funksionet kopjojnë shenjën nga një numër tjetër. Shembull:
    fn main() {
    assert_eq!(3.5_f32.copysign(-0.42), -3.5);
    }

  • Janë shtuar metoda të reja për tipet Range.
    • Range::contains
    • RangeFrom::contains
    • RangeTo::contains
    • RangeInclusive::contains
    • RangeToInclusive::contains

    Me këto metoda mund të kontrolloni lehtësisht nëse një vlerë e caktuar ndodhet në një sekuencë:
    fn main() {
    if (0..=10).contains(&5) {
    println!("Pesë është i përfshirë nga zero në dhjetë.");
    }
    }

  • Lista e plotë e API-ve të stabilizuar mund të gjendet. këtu
• Në këtë përditësim, në Clippy (Kjo është një program që kontrollon kodin tuaj për shumë gabime) është shtuar një kontroll i ri për drop_bounds. Ky kontroll aktivizohet kur vendosni kufizim: T: Drop — për funksione të përgjithshme:
  fn foo<T: Drop>(x: T) {}

  Të kesh një kufizim T: Drop shpesh është një gabim, pasi përjashton menjëherë disa tipe si, për shembull, u8. (Më shumë rreth kësaj mund të lexoni) këtu)

• Shumë gjëra janë përmirësuar dhe korrigjuar në Cargo (menaxheri i paketave të gjuhës), lista e plotë e ndryshimeve

Burimi: linux.org.ru