Veröffentlichung von Rust 1.78. Die Sprache Borgo, die die Stärken von Go und Rust kombiniert

Die Veröffentlichung der Programmiersprache Rust 1.78, die ursprünglich von Mozilla entwickelt wurde und nun unter der Aufsicht der unabhängigen gemeinnützigen Organisation Rust Foundation weiterentwickelt wird, wurde bekannt gegeben. Die Sprache fokussiert sich auf eine sichere Speicherverwaltung und bietet Mittel zur Erreichung einer hohen Parallelität bei der Ausführung von Aufgaben, ohne dabei einen Garbage Collector oder eine Laufzeitumgebung (runtime) zu verwenden, die auf die grundlegende Initialisierung und Unterstützungsfunktionen der Standardbibliothek beschränkt ist.

Die Methoden zur Speicherverwaltung in Rust befreien den Entwickler von Fehlern beim Umgang mit Zeigern und schützen vor Problemen, die durch niedrige Speicherverwaltung entstehen, wie z. B. den Zugriff auf Speicherbereiche nach deren Freigabe, Dereferenzierung von Nullzeigern, Pufferüberläufen usw. Zur Verbreitung von Bibliotheken, zur Gewährleistung des Builds und zur Verwaltung von Abhängigkeiten wird der Paketmanager Cargo entwickelt. Für das Hosting von Bibliotheken wird das Repository crates.io unterstützt.

Sichere Speicherverwaltung wird in Rust während der Kompilierung durch Überprüfung von Referenzen, Nachverfolgung des Eigentums an Objekten, Berücksichtigung der Lebensdauer von Objekten (Sichtbarkeitsbereiche) und Bewertung der Korrektheit des Zugriffs auf den Speicher während der Ausführung des Codes gewährleistet. Rust bietet ebenfalls Mittel zum Schutz vor Überläufen bei Ganzzahlen, fordert die zwingende Initialisierung von Variablenwerten vor deren Verwendung und behandelt Fehler in der Standardbibliothek besser. Außerdem wird das Konzept der Unveränderlichkeit (immutable) von Referenzen und Variablen standardmäßig angewendet, und es bietet eine starke statische Typisierung zur Minimierung logischer Fehler.

Hauptneuheiten:

• Ein neuer Namensraum für Attribute "#[diagnostic]" wurde eingeführt, der Möglichkeiten bietet, die vom Compiler ausgegebenen Fehlermeldungen zu beeinflussen. Der erste im neuen Namensraum realisierte Attribut ist "#[diagnostic::on_unimplemented]", der verwendet werden kann, um Fehlermeldungen anzupassen, die angezeigt werden, wenn ein Trait benötigt wird, der für einen Typ nicht implementiert ist. #[diagnostic::on_unimplemented( message = "My Message for `ImportantTrait<{A}>` is not implemented for `{Self}`", label = "My Label", note = "Note 1", note = "Note 2" )] trait ImportantTrait<A> {} fn use_my_trait(_: impl ImportantTrait<i32>) {} fn main() { use_my_trait(String::new()); } error[E0277]: My Message for `ImportantTrait<i32>` is not implemented for `String` —> src/main.rs:12:18 | 12 | use_my_trait(String::new()); | ———— ^^^^^^^^^^^^^ My Label | | | required by a bound introduced by this call | = help: the trait `ImportantTrait<i32>` is not implemented for `String` | = note: Note 1 | = note: Note 2
• Vorläufige Assert-Prüfungen, die auf unsafe-Funktionen angewendet werden, können jetzt bis zur Codegenerierungsphase verschoben werden, sodass 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-Assert für Test- oder Debug-Bauten des eigenen Codes zu aktivieren.
• Das Verhalten von Funktionen in der Standardbibliothek, die die Ausrichtung von Zeigern und Slices beeinflussen, ist nun zur Laufzeit vorhersagbar und hängt von den Eingabewerten ab. Die Funktion pointer::align_offset, die den Offset für die 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 ausgerichteten mittleren Slices und den ursprünglichen Anfangs- und End-Slices umwandeln, geben jetzt immer den größten mittleren Teil zurück.
• In die Kategorie stabil überführt wurden:
  • impl Read for &Stdin
  • Die Verwendung einer nicht statischen Lebensdauer (nicht ‚static) ist für einige Implementierungen, die mit std::error::Error verbunden sind, erlaubt.
  • Es ist in der Implementierung impl<Fd: AsFd> erlaubt, den Wert ?Sized zu verwenden.
  • impl From<TryReserveError> für io::Error
• Die Funktion Barrier::new() wurde stabilisiert, um mit dem Attribut „const“ in jedem Kontext verwendet zu werden, anstelle von konstanten Werten.
• 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 wird jetzt mindestens Windows 10 benötigt.
• Der dritte Support-Level für die Plattformen wasm32-wasip2, arm64ec-pc-windows-msvc, armv8r-none-eabihf und loongarch64-unknown-linux-musl wurde implementiert. Der dritte Level bedeutet grundlegende Unterstützung, jedoch ohne automatisierte Tests, Veröffentlichung offizieller Builds und Überprüfung der Buildfähigkeit des Codes.
• Der zweite Support-Level für die Zielplattform Add wasm32-wasip1 wurde implementiert. Der zweite Support-Level garantiert das Bauen.
• Die Plattform wasm32-wasi-preview1-threads wurde in wasm32-wasip1-threads umbenannt.
• Der Compiler wurde auf die Verwendung von LLVM 18 umgestellt. Bei Verwendung von LLVM 18 für die Architekturen x86-32 und x86-64 wurde das ABI, das mit den Typen u128 und i128 verbunden ist, geändert.
• Im Paketmanager Cargo wurde die Version 4 der Lockdateien (lockfile v4) stabilisiert.
• In Cargo wurde ein globaler Cache mit Informationen zur letzten Nutzung von Daten stabilisiert. Der Cache wird in der Datei $CARGO_HOME/.global-cache mit SQLite gespeichert, automatisch aktualisiert und spiegelt die letzten Änderungen wider, die mit dem Index, der crate-Datei, dem Quellcodeverzeichnis, git clone und git checkout verbunden sind.

Zusätzlich kann die Programmiersprache Borgo erwähnt werden, die versucht, ausdrucksvoller als Go, aber weniger komplex als Rust zu sein. Borgo kombiniert die besten Eigenschaften von Go und Rust und kompensiert die Mängel jeder Sprache. Zum Beispiel ist Go einfach und verständlich, bietet jedoch keine erweiterten Mittel zur Gewährleistung der Sicherheit im Umgang mit Typen. Rust bietet Mittel für sicheres Programmieren, ist jedoch überkompliziert. Das Projekt wird von Marco Sampellegrini entwickelt, dem Autor des Buches „The Simple Haskell Handbook“ und dem Entwickler des Systems für kontinuierliche Integration Quad CI.

In Borgo wird statische Typisierung verwendet, ähnlich wie bei der Programmiersprache Go, und die Syntax erinnert an Rust. Das Setzen von Semikolons am Ende der Zeilen im Borgo-Code ist nicht verpflichtend. Der Code in der Sprache Borgo wird in Go-Code kompiliert, der vollständig kompatibel mit bestehenden Paketen für die Sprache Go ist. Der Compiler-Code ist in Rust geschrieben und wird unter der ISC-Lizenz vertrieben. 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