Ce que le `comptime` de Zig ne fait pas

• La fonctionnalité comptime de Zig offre une évaluation à la compilation très puissante, mais elle est volontairement limitée
• Lors de l’exécution de code à la compilation, il est impossible d’accéder aux informations de l’hôte, une conception adaptée à la compilation croisée
• La génération dynamique de code, les DSL, la RTTI, les E/S, etc. ne sont pas pris en charge ; Zig privilégie à la place une spécialisation explicite du code basée sur les types
• La RTTI peut être implémentée manuellement, en reconstruisant des informations de type qui n’existent qu’à la compilation pour les rendre utilisables à l’exécution
• Il est possible de créer de nouveaux types avec comptime, mais pas d’étendre leur API ; il est impossible d’ajouter des méthodes personnalisées

---

Ce que le comptime de Zig ne fait pas

• Le comptime de Zig fournit des capacités puissantes pour les génériques, la compilation conditionnelle, la sérialisation, les ORM, etc., mais certaines fonctionnalités sont explicitement limitées
• Ces limitations rendent au contraire la conception de Zig plus simple et plus prévisible

• Pas d’accès aux informations de l’hôte (No Host Leakage)

  • Le code comptime fonctionne en fonction de la plateforme cible, et non du système sur lequel le code est exécuté
  • En Zig, il est impossible d’utiliser à la compilation des informations du système hôte comme l’endianness ou la taille des pointeurs
  • L’objectif est de garantir la sûreté dans une logique de compilation croisée
  • Dans l’exemple de code, l’affichage des octets d’un nombre au format BF16 varie selon la plateforme cible

• Pas de génération de code basée sur des chaînes (No #eval)

  • Zig ne propose pas de mécanisme de génération dynamique de code comme #include en C, les mixins du langage D ou les macros de Rust
  • À la place, il prend en charge l’évaluation partielle (partial evaluation) fondée sur des arguments comptime
  • Si certains arguments sont connus à la compilation, seule la branche correspondante est conservée, ce qui permet d’optimiser le code

• Pas d’extension syntaxique DSL (No DSLs)

  • Zig ne permet pas de créer une syntaxe personnalisée comme en Lisp ou en Rust
  • Toutes les données sont transmises uniquement sous forme de valeurs conformes à la syntaxe de Zig
  • Des DSL limités comme les chaînes de formatage (printf) ne peuvent être implémentés que sous forme de chaînes comptime

• Pas d’informations de type à l’exécution (No RTTI)

  • Zig peut se comporter comme un langage dynamique tel que Python, mais les informations de type n’existent qu’en comptime
  • Pour les rendre disponibles à l’exécution, il faut définir soi-même une structure RTTI et la manipuler via des pointeurs
  • Exemple : définir une structure RTTI contenant les noms et offsets des champs d’une struct, puis accéder aux champs via des pointeurs

• Impossible de créer une nouvelle API (No New API)

  • En Zig, il est possible de créer de nouveaux types avec comptime, mais on ne peut pas leur ajouter de méthodes
  • Il n’est donc pas possible d’étendre l’API comme avec les derive macros de Rust
  • Lors d’une implémentation de sérialisation JSON, on ne peut pas ajouter de méthode .to_json() ; il faut passer le type en argument à une fonction globale

• Pas d’E/S à la compilation (No IO)

  • Le comptime de Zig interdit l’accès aux ressources externes comme le système de fichiers, le réseau ou les bases de données
  • Cela améliore la reproductibilité, la sûreté et l’exploitabilité du cache
  • Si des E/S sont nécessaires, il faut utiliser le système de build build.zig pour importer du code Zig pré-généré

• Conclusion : El Disco (équilibre entre abstraction et simplicité)

  • Zig fournit de puissantes capacités de métaprogrammation, tout en conservant une conception très restrictive afin de garantir la prévisibilité
  • Grâce à ces limitations, le comptime de Zig reste pratique et facile à comprendre
  • Même sans abstractions complexes, il reste utile en pratique et n’exécute clairement que les fonctionnalités déclarées

[GN⁺]

Discussion sur Hacker News

• Le comptime de Zig possède des caractéristiques uniques

  • il remplace diverses fonctionnalités présentes dans d'autres langages
  • il est facile à comprendre grâce à sa transparence référentielle
  • il offre des capacités puissantes via l'introspection
  • il permet d'écrire du code à la fois simple et puissant, d'une manière différente de Lisp
  • les langages proposant une nouvelle conception et une nouvelle approche sont rares

• Inconvénients du comptime de Zig et solutions

  • on peut générer du code via zig build, puis le compiler avec @import
  • cela offre davantage de liberté et un temps d'exécution illimité, mais pas la liberté de générer des types Zig comme valeurs dans la compilation en cours
  • cela rappelle les anciennes expériences consistant à relier Perl et Tcl à du C
  • l'attitude autocritique de la communauté Zig est parfois déconcertante

• La phrase espagnole citée dans une histoire de Borges concerne un dieu nordique

• Flexibilité du comptime

  • lorsqu'on a besoin d'informations de type pendant le travail, on peut les ajouter aux paramètres de la fonction
  • lorsqu'il est impossible de fournir le type dans certaines situations, il faut résoudre un problème de conception

• Ce pour quoi le comptime de Zig est connu

  • il permet les génériques, la compilation conditionnelle, le sous-typage, la sérialisation, les ORM et bien d'autres fonctionnalités
  • d'autres langages disposent aussi de mécanismes similaires d'évaluation à la compilation

• Un billet de blog pédagogique

  • il explique la différence entre comptime for et inline for
  • dans la version inline, la longueur ne peut être connue qu'au comptime

• Avis positifs sur le langage et les outils Zig

  • certains aimeraient qu'il existe un mode de sécurité comme en Rust
  • le projet est bien plus avancé que C/C++
  • le compilateur Zig impressionne beaucoup

• Ce qui est intéressant dans le comptime de Zig

  • la capacité à représenter des types comme des valeurs à la compilation
  • cela permet d'approcher les langages dynamiques ou la réflexion à l'exécution sans surcoût à l'exécution

• Confusion autour de l'exécution de code à la compilation

  • certains se demandent si le code exécuté à la compilation tourne réellement sur la machine hôte locale
  • on s'interroge sur la raison pour laquelle Zig masque la plateforme hôte
  • les capacités de cross-compilation de Zig sont vues très positivement