Rust 1.35

Das Entwicklerteam von Rust freut sich, die neue Version seiner Sprache vorzustellen: 1.35. Rust ist eine Programmiersprache, die es ermöglicht, zuverlässige und effiziente Programme zu schreiben.

Wenn Sie Rust bereits über rustup installiert haben, können Sie mit dem folgenden Befehl aktualisieren:
$ rustup update stable

Das Wichtigste an diesem Update ist die Implementierung der Trait Closures Fn, FnOnce, FnMut für Box, Box, Box. Die Möglichkeit, Closures in Zeiger auf unsichere Funktionen zu konvertieren, wurde hinzugefügt, der Aufruf des Makros dbg!() ist jetzt ohne Argumente möglich, und die Standardbibliothek wurde stabilisiert.

Im Detail:

• In der neuen Version wurden die Implementierungen der Traits Fn, FnOnce, FnMut für Box, Box, Box hinzugefügt.
  Jetzt wird folgender Code funktionieren:
  fn foo(x: Box u8>) -> Vec {
  vec![1, 2, 3, 4].into_iter().map(x).collect()
  }

  Außerdem können Sie Closures direkt aus Box aufrufen:
  fn foo(x: Box) {
  x()
  }

• Jetzt können Closures in Zeiger auf unsafe fn konvertiert werden.
  Jetzt ist folgender Code gültig:
  /// 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!();
  });
  }
  }

• Die Möglichkeit, das Makro dbg!() ohne Argumente aufzurufen, wurde hinzugefügt.
  Wenn Sie diesem Makro einen Ausdruck übergeben, gibt das Makro das Ergebnis aus. Beispiel:
  fn main() {
  let mut x = 0;

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

  dbg!(x);
  }

  Wenn Sie diesen Code ausführen, sehen Sie:
  [src/main.rs:4] x == 1 = false
  [src/main.rs:8] x = 0

  Jetzt können Sie folgendes schreiben:
  fn main() {
  let condition = true;

  if condition {
  dbg!();
  }
  }

  Wenn Sie diesen Code ausführen, sehen Sie:
  [src/main.rs:5]
  

• Einige Teile der Standardbibliothek wurden stabilisiert.
  • Neue Methoden für f32 und f64:
    • f32::copysign
    • f64::copysign

    Tatsächlich kopieren die Funktionen das Vorzeichen einer anderen Zahl. Beispiel:
    fn main() {
    assert_eq!(3.5_f32.copysign(-0.42), -3.5);
    }

  • Neue Methoden für Bereichs-Typen wurden hinzugefügt.
    • Range::contains
    • RangeFrom::contains
    • RangeTo::contains
    • RangeInclusive::contains
    • RangeToInclusive::contains

    Mit diesen Methoden können Sie leicht überprüfen, ob ein bestimmter Wert in einer Sequenz vorhanden ist:
    fn main() {
    if (0..=10).contains(&5) {
    println!("Fünf ist im Bereich von null bis zehn enthalten.");
    }
    }

  • Die vollständige Liste der stabilisierten APIs finden Sie. hier
• In diesem Update wurde in Clippy (einem Programm, das Ihren Code auf viele Fehler überprüft) eine neue Überprüfung für drop_bounds hinzugefügt. Diese Überprüfung wird ausgelöst, wenn Sie eine Einschränkung setzen: T: Drop — für generische Funktionen:
  fn foo(x: T) {}

  Eine Einschränkung T: Drop ist häufig ein Fehler, da dadurch sofort einige Typen wie z.B. u8 ausgeschlossen werden. (Mehr darüber kann gelesen werden) hier)

• Es wurde viel in Cargo (Paketmanager der Sprache) verbessert und korrigiert. vollständige Liste der Änderungen

Quelle: linux.org.ru