Où vit une variable ? Qui peut la voir ? La réponse définit le comportement des fonctions.
⏱️ Durée : environ 95 minutes · 🎓 Niveau : intermédiaire · 🏅 Badge : Cartographe des noms
🎬 L'histoire
HashScript sait faire des boucles mais pas encore des fonctions. Kodi ajoute fun. Un bug étrange apparaît : une fonction lit x et obtient la valeur de celui qui l'appelle, au lieu de celui qui l'a écrite.
« Tu as implémenté la portée dynamique sans le savoir, dit Sam. La plupart des langages modernes utilisent la portée lexicale. La différence est subtile, mais elle change tout, y compris les fermetures. »
Tu implémentes les fonctions, la portée lexicale et les fermetures de HashScript.
🎯 Ta mission
À la fin, je serai capable de :
- distinguer portée lexicale et portée dynamique avec un exemple
- implémenter des environnements chaînés (parent)
- implémenter appels de fonctions,
returnet récursion - expliquer une fermeture (closure) et la coder
- gérer le masquage de variables (shadowing)
🧩 Défi d'échauffement (5 XP)
Tu lis dans un livre de cuisine : « Pour la sauce, utilise le sel ». Dans ta cuisine, il y a du sel fin ; dans la cuisine de ton voisin, du gros sel. Si tu envoies la recette au voisin, il utilise son sel. Maintenant, si tu écris sur la recette « le sel de la maison qui a écrit la recette », quel sel utilise-t-il ? Quelle est la différence entre « sel de celui qui exécute » et « sel de celui qui a écrit » ?
💡 Le concept
L'environnement
Un environnement associe des noms à des valeurs. Pour gérer les portées imbriquées, chaque environnement a un parent :
env global {x: 1, f: <fonction>}
└─ env de f {a: 10} parent = env global
└─ bloc {t: 3} parent = env de f
- Définir : dans l'environnement courant.
- Chercher : dans l'environnement courant, puis son parent, etc. jusqu'au global.
- Affecter : à l'environnement le plus proche qui contient déjà le nom.
Portée lexicale ou dynamique
Quand une fonction utilise une variable qui n'est ni un paramètre ni une variable locale, où la chercher ?
| Portée | Règle | Langages |
|---|---|---|
| Lexicale (statique) | dans les environnements où la fonction a été écrite | Python, JavaScript, Java, presque tous |
| Dynamique | dans l'environnement de l'appelant | anciens Lisp, shell, Perl (local) |
let x = 1;
fun f() { return x; }
fun g() { let x = 2; return f(); }
print g();
- Lexicale :
fvoit lexdu programme où elle a été écrite → 1. - Dynamique :
fvoit lexde l'appelantg→ 2.
La portée lexicale rend un programme lisible localement : on sait ce que fait f en regardant son texte, sans connaître ses appelants.
La fermeture (closure)
Une fermeture est une fonction accompagnée de l'environnement dans lequel elle a été créée. Quand on l'appelle, ses variables libres se résolvent dans cet environnement, même si la fonction qui l'a créée est terminée.
fun compteur() {
let c = 0;
fun incrementer() { c = c + 1; return c; }
return incrementer;
}
let a = compteur();
a(); a();
print a(); # 3 : 'c' a survécu à la fin de compteur()
Les fermetures permettent : des compteurs et générateurs, des fonctions de configuration, des rappels, de l'encapsulation de données privées.
Implémentation
class Environnement:
def __init__(self, parent=None):
self.vars, self.parent = {}, parent
def trouver(self, nom):
env = self
while env is not None:
if nom in env.vars:
return env
env = env.parent
return None
class Fermeture:
def __init__(self, fun, env):
self.fun, self.env = fun, env # la fonction ET son environnement de définition
Appeler une fonction :
- évaluer les arguments dans l'environnement de l'appelant ;
- créer un nouvel environnement dont le parent est celui de la fermeture (lexical) ;
- y définir les paramètres ;
- exécuter le corps ; un
returninterrompt l'exécution (on utilise une exception interneRetourne).
Pour la portée dynamique, il suffit de choisir comme parent l'environnement de l'appelant.
La récursion
Une fonction se retrouve elle-même car son nom est défini dans l'environnement où elle a été déclarée, et son corps s'exécute dans un environnement dont ce parent contient son propre nom.
Le masquage (shadowing)
Une variable déclarée dans une portée interne masque celle de même nom dans une portée externe, sans la modifier :
let x = 1;
if true { let x = 2; print x; } # 2
print x; # 1
Les pièges
- Capturer une variable de boucle : toutes les fermetures créées dans une boucle partagent la même variable.
- Récursion infinie : il faut une limite de profondeur.
- Affecter à une variable non déclarée : erreur, ou création implicite ? C'est un choix de conception (HashScript : erreur).
🔍 Exemple pas à pas
Problème : implémenter fonctions, fermetures et comparer portée lexicale / dynamique.
import operator
from hashscript import parser, Let, Assign, Print, Si, TantQue, Fun, Retour, Appel, Num, Bool, Var, Bin, Neg, ErreurLangage
OPS = {"+": operator.add, "-": operator.sub, "*": operator.mul, "/": operator.truediv,
"<": operator.lt, ">": operator.gt, "<=": operator.le, ">=": operator.ge,
"==": operator.eq, "!=": operator.ne}
class Env:
def __init__(self, parent=None):
self.vars, self.parent = {}, parent
def trouver(self, nom):
e = self
while e is not None:
if nom in e.vars: return e
e = e.parent
class Retourne(Exception):
def __init__(self, valeur): self.valeur = valeur
class Fermeture:
def __init__(self, fun, env): .fun, .env = fun, env
:
():
.portee, .sortie, .global_env = portee, [], Env()
.profondeur, .profondeur_max = , profondeur_max
():
.bloc(parser(source), .global_env)
.sortie
():
i instrs:
.executer(i, env)
():
(n, Let): env.[n.nom] = .evaluer(n.expr, env)
(n, Assign):
cible = env.trouver(n.nom)
cible : ErreurLangage(, n.ligne, n.col)
cible.[n.nom] = .evaluer(n.expr, env)
(n, Print): .sortie.append(.formater(.evaluer(n.expr, env)))
(n, Si): .bloc(n.alors .evaluer(n.cond, env) n.sinon, Env(env))
(n, TantQue):
.evaluer(n.cond, env):
.bloc(n.corps, Env(env))
(n, Fun): env.[n.nom] = Fermeture(n, env)
(n, Retour): Retourne(.evaluer(n.expr, env))
: .evaluer(n, env)
():
(n, (Num, Bool)): n.valeur
(n, Var):
e = env.trouver(n.nom)
e : ErreurLangage(, n.ligne, n.col)
e.[n.nom]
(n, Neg): -.evaluer(n.expr, env)
(n, Bin):
a, b = .evaluer(n.gauche, env), .evaluer(n.droite, env)
n.op == b == : ErreurLangage(, n.ligne, n.col)
OPS[n.op](a, b)
(n, Appel):
f = .evaluer(n.fonction, env)
(f, Fermeture): ErreurLangage(, n.ligne, n.col)
(n.args) != (f.fun.params):
ErreurLangage(, n.ligne, n.col)
valeurs = [.evaluer(a, env) a n.args]
parent = f.env .portee == env
local = Env(parent)
nom, v (f.fun.params, valeurs): local.[nom] = v
.profondeur +=
.profondeur > .profondeur_max:
ErreurLangage(, n.ligne, n.col)
:
.bloc(f.fun.corps, local)
Retourne r:
r.valeur
:
.profondeur -=
ErreurLangage(, , )
():
v :
v :
(v, ) v == (v): ((v))
(v)
Interprete().lancer() == []
compteur =
(Interprete().lancer(compteur))
programme =
(, Interprete().lancer(programme))
(, Interprete().lancer(programme))
Lecture :
aetbsont deux fermetures issues du mêmecompteur, mais avec deux environnements distincts (chaque appel decompteur()crée son proprec) ;- en portée lexicale,
frenvoie 1 (lexvisible là oùfest écrite) ; en dynamique, 2 (lexde l'appelant) ; - une récursion de profondeur maximale est interceptée par une erreur claire.
✍️ À toi, avec aide (10 XP)
Écris en HashScript (puis exécute avec l'interpréteur de l'exemple) :
- une fonction
additionneur(n)qui renvoie une fonction ajoutantnà son argument ; vérifie queadditionneur(5)(10)vaut 15 (l'appel chaîné est supporté par le parseur) ; - une fonction
fois_n(n)qui renvoie une fonction multipliant parn, puis une fonctioncomposer(f, g)qui renvoie une fonction appliquantgpuisf.
Teste composer(additionneur(1), fois_n(3))(4) (attendu : 13).
💡 Indice 1
Une fonction peut déclarer une autre fonction à l'intérieur et la renvoyer avec return nom;.
💡 Indice 2
Les paramètres sont des variables locales : les fonctions internes les capturent.
💡 Indice 3
Pour composer : fun composer(f, g) { fun h(x) { return f(g(x)); } return h; }.
✅ Réponse
# (Interprete de l'exemple)
programme = '''
fun additionneur(n) { fun ajoute(x) { return x + n; } return ajoute; }
fun fois_n(n) { fun multiplie(x) { return x * n; } return multiplie; }
fun composer(f, g) { fun h(x) { return f(g(x)); } return h; }
print additionneur(5)(10);
let g = composer(additionneur(1), fois_n(3));
print g(4);
'''
assert Interprete().lancer(programme) == ["15", "13"]
print("fermetures composées ok")
Chaque appel à additionneur, fois_n et composer crée un nouvel environnement qui capture ses paramètres : n, f, g survivent aussi longtemps que les fonctions renvoyées.
🚀 À toi, en solo (20 XP)
Pile d'appels et traceback. Améliore l'interpréteur pour qu'une erreur d'exécution dans une fonction indique la chaîne d'appels :
erreur ligne 2, colonne 24 : division par zéro
appelée depuis g (ligne 3)
appelée depuis f (ligne 5)
appelée depuis <programme> (ligne 7)
- Maintiens une pile
(nom_de_fonction, ligne_de_l_appel). - Quand une
ErreurLangagetraverse un appel, ajoute-lui un attributpile(copie de la pile à ce moment). - Écris
afficher_traceback(erreur)et teste avec trois fonctions imbriquées.
✅ Pistes de correction
# (Interprete de l'exemple, étendu)
class InterpreteTraceback(Interprete):
def __init__(self, **kw):
super().__init__(**kw)
self.pile = [] # (nom, ligne de l'appel)
def evaluer(self, n, env):
if isinstance(n, Appel):
f = None
try:
f = self.evaluer(n.fonction, env)
except ErreurLangage:
raise
nom = f.fun.nom if isinstance(f, Fermeture) else "?"
self.pile.append((nom, n.ligne))
try:
return super().evaluer(n, env)
except ErreurLangage as e:
if not hasattr(e, "pile"):
e.pile = list(self.pile)
raise
finally:
self.pile.pop()
return ().evaluer(n, env)
():
lignes = []
pile = (e, , [])
i ((pile) - , -, -):
appelant = pile[i - ][] i >
lignes.append()
.join(lignes)
source =
:
InterpreteTraceback().lancer(source)
ErreurLangage e:
(afficher_traceback(e))
⚠️ Pièges classiques
| Piège | Pourquoi c'est un problème | Comment l'éviter |
|---|---|---|
| Parent = appelant au lieu de définition | Portée dynamique involontaire, comportements surprenants | Une fermeture garde l'environnement où elle est définie |
| Un environnement partagé entre les appels | Les appels s'écrasent mutuellement (récursion fausse) | Un nouvel environnement par appel |
| Capturer la variable de boucle | Toutes les fermetures voient la dernière valeur | Créer une portée par itération |
| Pas de limite de profondeur | Plantage de la machine hôte (pile Python) | Compteur de profondeur et erreur claire |
🐉 Mini-boss (40 XP)
Récursion, mémoïsation et générateurs en HashScript. Écris, en HashScript, des programmes qui utilisent les fermetures :
- une fonction
memoisern'est pas possible sans structure de données : à la place, écrisfibonacciitératif avec une fermeture « état » (a,b) qui renvoie le terme suivant à chaque appel ; - un générateur de nombres pairs (fermeture avec compteur) ;
- une banque :
compte(solde)renvoie une fonctionoperation(montant)qui modifie le solde privé et le renvoie (les montants négatifs sont des retraits) ; deux comptes sont indépendants ; - une fonction d'ordre supérieur
appliquer_n(f, n, x)qui appliquefnfois ; - Vérifie chaque programme avec l'interpréteur lexical et montre au moins un cas où le mode dynamique donnerait un résultat différent (ou une erreur).
✅ Pistes de correction
Exemples de réponses (HashScript) :
fun suite() { let a = 0; let b = 1; fun suivant() { let r = a; let t = a + b; a = b; b = t; return r; } return suivant; }
let s = suite(); s(); s(); s(); print s(); # 3
fun pairs() { let n = 0 - 2; fun suivant() { n = n + 2; return n; } return suivant; }
fun compte(solde) { fun operation(m) { solde = solde + m; return solde; } return operation; }
let c1 = compte(100); let c2 = compte(50); c1(20); c2(0 - 10); print c1(0); print c2(0); # 120 40
fun appliquer_n(f, n, x) { let i = 0; while i < n { x = f(x); i = i + 1; } return x; }
fun double(x) { return x * 2; }
print appliquer_n(double, 5, 1); # 32
En portée dynamique, operation chercherait solde dans l'environnement de l'appelant (le programme principal), où solde n'existe pas : erreur « variable inconnue » — ce qui montre que les fermetures dépendent de la portée lexicale.
⚡ Quiz éclair (15 XP si 4/5 ou plus)
1. En portée lexicale, une variable libre d'une fonction est cherchée dans :
- A. l'environnement où la fonction a été définie
- B. l'environnement de l'appelant
- C. la mémoire globale uniquement
2. Une fermeture est :
- A. une fonction sans paramètre
- B. une fonction accompagnée de son environnement de définition
- C. un type de boucle
3. Le masquage (shadowing) signifie :
- A. une variable est supprimée
- B. une variable devient privée
- C. une variable interne cache une variable externe de même nom, sans la modifier
4. 🔁 Révision mission 06 : Un interpréteur d'arbre exécute un programme en :
- A. parcourant l'AST et appliquant une règle par type de nœud
- B. le traduisant en code machine à l'avance
- C. relisant le texte caractère par caractère
5. 🔁 Révision mission 06 : Une limite de pas protège contre :
- A. les erreurs de syntaxe
- B. les boucles infinies
- C. les variables inutilisées
✅ Réponses
- A.
- B.
- C.
- A.
- B.
🪞 Je réfléchis (10 XP)
- Dans ta vie, où une information dépend-elle du contexte où elle a été écrite plutôt que du contexte où elle est lue ?
- Quels usages des fermetures rencontres-tu déjà dans ton travail (rappels, configuration, décorateurs) ?
🎒 À retenir
- Environnements chaînés avec parent.
- Lexicale : parent = environnement de définition ; dynamique : parent = appelant.
- Fermeture = fonction + environnement capturé.
- Chaque appel crée un nouvel environnement.
- Limite de profondeur contre la récursion infinie.
flowchart LR
T(["Environnement, portée et fermetures"])
T --> R1["1. Environnements chaînés avec parent."]
T --> R2["2. Lexicale : parent = environnement de définition ; dynamique : parent…"]
T --> R3["3. Fermeture = fonction + environnement capturé."]
T --> R4["4. Chaque appel crée un nouvel environnement."]
T --> R5["5. Limite de profondeur contre la récursion infinie."]
Description du schéma : la mission au centre, reliée aux cinq idées à retenir.
🏅 Récompenses
Total possible : 100 XP · 🏅 Badge Cartographe des noms
← Mission 06 — L'interpréteur : faire vivre l'arbre · Mission 08 — Bytecode et machine virtuelle →
HEF-090 — Compilateurs et langages

