Deklarative Makros (`macro_rules!`)

Makros bieten eine Möglichkeit, Code zu schreiben, der Code schreibt! Sie ähneln Funktionen, arbeiten aber nicht mit Werten, sondern mit Syntaxbäumen (der Struktur Ihres Codes).

• Sie helfen dabei, sich wiederholenden Code zu abstrahieren.
• Sie ermöglichen domänenspezifische Sprachen (DSLs) innerhalb von Rust.
• Sie werden zur Compile-Zeit ausgeführt und vor der Kompilierung in normalen Rust-Code erweitert.

Rusts deklarative Makros verwenden das Schlüsselwort macro_rules!. Sie definieren eine Reihe von Regeln, die bestimmten Mustern von Rust-Code entsprechen.

Stellen Sie es sich als Pattern Matching für Codeausschnitte vor. Wenn der Compiler einen Makroaufruf sieht, versucht er, die Eingabe einer der von Ihnen definierten Regeln zuzuordnen.

Erstellen wir ein sehr einfaches Makro, das eine Begrüßung ausgibt. Beachten Sie das Schlüsselwort macro_rules! und die Syntax () => {}, mit der eine Regel ohne Eingabemuster definiert wird.

Führen Sie dieses Beispiel aus:

Makros können Eingaben mithilfe von „Designatoren“ entgegennehmen. Diese geben dem Makro an, welche Art von Rust-Syntax es erfassen soll.

• $expr: Ein Ausdruck (z. B. 1 + 2, "hello")
• $ident: Ein Bezeichner (z. B. ein Variablen- oder Funktionsname)
• $ty: Ein Typ (z. B. i32, String)
• $block: Ein Codeblock (z. B. { ... })
• ...und viele weitere!

Hier ist ein Makro, das einen Ausdruck ($e:expr) entgegennimmt und dessen Wert ausgibt. Das :expr ist der Designator.

Das erfasste $e kann anschließend im Rumpf des Makros verwendet werden. Das Makro stringify! wandelt den Ausdruck in seine String-Darstellung um.

Was ist, wenn Sie ein Makro erstellen möchten, das mehrere Argumente desselben Typs akzeptiert? Sie können Wiederholungsoperatoren verwenden: $()*.

• $(): Der Inhalt darin ist das zu wiederholende Muster.
• *: Null oder mehr Wiederholungen.
• +: Eine oder mehr Wiederholungen.
• Sie können auch ein Trennzeichen angeben, beispielsweise $(...),* für durch Kommas getrennte Elemente.

Erstellen wir ein Makro, das mehrere durch Kommas getrennte Ausdrücke akzeptiert und jeden einzelnen ausgibt. Dies ist besonders nützlich, um listenähnliche Strukturen zu erstellen.

Die Makros von Rust sind „hygienisch“. Das bedeutet, dass innerhalb eines Makros definierte Variablen nicht versehentlich mit Variablen außerhalb des Makros kollidieren, selbst wenn sie denselben Namen haben.

Der Compiler benennt Elemente während der Expansion intern um, um unbeabsichtigte Seiteneffekte zu verhindern. Dadurch lassen sich Makros sicherer und vorhersehbarer verwenden.

Manchmal werden Makros nicht so expandiert, wie Sie es erwarten. Rust bietet eine Möglichkeit, den expandierten Code anzuzeigen:

• Führen Sie cargo expand aus (dazu muss das Tool cargo-expand installiert sein).
• Verwenden Sie rustc --pretty expanded direkt für Ihre Quelldatei.

Dadurch wird der unverarbeitete Rust-Code angezeigt, den Ihr Makro erzeugt. Das ist für das Debuggen und das Verständnis komplexen Makroverhaltens äußerst hilfreich!

Betrachten Sie die folgende Makrodefinition:

macro_rules! make_tuple {
    ( $x:expr, $y:expr ) => {
        ($x, $y)
    };
}

Welche der folgenden Zeilen würde erfolgreich kompiliert und das Makro make_tuple! verwenden?

In dieser Lektion haben Sie deklarative Makros mit macro_rules! kennengelernt:

• Sie erzeugen zur Kompilierzeit Code und abstrahieren sich wiederholende Muster.
• Sie verwenden Pattern-Matching, um Eingaben anhand ihrer Syntax zu erfassen.
• Designatoren wie $expr und $ident legen fest, welche Art von Syntax erwartet wird.
• Wiederholungsoperatoren wie $()* verarbeiten mehrere Argumente mit flexiblen Trennzeichen.
• Makros sind hygienisch und verhindern versehentliche Namenskonflikte.

Makros sind ein leistungsfähiges Werkzeug, um Boilerplate-Code zu reduzieren und flexible, ergonomische APIs in Rust zu erstellen!