Rust 1.32 Release

Das Rust-Entwicklungsteam freut sich, die Veröffentlichung einer neuen Version von Rust, 1.32.0, bekannt zu geben. Rust ist eine Programmiersprache, mit der jeder zuverlässige und effiziente Software erstellen kann.


Wenn Sie eine frühere Version von Rust mit rustup installiert rustup , müssen Sie nur Folgendes tun, um Rust auf Version 1.32.0 zu aktualisieren:


 $ rustup update stable 

Wenn Sie rustup noch nicht installiert rustup , können Sie es von der entsprechenden Seite unserer Website installieren . Detaillierte Versionshinweise für Rust 1.32.0 sind auf GitHub verfügbar.


Ein rustup Hinweis: rustup wurden mehrere neue rustup Releases rustup ! Um rustup selbst zu aktualisieren, führen Sie rustup self update .

Was ist in der stabilen Version 1.32.0 enthalten


Rust 1.32.0 hat mehrere lebensverbessernde Verbesserungen erhalten, den Standardspeicher-Allokator geändert und mehr Funktionen konstant gemacht. Lesen Sie weiter unten über diese Änderungen oder lesen Sie mehr in den Versionshinweisen .


Dbg-Makro


Beginnen wir mit einer lebensverbessernden Verbesserung. Verwenden Sie Print-Debugging? Wenn dies der Fall ist und Sie während der Arbeit am Code einen Wert drucken möchten, müssen Sie Folgendes tun:


 let x = 5; println!("{:?}", x); //    println!("{:#?}", x); 

Dies ist nicht das größte Hindernis, das die Entwicklung verlangsamt, aber es erfordert zu viel Aufwand, um einfach die Ausgabe des x Werts zu debuggen. Außerdem wird der Kontext hier nicht berücksichtigt. Wenn Sie mehrere solcher println! s wird es schwierig zu bestimmen, worauf sich die Ausgabe bezieht, bis Sie selbst jedem Aufruf Kontextinformationen hinzufügen, was noch mehr Arbeit erfordert.


Zu diesem Zweck haben wir in Rust 1.32.0 ein neues Makro dbg hinzugefügt! ::


 fn main() { let x = 5; dbg!(x); } 

Nach dem Starten dieses Programms sehen Sie:


 [src/main.rs:4] x = 5 

Zusammen mit dem Variablennamen und seinem Wert werden der Dateiname und die dbg! angezeigt, unter der der dbg! Aufruf durchgeführt wurde dbg! .


Darüber hinaus println! druckt auf Standardausgabe, daher ist es besser, eprintln! zum Drucken in den Standardfehlerstrom. Makro dbg! gibt zu Recht an stderr .


Dies funktioniert auch in schwierigen Fällen. Betrachten Sie ein Beispiel für eine faktorielle Implementierung:


 fn factorial(n: u32) -> u32 { if n <= 1 { n } else { n * factorial(n - 1) } } 

Um es zu debuggen, können wir eprintln! ::


 fn factorial(n: u32) -> u32 { eprintln!("n: {}", n); if n <= 1 { eprintln!("n <= 1"); n } else { let n = n * factorial(n - 1); eprintln!("n: {}", n); n } } 

Wir wollen bei jeder Iteration n ausgeben und den Kontext jedes Zweigs sehen. Für factorial(4) wird Folgendes ausgegeben:


 n: 4 n: 3 n: 2 n: 1 n <= 1 n: 2 n: 6 n: 24 

Dies ist akzeptabel, aber nicht besonders gut. Vielleicht könnten wir daran arbeiten, die Ausgabe von Kontextinformationen zu verbessern, um die Schlussfolgerung klarer zu machen. Aber anstatt unseren Code zu debuggen, werden wir den Debugging-Code verbessern.


Betrachten Sie das gleiche Beispiel mit dbg! ::


 fn factorial(n: u32) -> u32 { if dbg!(n <= 1) { dbg!(1) } else { dbg!(n * factorial(n - 1)) } } 

Wir haben einfach ein Makro mit jedem der Ausdrücke umbrochen, die wir ausgeben möchten. Als Ergebnis erhalten wir:


 [src/main.rs:3] n <= 1 = false [src/main.rs:3] n <= 1 = false [src/main.rs:3] n <= 1 = false [src/main.rs:3] n <= 1 = true [src/main.rs:4] 1 = 1 [src/main.rs:5] n * factorial(n - 1) = 2 [src/main.rs:5] n * factorial(n - 1) = 6 [src/main.rs:5] n * factorial(n - 1) = 24 [src/main.rs:11] factorial(4) = 24 

Da das Makro dbg! gibt im Gegensatz zu eprintln! den Debug-Wert selbst eprintln! Wenn () , müssen wir keine Änderungen an der Struktur unseres Codes vornehmen. Zusätzlich erhalten wir eine viel nützlichere Schlussfolgerung.


Wir haben einem so kleinen Makro viel Aufmerksamkeit geschenkt, da wir hoffen, dass es Ihren Debugging-Prozess vereinfacht. Natürlich arbeiten wir auch weiterhin an der Unterstützung von gdb und Co.


jemalloc wird jemalloc


