Skip to content

Programmiersprache Rust 1.64 erweitert asynchrone Programmierung mit IntoFuture

Im turnusmäßigen Sechswochentakt ist Rust 1.64 erschienen. Das Launch implementiert das Trait IntoFuture für die asynchrone Programming. Außerdem sind einige C-Typen nun von der Customary- in die Core-Library gewandert, um sie vor allem in der Embedded-Programmierung nutzen zu können.

Auf Ökosystemseite ist neuerdings der rust-analyzer Bestandteil der Toolsammlung von Rust. Das Werkzeug ist eine Implementierung des Language Server Protocol, um Funktionen wie Autovervollständigung in IDEs und Sourcecode-Editoren wie Visible Studio Code, Emacs und Vim zu nutzen. Um den Language Server für Rust zu installieren, dent die Zeile rustup element add rust-analyzer.

Rust hat das Async-Await-Sample mit Rust 1.39 Ende 2019 eingeführt. sie nutzt das Future-Trait Einzug, das einen zukünftigen Wert beschreibt. Traits sind Rusts Umsetzung von Interfaces. Uber eine ballot-Methode lässt sich der Wert abfragen. Die Methode wartet nicht, bis der Wert tatsächlich da ist, blockiert additionally nicht, aber kann dem Aufrufer mitteilen, dass die Future noch nicht bereit ist. Mit dem Key phrase await lässt sich die Ausführung einer Funktion so lange aufhalten, bis die Future fertig durchlaufen ist.

Das aktuelle Launch führt mit IntoFuture ein neues Trait ein, das einen beliebigen Typ in ein Future wandelt. Die Umsetzung ist an das in Rust 1.53 eingeführte Trait IntoIterator angelehnt, der das Iterieren über die Elemente eines Typs ermöglicht.

You give IntoFuture-Trait benötigt die Typen für den zugehörigen Output (sort Output) und die Future (sort IntoFuture) sowie eine Methode (fn into_future(self)), die das Objekt vorbereitet und eine Future erstellt. .await ruft letztere Methode auf, bevor es die Ergebnisse abruft beziehungsweise abwartet.

Folgender Code aus der Rust-Dokumentation zeigt den Einsatz des Trait an dem einfachen, wenn auch konstruierten Beispiel eines Struct für die Multiplikation einer Zahl num mit einem Issue issue:

use std::future::{prepared, Prepared, IntoFuture};

/// Ultimately multiply two numbers
pub struct Multiply {
    num: u16,
    issue: u16,
}

impl Multiply {
    /// Assemble a brand new occasion of `Multiply`.
    pub fn new(num: u16, issue: u16) -> Self {
        Self { num, issue }
    }

    /// Set the quantity to multiply by the issue.
    pub fn quantity(mut self, num: u16) -> Self {
        self.num = num;
        self
    }

    /// Set the issue to multiply the quantity with.
    pub fn issue(mut self, issue: u16) -> Self {
        self.issue = issue;
        self
    }
}

impl IntoFuture for Multiply {
    sort Output = u16;
    sort IntoFuture = Prepared;

    fn into_future(self) -> Self::IntoFuture {
        prepared(self.num * self.issue)
    }
}

async fn run() {
  let num = Multiply::new(0, 0)  // initialize the builder to 
                                 // quantity: 0, issue: 0
      .quantity(2)                 // change the quantity to 2
      .issue(2)                 // change the issue to 2
      .await;                    // convert to future and .await

    assert_eq!(num, 4);
}

Die eigentliche Implementierung des neuen Trait findet sich in dem Block impl IntoFuture for Multiply. Auf die neue Umsetzung zu setzen lohnt sich laut Dokumentation vor allem für asynchrone Builder-Typen, für die vor dem Await-Prozess mehrfache Änderungen der Werte anstehen. Im Blogbeitrag zu Rust 1.64 findet sich ein Beispiel zu einer Storage-Abfrage.

Der Vorschlag zur Implementierung eines IntoFuture kam bereits Ende 2019 kurz nach der Umsetzung von Async/Await auf, führte allerdings wohl zunächst zu Efficiency-Problemen, weshalb er zunächst wieder aus der Sprache herausgenommen wurde.

Eine weitere Änderung betrifft vor allem die Embedded-Entwicklung: Einige Typ-Aliase wandern von der Customary in die Core-Library. Letztere ist die minimale Umsetzung, die auf Dependencies verzichtet und auch in Code aus Paketen (Crates) verfügbar ist, die mit #![no_std] gekennzeichnet sind, additionally auf die Standardbibliothek verzichten.

Rust 1.64 bietet nun numerous Typ-Aliase für das Overseas-Operate-Interface (FFI) zu C in core::ffi. Dazu gehören die Aliase, mit c_ beginnen wie c_uint und c_ulong sowie die String-Umsetzung core::ffi::CStr.

Weitere Particulars zu Rust 1.64 wie das Anstoßen eines Cargo-Construct-Prozesses für mehrere Targets lassen sich dem Rust-Weblog entnehmen. Wie üblich können Entwicklerinnen und Entwickler, die Rust bereits installiert haben, das aktuelle Launch über rustup replace steady herunterladen. Für diejenigen, die noch kein Rust verwenden, ist das rustup-Software auf der Obtain-Seite separat verfügbar.


(me)

Zur Startseite

.

Leave a Reply

Your email address will not be published.