Écrire un interpréteur en Go

Introduction

Le livre « Writing an Interpreter in Go » (en traduction française — « Écrire un interpréteur en Go ») de Thorsten Ball est un guide pratique unique qui enseigne étape par étape à créer un interpréteur complet pour le langage de programmation fictif Monkey. Contrairement aux manuels académiques sur les compilateurs, ce livre se concentre sur le code réel et un minimum de théorie, permettant au lecteur de se lancer immédiatement dans l'écriture d'un interpréteur fonctionnel en langage Go.

Publié en 2018, le livre contient 212 pages et s'adresse aux programmeurs qui souhaitent comprendre plus en profondeur le fonctionnement interne des langages de programmation. Il ne nécessite pas de connaissances préalables en compilateurs, mais suppose une maîtrise solide de Go.

De quoi parle ce livre

Le livre guide le lecteur à travers toutes les étapes de la création d'un interpréteur : de l'analyse lexicale à l'exécution du code. Les sujets principaux sont :

• Analyseur lexical (lexer) — découpage du code source en tokens.
• Parser — construction d'un arbre syntaxique abstrait (AST) en utilisant la descente récursive et la méthode de Pratt (Pratt parser).
• Système d'objets — représentation des valeurs (nombres, chaînes, booléens, fonctions, tableaux, hashs).
• Évaluateur (eval) — parcours de l'AST et exécution des expressions et instructions.
• Fermetures et fonctions de première classe — implémentation des portées et des fermetures.
• Fonctions intégrées — ajout d'opérations standard (len, puts, first, rest, etc.).
• Système de types — typage dynamique avec vérifications à l'exécution.

Chaque chapitre se termine par un code fonctionnel qui peut être testé immédiatement. Au final, le lecteur obtient un interpréteur capable d'exécuter des programmes en Monkey — un langage dont la syntaxe rappelle un mélange de C, JavaScript et Python.

À qui s'adresse ce livre

Ce livre sera utile :

• Aux développeurs Go souhaitant approfondir leur compréhension du langage et de ses capacités.
• Aux programmeurs intéressés par les compilateurs — ceux qui veulent comprendre comment fonctionnent les parsers et les interpréteurs.
• Aux étudiants et enseignants — comme complément pratique aux cours sur les langages de programmation.
• À tout développeur souhaitant créer son propre langage ou DSL (langage dédié).

Important : le livre n'enseigne pas Go à partir de zéro — le lecteur doit savoir programmer en Go à un niveau intermédiaire (connaître les structures, les interfaces, les pointeurs ; les goroutines ne sont pas nécessaires).

Ce que le lecteur apprendra

Après avoir lu ce livre, vous serez capable de :

• Écrire un lexer à partir de zéro, découpant les chaînes en tokens.
• Implémenter un parser par descente récursive avec priorités des opérateurs.
• Construire et parcourir un AST.
• Créer un système de valeurs et d'environnements (contextes d'exécution).
• Implémenter des fermetures et des fonctions d'ordre supérieur.
• Ajouter le support des tableaux, hashs et opérations sur les chaînes.
• Comprendre le fonctionnement de la dispatch dynamique et de la gestion des erreurs.
• Obtenir un code d'interpréteur prêt à l'emploi, pouvant être étendu.

Points forts du livre

Orientation pratique. Chaque concept est immédiatement accompagné de code. Vous ne lisez pas simplement de la théorie — vous écrivez un interpréteur ligne par ligne.

Exposé progressif. Le livre est divisé en petits chapitres, chacun ajoutant une nouvelle fonctionnalité. Cela permet de revenir facilement aux sections précédentes.

Code Go propre. L'auteur utilise un Go idiomatique, des interfaces et la composition, rendant le code à la fois pédagogique et professionnel.

Absence de théorie superflue. Contrairement au « Dragon » (Aho, Lam, Sethi, Ullman), il n'y a ici ni grammaires formelles ni démonstrations — seulement ce qui est nécessaire pour un interpréteur fonctionnel.