Apprendre à coder un langage en 7 lignes : le hack qui change tout

Pourquoi 7 lignes suffisent

La plupart des langages (Python, JavaScript, Haskell) cachent en réalité le même moteur : le lambda calcul. Créé par le mathématicien Alonzo Church, ce système repose sur trois idées seulement :

1. ▸Les variables : x
2. ▸Les fonctions anonymes : (λ x . x) — l'identité
3. ▸L'appel de fonction : ((λ x . x) valeur)

C'est tout. Pas de boucles, pas de nombres, pas de conditions. Et pourtant, c'est Turing-complet — tu peux calculer n'importe quoi.

L'interpréteur : eval et apply

Tout repose sur deux fonctions :

eval prend une expression et un environnement (un dictionnaire de variables), et retourne une valeur.

apply prend une fonction et un argument, et les assemble.

En Scheme :

(define (eval e env)
  (cond
    ((symbol? e) (cadr (assq e env)))
    ((eq? (car e) 'λ) (cons e env))
    (else (apply (eval (car e) env) (eval (cadr e) env))))))

(define (apply f x)
  (eval (cddr (car f)) (cons (list (cadr (car f)) x) (cdr f))))

Li première branche reconnaît une variable et la cherche dans l'environnement. La deuxième enveloppe une fonction lambda avec son environnement (une closure). La troisième évalue une application : d'abord la fonction, puis l'argument.

Pourquoi c'est une architecture puissante

Cette séparation eval/apply n'est pas accidentelle. C'est le patron du livre de référence Structure and Interpretation of Computer Programs. Elle passe à l'échelle :

• ▸7 lignes : lambda calcul pur (Turing-complet mais minimaliste).
• ▸100 lignes : un vrai sous-ensemble de Scheme avec conditions, boucles, mutations, variables globales.

Chaque ajout (if, let, letrec, set!) suit la même logique : une branche de correspondance de plus dans eval.

L'exercice concret

Si tu veux vraiment comprendre, essaie ceci :

1. ▸Copie le code Racket dans try.racket-lang.org.
2. ▸Teste ((λ x . x) 5) — retourne 5.
3. ▸Teste (((λ f . (λ x . (f x))) (λ a . a)) (λ b . b)) — un « composeur » de fonctions.

Ce qui paraît magique devient transparent quand tu vois eval traverser l'arbre d'expressions.

À retenir

Les langages que tu utilises tous les jours reposent sur ces fondations. Coder un interpréteur, c'est passer du statut de programmeur à celui de créateur de langages. Et ça prend 3 minutes.