Eine hervorragende Bewertung von Zigs `comptime`

Verschiedene Perspektiven auf comptime in Zig

• Metaprogrammierung in Zig: Zig stellt Metaprogrammierung als zentrales Feature bereit und nutzt die Art und Weise, wie Code mit Daten umgeht, um die Leistungsfähigkeit von Programmierung auszuschöpfen. Besonders bei hardwarenaher Programmierung ist es vorteilhaft, weil sich höherwertige Konzepte präzise auf Low-Level-Operationen abbilden lassen.

• Erste Erfahrung mit comptime: Als ich Zigs comptimezum ersten Mal verwendet habe, war es schwierig. Als ich jedoch die Perspektive änderte, wurde es leichter verständlich. Um das zu erreichen, werden sechs verschiedene Blickwinkel aufcomptime` vorgestellt.

Ansicht 0: Kann ignoriert werden

• Lesbarkeit im Fokus: comptime in Zig legt den Schwerpunkt auf lesbaren Code, was für Debugging und Code-Änderungen unverzichtbar ist. Metaprogrammierung kann oft zu "write-only code" werden, aber bei Zig können Compile-Zeit und Laufzeit gemeinsam genutzt werden und der Code bleibt trotzdem einfach zu lesen.

Ansicht 1: Generisch

• Generische Programmierung: In Zig wird Generik nicht als einzelne Funktion behandelt, sondern als Teil von comptime. Um einen Typ generisch zu machen, wird er als Funktionsargument aufgenommen und zurückgegeben.

Ansicht 2: Normale Codeausführung zur Compile-Zeit

• Ausführung zur Compile-Zeit: Zig verwendet dieselbe Sprache für Laufzeit, comptime und Build-System. So kann man beispielsweise das Fizz-Buzz-Problem bereits zur Compile-Zeit vorab berechnen und damit die Ausführungsgeschwindigkeit erhöhen.

Ansicht 3: Teilweise Auswertung

• Partielle Auswertung: Eine Technik, bei der ein Teil einer Funktion vorab ausgewertet wird, indem nur einige ihrer Argumente übergeben werden. comptime in Zig führt diese partielle Auswertung während des Kompilierens durch.

Ansicht 4: Compile-Zeit-Auswertung, Laufzeit-Codeerzeugung

• Codeerzeugung: Zum Compile-Zeit auswertbarer Code wird ausgewertet, und Code, der zur Laufzeit benötigt wird, wird dem Ausgabecode hinzugefügt. Der Zig-Compiler implementiert comptime über eine virtuelle Maschine.

Ansicht 5: Textbasierte Codeerzeugung

• Ähnlichkeit zur Code-Generierung: comptime in Zig funktioniert ähnlich wie Code-Generierung, indem es die Stärke textbasierter Codeerzeugung mit der Einfachheit von comptime kombiniert.

Fazit

• Die Vorteile von Zigs comptime: Zigs comptime vereint die Leistungsfähigkeit von Codegenerierung mit der einfachen Lesbarkeit von Code und ist dadurch sehr nützlich. Verschiedene Methoden der Metaprogrammierung lassen sich in comptime überführen.

Weitere Lektüre

• Auf der offiziellen Zig-Webseite finden sich weitere Informationen, und in der Zig-Standardbibliothek finden sich weitere Beispiele.

[GN⁺]

Hacker News Kommentar

• Es braucht eine vertiefte Diskussion der Probleme rund um Compile-Time-Programmierung. Staged Programming ist nichts Neues; es gibt zahlreiche Designkompromisse und -probleme.

  • Die Art der Generic-Implementierung verletzt die Parametrizität. Parametrizität bedeutet die Fähigkeit, eine Funktion allein aus ihrer Typ-Signatur heraus zu erschließen.
  • Unklar ist, wie Zig mit rekursiven generischen Typen umgeht. Typische Typsysteme nutzen dafür Laziness, um Rekursion zuzulassen.
  • Die Interaktion zwischen Typprüfung und Compile-Time-Berechnung ist interessant; welche Wahl Zig dabei getroffen hat, ist nicht eindeutig.
  • Compile-Time-Code eröffnet Möglichkeiten zur Codegenerierung, aber es wird nichts über Hygiene diskutiert.

• Die Sprache D hat solche Funktionen seit 17 Jahren, und diese Features wandern ständig in andere Sprachen.

  • D verwendet keine speziellen Schlüsselwörter und triggert die Compile-Time-Ausführung über „const expression“.
  • Viele Funktionen können zur Compile-Time ausgeführt werden, wenn man nicht-konstante globale Variablen, I/O und Systemaufrufe vermeidet.

• Zig ist interessant, aber es fehlt mir die Operator-Overloading-Unterstützung. Die Gegenargumente gegen Operator-Overloading sind mir nicht wirklich einleuchtend.

  • Das Argument, man könne bei Operator-Overloading nicht nachvollziehen, was genau passiert, ist wenig überzeugend.

• Das Muster, Strukturen zur Compile-Time zu erzeugen, ist spannend.

  • Ich habe ein Experiment gemacht, bei dem bei der Implementierung eines neuronalen Netzes eine JSON-Datei generiert und daraus Strukturen erzeugt werden.
  • Theoretisch könnte der Compiler das Netz direkt optimieren.

• „fieldNames“ ist ähnlich wie „fieldPairs“ in Nim und ist eine sehr nützliche Konstruktion.

  • In Rust fehlt so etwas. Rusts Makros sind auf untypisierte Makros beschränkt.

• Wenn dich die Compile-Time-Funktionen von Zig überraschen, lohnt es sich, auch Nim anzuschauen. Nim hat Compile-Time-Codeauswertung und ein vollständiges AST-Makrosystem.

• Zig kann für die Audio-Plugin-Entwicklung geeignet sein, aber es fehlt das C++-Ökosystem (z. B. JUCE usw.).

• Zig ist als Sprache wirklich gut; entscheidend ist, sie für den richtigen Zweck einzusetzen.

• Ich wünsche mir etwas, das Zig-s Metaprogrammier-Funktionen mit der riesigen Ökosystem, Community und Sicherheit von Rust kombiniert.

  • Mir gefällt das Sprachdesign von Zig, aber es ist noch schwer, etwas Nützliches oder Verlässliches damit zu schreiben.