Erscheinung von Rust 1.78. Die Borgo-Sprache kombiniert die Stärken von Go und Rust.

Die Veröffentlichung der Programmiersprache Rust 1.78, die ursprünglich von Mozilla entwickelt wurde und jetzt unter der Schirmherrschaft der unabhängigen Non-Profit-Organisation Rust Foundation weiterentwickelt wird, wurde bekannt gegeben. Die Sprache konzentriert sich auf sicheren Umgang mit Speicher und bietet Mittel zur Erreichung hohen Task-Parallelismus, ganz ohne einen Garbage Collector und Runtime (die Runtime beschränkt sich auf die grundlegende Initialisierung und Pflege 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:

• Ein neuer Namensraum für Attribute „#[diagnostic]“ wurde eingeführt, der Mittel bereitstellt, um die vom Compiler ausgegebenen Fehlermeldungen zu beeinflussen. Zunächst wurde das Attribut „#[diagnostic::on_unimplemented]“ implementiert, das zur Anpassung der Fehlermeldungen verwendet werden kann, die ausgegeben werden, wenn ein Trait gefordert wird, der für einen Typ nicht implementiert ist. #[diagnostic::on_unimplemented( message = „Meine Nachricht für `ImportantTrait<{A}>` ist nicht für `{Self}` implementiert“, label = „Mein Label“, note = „Hinweis 1“, note = „Hinweis 2“ )] trait ImportantTrait<A> {} fn use_my_trait(_: impl ImportantTrait<i32>) {} fn main() { use_my_trait(String::new()); } error[E0277]: Meine Nachricht für `ImportantTrait<i32>` ist nicht für `String` implementiert —> src/main.rs:12:18 | 12 | use_my_trait(String::new()); | ———— ^^^^^^^^^^^^^ Mein Label | | | erforderlich durch eine Bindung, die durch diesen Aufruf eingeführt wurde | = Hilfe: Das Trait `ImportantTrait<i32>` ist nicht für `String` implementiert | = Hinweis: Hinweis 1 | = Hinweis: Hinweis 2
• Die vorläufigen assert-Prüfungen, die auf unsafe-Funktionen angewendet werden, können jetzt bis zur Codegenerierung verzögert werden, was bedeutet, dass diese Prüfungen durchgeführt werden können, ohne dass die Standardbibliothek im Modus "#[cfg(debug_assertions)]" erstellt werden muss. Um die Prüfungen auszulösen, reicht es jetzt aus, die Debug-Assertions für Test- oder Debug-Builds Ihres Codes zu aktivieren.
• Das Verhalten von Funktionen in der Standardbibliothek, die die Ausrichtung von Zeigern und Slices beeinflussen, ist jetzt zur Laufzeit vorhersehbar und hängt von den Eingabedaten ab. Die Funktion pointer::align_offset, die die Verschiebung zur Ausrichtung eines Zeigers berechnet, gibt jetzt nur dann usize::MAX zurück, wenn die Operation nicht ausgeführt werden kann. Die Funktionen slice::align_to und slice::align_to_mut, die Slices in eine Darstellung mit ausgerichtetem Mittel-Slice und den ursprünglichen Anfangs- und End-Slices umwandeln, geben nun immer den größten Mittelabschnitt zurück.
• In die stabile Version übernommen:
  • impl Read für &Stdin
  • Die Nutzung von nicht-statischen Lebenszeiten (nicht 'static') wurde für bestimmte Implementierungen im Zusammenhang mit std::error::Error erlaubt.
  • In der Implementierung impl<Fd: AsFd> ist die Verwendung von Werten ?Sized erlaubt.
  • impl From für io::Error
• Die Funktion Barrier::new() wurde stabilisiert, um in jedem Kontext mit dem Attribut „const“ verwendet zu werden.
• Für die Zielplattformen x86_64-pc-windows-msvc, i686-pc-windows-msvc, x86_64-pc-windows-gnu, i686-pc-windows-gnu, x86_64-pc-windows-gnullvm und i686-pc-windows-gnullvm ist jetzt mindestens Windows 10 erforderlich.
• Eine dritte Unterstützungsebene wurde für die Plattformen wasm32-wasip2, arm64ec-pc-windows-msvc, armv8r-none-eabihf und loongarch64-unknown-linux-musl implementiert. Die dritte Ebene bietet grundlegende Unterstützung ohne automatisierte Tests, Veröffentlichung offizieller Builds und Überprüfung der Code-Baustelle.
• Eine zweite Unterstützungsstufe für die Zielplattform wasm32-wasip1 wurde implementiert. Die zweite Unterstützungsstufe garantiert die Baufähigkeit.
• Die Plattform wasm32-wasi-preview1-threads wurde in wasm32-wasip1-threads umbenannt.
• Der Compiler wurde auf die Verwendung von LLVM 18 umgestellt. Bei der Verwendung von LLVM 18 für x86-32 und x86-64 wurde das ABI bezüglich der Typen u128 und i128 geändert.
• In dem Paketmanager Cargo wurde die Version 4 der Lockfiles (lockfile v4) stabilisiert.
• In Cargo ist ein globaler Cache stabilisiert, der Informationen über die letzte Nutzung der Daten enthält. Der Cache wird in der Datei $CARGO_HOME/.global-cache mit SQLite gespeichert, automatisch aktualisiert und spiegelt die letzten Änderungen in Bezug auf den Index, die Crate-Datei, das Quellverzeichnis, git clone und git checkout wider.

Es ist auch die Programmiersprache Borgo erwähnenswert, die versucht, ausdrucksvoller als Go und weniger komplex als Rust zu sein. Borgo kombiniert die besten Eigenschaften von Go und Rust und behebt die Schwächen beider Sprachen. Zum Beispiel ist Go einfach und verständlich, bietet jedoch keine erweiterten Mittel zur Typensicherheit. Rust hingegen sorgt für sichere Programmierung, ist aber überkompliziert. Das Projekt wird von Marco Sampellegrini geleitet, dem Autor des Buches „The Simple Haskell Handbook“ und Entwickler des Continuous Integration-Systems Quad CI.

In Borgo kommt statische Typisierung zum Einsatz, mit Typen, die dem Go-Sprachstil ähneln, und einer Syntax, die an Rust erinnert. Das Setzen von Semikolons am Ende der Zeilen im Borgo-Code ist nicht verpflichtend. Der Code in Borgo wird in eine Go-Darstellung kompiliert, die vollständig mit bestehenden Go-Paketen kompatibel ist. Der Compiler-Code ist in Rust geschrieben und wird unter der ISC-Lizenz verteilt. use fmt enum NetworkState { Loading, Failed(int), Success(T), } struct Response { title: string, duration: int, } fn main() { let res = Response { title: "Hello world", duration: 0, }; let state = NetworkState.Success(res); let msg = match state { NetworkState.Loading => "still loading", NetworkState.Failed(code) => fmt.Sprintf("Got error code: %d", code), NetworkState.Success(res) => res.title, }; fmt.Println(msg); }

Quelle: opennet.ru