Rust: Declarative Macro
Zusammenfassung
Kurz
Der vollständige Bericht erklärt anhand von Rust-Beispielen den Aufbau deklarativer Makros mit `macro_rules!`, Matchern, Metavariablen, Trennzeichen und Wiederholungen. Er zeigt außerdem Export und Import über Crates sowie `cargo-expand`; die Kritik an Lesbarkeit und Wartbarkeit ist als persönliche Einschätzung des Autors gekennzeichnet.
Mittel
Der vollständige Bericht von Itsuki führt in deklarative Makros in Rust ein. Er erklärt, dass Makros vor der Interpretation durch den Compiler erweitert werden, variable Eingaben annehmen können und vor ihrer Verwendung definiert oder eingebunden sein müssen. Der Autor hält sie für schwieriger zu lesen, schreiben und debuggen als Funktionen und sagt, er würde nach eigener Einschätzung meistens Funktionen bevorzugen.
Eigene deklarative Makros werden mit `macro_rules!` definiert. Ihre Regeln bestehen aus einem Matcher, der Eingaben erkennt, und einem Transcriber, der den erzeugten Code festlegt. Beispiele zeigen feste Textmuster, Metavariablen mit Fragment-Spezifizierern wie `expr`, mehrere Eingaben mit Trennzeichen sowie Wiederholungen mit `*`, `+` und `?`. Ein Makro begrüßt damit eine variable Liste von Namen. Für die Nutzung über Crate-Grenzen hinweg nennt der Artikel `#[macro_export]` und den Import mit `use`. `cargo-expand` wird als Werkzeug vorgestellt, um expandierten Code anzusehen. Prozedurale Makros werden nur kurz erwähnt; der Schwerpunkt liegt auf grundlegenden deklarativen Beispielen. Die Bewertung von Makros gegenüber Funktionen ist ausdrücklich die persönliche Einschätzung des Autors.
Ausführlich lesen
Der vollständige Bericht ist eine Einführung von Itsuki in deklarative Makros in Rust. Er erklärt, wie sie funktionieren, wie man einfache eigene Makros schreibt und wie man sie aus anderen Crates verfügbar macht. Prozedurale Makros werden als zweite Makroart erwähnt, aber nicht näher behandelt.
Der Autor beschreibt deklarative Makros als Code, der Rust-Code erzeugt, und ordnet sie als verbreitete Form der Makros in Rust ein. Im Unterschied zu Funktionen können sie laut Bericht Eingaben unterschiedlicher Art und variabler Anzahl verarbeiten. Außerdem werden sie vor der Interpretation des Codes durch den Compiler erweitert, während Funktionen zur Laufzeit aufgerufen werden. Makros müssen nach der Darstellung des Artikels definiert oder in den Geltungsbereich gebracht werden, bevor sie verwendet werden. Zugleich bewertet der Autor Makros als schwerer zu schreiben, zu lesen und zu debuggen als Funktionen und sagt, er würde nach eigener Einschätzung in den meisten Fällen Funktionen bevorzugen. Als Beispiel für den Nachteil beim Schreiben nennt er fehlende Eingabehilfen wie die, die er bei `println!` beobachtet.
Für die Definition eigener deklarativer Makros dient `macro_rules!`. Der Bericht erläutert deren Grundaufbau mit einem oder mehreren Regeln: Ein Matcher legt fest, welche Eingabe passt, und ein Transcriber bestimmt, welcher Code daraus erzeugt wird. Ein `hello`-Beispiel zeigt sowohl das Erkennen eines festgeschriebenen Wortes als auch das Binden einer Eingabe an eine Metavariable wie `$a:expr`. Anschließend listet der Artikel mögliche Fragment-Spezifizierer auf, darunter `expr`, `ident`, `ty`, `tt` und `literal`, und erklärt, dass ein Spezifizierer die Art des Rust-Syntaxfragments festlegt, das eine Metavariable erfasst. Ein weiteres Beispiel veranschaulicht unterschiedliche Trennzeichen zwischen zwei Ausdrücken.
Für eine variable Zahl von Eingaben stellt der Bericht die Wiederholungsoperatoren `*`, `+` und `?` vor: beliebig viele, mindestens eine oder null beziehungsweise eine Wiederholung. Ein Makro, das mehrere Namen begrüßt, zeigt eine wiederholte Ausdrucksgruppe mit Kommas. Der Artikel erklärt außerdem, wie eine optionale abschließende Trennung berücksichtigt werden kann und warum der erzeugte Block doppelte geschweifte Klammern verwendet.
Zum Teilen eines Makros über Crate-Grenzen nennt der Bericht `#[macro_export]` und zeigt anschließend den Import mit `use`. Als Hilfsmittel zur Ansicht des expandierten Codes empfiehlt er `cargo-expand`, das sich laut Artikel über Cargo installieren und im Projektverzeichnis ausführen lässt.
Die Beispiele dienen der Einführung; der Bericht bietet weder einen umfassenden Sprachreferenz-Ersatz noch eine systematische Behandlung prozeduraler Makros. Die Einschätzung zur Schwierigkeit und zur bevorzugten Verwendung von Funktionen kennzeichnet der Autor selbst als persönliche Meinung.
Gegengeprüft von Claude Haiku 5.5: kleine Mängel
Zu prüfen waren zwei Fassungen (kurz und mittel), die im Schema zu einer Zusammenfassung zusammengefasst sind. Beide geben den Bericht sachlich korrekt wieder, es gibt keine erfundenen Angaben. Die mittlere Fassung deckt die zentralen Aussagen ab; die kurze lässt den Makro-Funktion-Vergleich aus. Es wurden keine Fragen zur Einordnung angegeben (Abschnitte Einordnung leer), daher ist das Feld einordnung leer.
Im Bericht, aber nicht in der Zusammenfassung
- In der kurzen Fassung fehlt der Vergleich von Makros und Funktionen: variable Parameterzahl, Expansion vor der Compiler-Interpretation statt Laufzeit und Definitionsort vor der Verwendung. Auch die Präferenz des Autors für Funktionen wird dort nicht genannt.
Wie die Modelle den Bericht einordnen
Ansicht
Filter
Kein Modell sieht bei diesem Bericht einen Bezug zu einer der 44 Sammelfragen.