Une excellente évaluation des performances de comptime de Zig

Différentes perspectives sur le comptime de Zig

• Métaprogrammation de Zig : Zig propose la métaprogrammation comme fonctionnalité centrale, ce qui permet de maximiser la puissance de programmation en traitant le code comme des données. En particulier, cette approche est avantageuse pour mapper précisément des concepts de haut niveau vers des opérations de bas niveau, notamment en programmation proche du matériel.

• Première prise en main du comptime : Utiliser le comptime de Zig pour la première fois peut être difficile, mais le fait de changer de perspective a facilité la compréhension. L’article propose six approches différentes pour mieux comprendre le comptime.

View 0: Peut être ignoré

• Priorité à la lisibilité du code : Le comptime de Zig donne la priorité à la lisibilité du code, ce qui est essentiel pour le débogage et la modification du code. La métaprogrammation peut souvent se transformer en code « write-only », mais avec Zig, il est facile de combiner le temps de compilation et le runtime dans un code lisible.

View 1: Générique

• Programmation générique : Dans Zig, la programmation générique est traitée comme une fonction du comptime, et non comme une fonctionnalité distincte. Pour rendre un type générique, on définit une fonction qui prend le type en argument et le renvoie.

View 2: Code standard exécuté à la compilation

• Exécution pendant la compilation : Zig utilise le même langage pour le runtime, le comptime et le système de build. Par exemple, il est possible de pré-calculer le problème Fizz Buzz à la compilation pour améliorer les performances d’exécution.

View 3: Évaluation partielle

• Évaluation partielle : C’est une technique qui permet de préévaluer seulement une partie d’une fonction en passant certains arguments seulement. Le comptime de Zig réalise une évaluation partielle au cours de la compilation.

View 4: Évaluation à la compilation, génération de code runtime

• Génération de code : Le code pouvant être évalué à la compilation l’est, tandis que le code nécessaire à l’exécution est ajouté au code généré. Le compilateur de Zig implémente le comptime via une machine virtuelle.

View 5: Génération de code basée sur le texte

• Proximité avec la génération de code : Le comptime de Zig fonctionne de manière similaire à la génération de code, en combinant la puissance de la génération de code basée sur du texte avec la simplicité du comptime.

Conclusion

• Les atouts du comptime de Zig : Le comptime de Zig est très utile car il combine la puissance de la génération de code et la simplicité de la lisibilité du code. De nombreuses méthodologies de métaprogrammation peuvent être transposées en comptime.

Ressources complémentaires

• Des informations supplémentaires sont disponibles sur le site officiel de Zig, et davantage d’exemples peuvent être consultés dans la bibliothèque standard de Zig.

[GN⁺]

Avis de Hacker News

• Une discussion approfondie des problèmes de la programmation au moment de la compilation est nécessaire. La programmation stagée n’est pas nouvelle, et plusieurs problèmes et compromis de conception existent.

  • La façon dont la généricité est implémentée casse la parametricité. La parametricité désigne la capacité d’inférer quelque chose d’une fonction à partir de sa seule signature de type.
  • Il n’est pas clair comment Zig gère les types génériques récursifs. En général, les systèmes de types recourent à la paresse pour autoriser la récursion.
  • L’interaction entre la vérification de types et les calculs au moment de la compilation est intéressante. Il n’est pas clair quel choix Zig a fait.
  • Le code au moment de la compilation fait apparaître des possibilités de génération de code, mais la question de l’hygiène n’est pas discutée.

• Le langage D dispose de cette fonctionnalité depuis 17 ans, et des fonctionnalités similaires passent progressivement vers d’autres langages.

  • D n’utilise pas de mot-clé, et déclenche l’exécution au compile time via des "const expression".
  • En évitant les variables globales non constantes, les accès I/O et les appels aux fonctions système, beaucoup de fonctions peuvent être exécutées au moment de la compilation.

• Zig est intéressant, mais le manque de surcharge d’opérateurs est regrettable. Je comprends mal les objections contre la surcharge d’opérateurs.

  • L’argument selon lequel on ne peut pas savoir ce qui se passe réellement avec la surcharge d’opérateurs n’est pas convaincant.

• Le pattern de création de structures au compile time est intéressant.

  • J’ai fait une expérience consistant à générer un fichier JSON pour implémenter un réseau de neurones, puis à générer des structures en le lisant.
  • Théoriquement, le compilateur peut optimiser directement le réseau de neurones.

• 'fieldNames' est similaire aux 'fieldPairs' de Nim et constitue une structure très utile.

  • Rust manque d’une telle fonctionnalité : les macros de Rust sont limitées à des macros non typées.

• Si les capacités de compilation de Zig vous impressionnent, Nim mérite aussi d’être regardé. Nim dispose d’une évaluation de code au temps de compilation et d’un système de macros AST complet.

• Zig peut être adapté au développement de plugins audio, mais il manque l’écosystème C++ (JUCE, etc.)

• Zig est un très bon langage, et il est important de l’utiliser pour les bons cas d’usage.

• J’aimerais voir apparaître quelque chose qui combine les capacités de méta-programmation de Zig avec l’écosystème massif, la communauté et la fiabilité de Rust.

  • J’apprécie la conception du langage Zig, mais il est encore difficile d’écrire quelque chose d’utile ou digne de confiance.