Veröffentlichung der Programmiersprache Rust 1.61

Die Veröffentlichung der allgemeinen Programmiersprache Rust 1.61, die ursprünglich von Mozilla entwickelt wurde und nun unter dem Patronat der unabhängigen Non-Profit-Organisation Rust Foundation weiterentwickelt wird, ist erfolgt. Die Sprache legt einen Schwerpunkt auf sichere Speicherverwaltung und bietet Werkzeuge zur Erreichung hoher Parallelität bei der Ausführung von Aufgaben, ohne dabei auf einen Garbage Collector oder umfangreiche Laufzeitumgebungen zurückgreifen zu müssen. Die Laufzeit beschränkt sich auf grundlegende Initialisierung und die Unterstützung der Standardbibliothek.

Die Speicherverwaltungsmethoden in Rust befreien Entwickler von Fehlern beim Umgang mit Zeigern und schützen vor Problemen, die durch die Programmierung auf niedriger Ebene entstehen, wie z.B. den Zugriff auf freigegebenen Speicher, Dereferenzierung von Nullzeigern, Pufferüberläufe usw. Zur Verteilung von Bibliotheken, zur Gewährleistung des Builds und zum Management von Abhängigkeiten wird der Paketmanager Cargo entwickelt. Für die Bereitstellung von Bibliotheken wird das Repository crates.io unterstützt.

Die sichere Handhabung von Speicher in Rust wird während der Kompilierung durch die Überprüfung von Referenzen, das Verfolgen des Besitztums von Objekten, das Management der Lebensdauer von Objekten (Sichtbarkeitsbereiche) und die Bewertung der Korrektheit des Zugriffs auf den Speicher zur Laufzeit sichergestellt. Rust bietet außerdem Mechanismen zum Schutz vor ganzzahligen Überläufen, erfordert die verpflichtende Initialisierung von Variablenwerten vor der Verwendung, behandelt Fehler in der Standardbibliothek effektiver, implementiert das Konzept der Unveränderlichkeit (immutable) von Referenzen und Variablen standardmäßig und bietet eine starke statische Typisierung zur Minimierung logischer Fehler.

Hauptneuheiten:

• Es wurde die Möglichkeit eingeführt, eigene Rückgabecodes aus der Funktion main zu definieren. Ursprünglich konnte die Funktion main in Rust nur den Typ „()“ (Unit) zurückgeben, was immer auf einen erfolgreichen Abschluss hinwies, es sei denn, der Entwickler hatte explizit die Funktion „process::exit(code)“ aufgerufen. Mit Rust 1.26 wurde durch die Einführung des instabilen Traits Termination in der Funktion main die Rückgabe von Werten „Ok“ und „Err“ ermöglicht, die den Codes EXIT_SUCCESS und EXIT_FAILURE in C-Programmen entsprechen. In Rust 1.61 wurde der Trait Termination stabilisiert, und zur Darstellung eines spezifischen Rückgabecodes wurde ein separater Typ ExitCode vorgeschlagen, der plattformspezifische Rückgabewerte abstrahiert und sowohl die vordefinierten Konstanten SUCCESS und FAILURE als auch die Methode From zur Rückgabe beliebiger Rückgabecodes bereitstellt. use std::process::ExitCode; fn main() -> ExitCode { if !check_foo() { return ExitCode::from(42); } ExitCode::SUCCESS }
• Zusätzliche Funktionen, die mit der Aussage „const fn“ definiert wurden, können nun nicht nur wie gewöhnliche Funktionen aufgerufen, sondern auch in jedem Kontext anstelle von Konstanten verwendet werden. Diese Funktionen werden zur Compile-Zeit berechnet und nicht zur Laufzeit, weshalb sie bestimmten Einschränkungen unterliegen, wie zum Beispiel dem Lesen nur aus Konstanten. In der neuen Version sind innerhalb von const-Funktionen grundlegende Operationen mit Funktionszeigern erlaubt (es ist erlaubt, Zeiger zu erstellen, zu übertragen und zu casten, aber nicht, Funktionen über einen Zeiger aufzurufen); Typbeschränkungen für generische Parameter von const-Funktionen, wie z. B. T: Copy; dynamisch dispatchbare Typen (dyn Trait); impl Trait-Typen für Argumente und Rückgabewerte von Funktionen.
• Die Deskriptoren für die Streams Stdin, Stdout und Stderr in std::io haben jetzt eine statische Lebensdauer („'static“) beim Sperren, was es ermöglicht, Konstrukte wie „let out = std::io::stdout().lock();“ zu verwenden, um den Deskriptor zu erhalten und die Sperre in einer einzigen Anweisung zu setzen.
• Eine neue Reihe von APIs wurde stabilisiert und in die stabile Version überführt, einschließlich stabilisierter Methoden und Implementierungen von Traits:
  • Pin::static_mut
  • Pin::static_ref
  • Vec::retain_mut
  • VecDeque::retain_mut
  • Write für Cursor
  • std::os::unix::net::SocketAddr::from_pathname
  • std::process::ExitCode
  • std::process::Termination
  • std::thread::JoinHandle::is_finished
• Das „const“-Merkmal, das die Verwendung in jedem Kontext anstelle von Konstanten ermöglicht, wurde in den Funktionen angewendet:
  • ::offset und ::offset
  • ::wrapping_offset und ::wrapping_offset
  • ::add und ::add
  • ::sub und ::sub
  • ::wrapping_add und ::wrapping_add
  • ::wrapping_sub und ::wrapping_sub
  • ::as_mut_ptr
  • ::as_ptr_range
  • ::as_mut_ptr_range

Zusätzlich kann der Artikel „Rust: A Critical Retrospective“ erwähnt werden, der Eindrücke über die Programmiersprache Rust zusammenfasst, nachdem 100.000 Zeilen Code für die Entwicklung des Mikrokernel-Betriebssystems Xous, das in Firmware eingesetzt wird, geschrieben wurden. Zu den Nachteilen zählen eine schwer verständliche Syntax, Unvollständigkeit und die fortdauernde Entwicklung der Sprache, das Fehlen wiederholbarer Builds, typische Probleme mit dem Vertrauen in die Abhängigkeiten in Crates.io sowie die Notwendigkeit, eine bestimmte Disziplin beim Schreiben sicherer Codes einzuhalten. Als herausragende Möglichkeiten, die die Erwartungen übertroffen haben, werden die Tools zur Code-Refaktorisierung und zur Überarbeitung von „Hacks“, die bei der schnellen Erstellung von Prototypen hinzugefügt wurden, erwähnt.

Quelle: opennet.ru