Es war einmal, Rust hatte eine große Laufzeit ähnlich wie Erlang. Für ihn wurde jemalloc anstelle des Systemzuweisers gewählt, weil es oft produktiver war. Allmählich wurden wir die Laufzeit immer mehr los und am Ende wurde fast alles gelöscht, aber jemalloc blieb. Wir hatten keine Möglichkeit, einen benutzerdefinierten Allokator auszuwählen, und konnten daher jemalloc nicht vollständig entfernen, um denjenigen, die ihn benötigten, keinen Schaden zuzufügen.


Darüber hinaus bezog sich die Behauptung, dass jemalloc immer der Standardzuweiser war, hauptsächlich auf die UNIX-Welt, da dies standardmäßig nur auf einigen Plattformen der jemalloc war. Insbesondere das Ziel von MSVC unter Windows ist seit langem die Verwendung eines Systemzuordners.


Obwohl jemalloc normalerweise eine gute Leistung aufweist, ist dies nicht immer der Fall. Darüber hinaus werden jeder ausführbaren Datei etwa 300 Kilobyte hinzugefügt. Wir haben auch viele andere Probleme mit jemalloc angehäuft. Im Allgemeinen ist es seltsam, dass die Systemsprache standardmäßig nicht den Systemzuordner verwendet.


Aus diesen Gründen planten wir, sobald Rust 1.28 die Möglichkeit zur Auswahl eines globalen jemalloc , auf den Standardsystem- jemalloc und jemalloc als externe Bibliothek bereitzustellen. In Rust 1.32 haben wir diese Arbeit endlich abgeschlossen, und jetzt verwendet Ihr Programm standardmäßig den Systemzuweiser.


Wenn Sie jemalloc weiterhin verwenden möchten, verwenden Sie die jemallocator-Bibliothek . Cargo.toml in Cargo.toml :


 jemallocator = "0.1.8" 

Und in der Stammdatei Ihres Projekts:


 #[global_allocator] static ALLOC: jemallocator::Jemalloc = jemallocator::Jemalloc; 

Das ist alles! Wenn Sie jemalloc nicht benötigen, müssen Sie es nicht mehr verwenden. Wenn Sie es jedoch benötigen, wird das Problem mit wenigen Codezeilen gelöst.


Letzte Verbesserungen des Modulsystems


In den letzten beiden Versionen haben wir über verschiedene Verbesserungen des Modulsystems gesprochen. In 1.32.0 und der Ausgabe 2018 haben wir die neueste Änderung hinzugefügt. Es wird als "einheitliche Pfade" bezeichnet und ermöglicht es Ihnen, mit Importpfaden auf die gleiche Weise wie mit anderen Pfaden zu arbeiten, die zuvor falsch funktionierten. Zum Beispiel:


 enum Color { Red, Green, Blue } use Color::*; 

Dieser Code wurde zuvor noch nicht kompiliert, da die verwendeten Pfade mit super , self oder crate . Dank des Compilers, der konsistente Pfade unterstützt, funktioniert dieser Code jetzt und macht das, was Sie erwarten: Importieren von Varianten der oben definierten Farbaufzählung.


Diese Änderung vervollständigt unsere Überarbeitung des Modulsystems. Wir wünschen Ihnen viel Spaß mit dem vereinfachten System!


Makroverbesserungen


Rust 1.32.0 hat mehrere Makroverbesserungen veröffentlicht. Zunächst wurde ein neuer Literalfragmentspezifizierer hinzugefügt:


 macro_rules! m { ($lt:literal) => {}; } fn main() { m!("some string literal"); } 

Das literal wird Literalen eines beliebigen Typs zugeordnet: Zeichenfolge, Zahl und Zeichen.


macro_rules Sie in der macro_rules 2018 auch macro_rules ? ::


 macro_rules! bar { ($(a)?) => {} } 

Fragment mit ? Ein Vorkommen von Null oder Eins wird abgeglichen, genauso wie ein Fragment mit * bereits mit Vorkommen von "Null oder Mehr" und mit + - einem oder mehreren Vorkommen übereinstimmt.


Stabilisierung der Standardbibliothek


Makro dbg! , die wir oben bereits beschrieben haben, ist zu einer wichtigen Ergänzung der Standardbibliothek geworden. Zusätzlich wurden 19 Funktionen konstant gemacht und alle numerischen primitiven Typen erhielten Konvertierungsfunktionen in ein Bytearray und umgekehrt mit der angegebenen Bytereihenfolge. Es gibt sechs Funktionen mit den Namen to_<endian>_bytes und from_<endian>_bytes , wobei <endian> lautet:


  • ne - native Ordnung (native Endianness)
  • le - order von junior bis senior (little endian)
  • be - order vom ältesten zum jüngsten (big endian)

Weitere Informationen finden Sie in den Versionshinweisen.


Frachtverbesserungen


Cargo hat den Alias Cargo c für den Cargo Check- Befehl erhalten und ermöglicht nun die Verwendung von Benutzernamen in den Repository-URLs .


Weitere Informationen finden Sie in den Versionshinweisen.


Entwickler 1.32.0


Viele Leute haben zusammen Rust 1.32.0 erstellt. Ohne jeden von Ihnen hätten wir die Arbeit nicht abschließen können. Vielen Dank!


Von einem Übersetzer: Ich bedanke mich ganz besonders bei den Mitgliedern der Rustycrate-Community und persönlich bei @dashadee und ozkriff für ihre Hilfe bei der Übersetzung und beim Korrekturlesen.

Source: https://habr.com/ru/post/de436854/


All Articles