Rust 1.35

Rusti arendajate meeskond on rõõmuga esitlemas oma keele uut versiooni: 1.35. Rust on programmeerimiskeel, mis võimaldab kirjutada usaldusväärseid ja efektiivseid programme.

Kui Rust on juba installitud rustupi kaudu, saate värskendada käsuga:
$ rustup update stable

Uuenduse peamine eesmärk on rakendada sulgude trait'e Fn, FnOnce, FnMut vastavalt Box, Box, Box. Lisatud on võimalus viia sulgude tüübid üle ohtlike funktsioonide näidikutele, samuti on nüüd võimalik kutsuda makro dbg!() ilma argumentideta, standardteeki stabiliseerimine on toimunud.

Detailidest:

• Uues versioonis on lisatud trait'ide Fn, FnOnce, FnMut rakendused Box, Box, Box jaoks.
  Nüüd töötab selline kood:
  fn foo(x: Box u8>) -> Vec {
  vec![1, 2, 3, 4].into_iter().map(x).collect()
  }

  Samuti saab sulgude funktsiooni otse Box seest kutsuda:
  fn foo(x: Box) {
  x()
  }

• Nüüd saab sulgudest teha viiteid ohtlikele fn-dele.
  Praegu on selline kood kehtiv:
  /// 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!();
  });
  }
  }

• Makro dbg!() kutse ilma argumentideta on nüüd lubatud.
  Kui sellele makrole mingit väljendit edastada, siis makro väljastab selle tulemuse. Näide:
  fn main() {
  let mut x = 0;

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

  dbg!(x);
  }

  Selle koodi käivitamisel näete:
  [src/main.rs:4] x == 1 = false
  [src/main.rs:8] x = 0

  Nüüd saate kirjutada järgmiselt:
  fn main() {
  let condition = true;

  if condition {
  dbg!();
  }
  }

  Selle koodi täitmisel näete:
  [src/main.rs:5]
  

• Mõned osad standardraamatukogust on stabiliseeritud
  • Uued meetodid f32 ja f64 jaoks:
    • f32::copysign
    • f64::copysign

    Need funktsioonid kopeerivad teise arvu märgi. Näide:
    fn main() {
    assert_eq!(3.5_f32.copysign(-0.42), -3.5);
    }

  • Uued meetodid Range tüüpide jaoks
    • Range::contains
    • RangeFrom::contains
    • RangeTo::contains
    • RangeInclusive::contains
    • RangeToInclusive::contains

    Nende meetoditega on lihtne kontrollida, kas teatud väärtus on järjestuses:
    fn main() {
    if (0..=10).contains(&5) {
    println!("Viis on nullist kümneni kaasatud.");
    }
    }

  • Täieliku stabiliseeritud API loendi leiate siin
• Selles uuenduses, Clippys (programmis, mis kontrollib teie koodi mitmete vigade suhtes) on lisatud uus kontroll drop_bounds jaoks. See kontroll aktiveerub, kui seadistate piirangu: T: Drop — geneeriliste funktsioonide jaoks:
  fn foo(x: T) {}

  T: Drop piirang on sageli viga, kuna see välistab kohe mõned tüübid, nagu näiteks u8. (Kuidas selle kohta rohkem lugeda) siin)

• Cargo (keele paketihaldur) on saanud palju parandusi ja täiustusi. täielik muudatuste nimekiri

Allikas: linux.org.ru