Rust 1.35

Echipa de dezvoltare Rust este încântată să prezinte noua versiune a limbajului său: 1.35. Rust este un limbaj de programare care permite scrierea de programe fiabile și eficiente.

Dacă ai deja Rust instalat prin rustup, poți actualiza cu comanda:
$ rustup update stable

Cel mai important în actualizare este implementarea trăsăturilor de closure Fn, FnOnce, FnMut pentru Box, Box, Box, respectiv. A fost adăugată posibilitatea de a converti closures în pointeri la funcții nesigure, apelarea macro-ului dbg!() acum este posibilă fără argumente, iar biblioteca standard a fost stabilizată.

Iată detaliile:

• În noua versiune au fost adăugate implementări ale trăsăturilor Fn, FnOnce, FnMut pentru Box, Box, Box, respectiv.
  Acum astfel de cod va funcționa:
  fn foo(x: Box u8>) -> Vec {
  vec![1, 2, 3, 4].into_iter().map(x).collect()
  }

  De asemenea, poți apela closure direct din Box:
  fn foo(x: Box) {
  x()
  }

• Acum closures pot fi convertite în pointeri către funcții nesigure.
  Acum astfel de cod este 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!();
  });
  }
  }

• A fost adăugată posibilitatea de a apela macro-ul dbg!() fără argumente.
  Dacă îi transmiți această macro vreo expresie, macro-ul va afișa rezultatul acesteia. Exemplu:
  fn main() {
  let mut x = 0;

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

  dbg!(x);
  }

  Când rulezi acest cod vei vedea:
  [src/main.rs:4] x == 1 = false
  [src/main.rs:8] x = 0

  Acum poți scrie așa:
  fn main() {
  let condition = true;

  if condition {
  dbg!();
  }
  }

  Când rulezi acest cod vei vedea:
  [src/main.rs:5]
  

• Au fost stabilizate anumite părți ale bibliotecii standard
  • Metode noi pentru f32 și f64:
    • f32::copysign
    • f64::copysign

    Aceste funcții copiază semnul unui alt număr. Exemplu:
    fn main() {
    assert_eq!(3.5_f32.copysign(-0.42), -3.5);
    }

  • Au fost adăugate metode noi pentru tipurile Range
    • Range::contains
    • RangeFrom::contains
    • RangeTo::contains
    • RangeInclusive::contains
    • RangeToInclusive::contains

    Cu aceste metode poți verifica cu ușurință dacă o anumită valoare există în secvență:
    fn main() {
    if (0..=10).contains(&5) {
    println!("Cinci este inclus în zero până la zece.");
    }
    }

  • Lista completă a API-urilor stabilizate o poți găsi aici
• În această actualizare, în Clippy (Aceasta este o aplicație care verifică codul tău pentru multe erori) a fost adăugat un nou control pentru drop_bounds. Acest control se activează când pui o restricție: T: Drop — pentru funcțiile generice:
  fn foo(x: T) {}

  A avea o restricție T: Drop este adesea o eroare, deoarece exclude imediat anumite tipuri, cum ar fi u8. (Puteți citi mai multe despre asta aici)

• Multe îmbunătățiri și corecții au fost aduse în Cargo (managerul de pachete al limbajului) lista completă a modificărilor

Sursa: linux.org.ru