Programmation Scheme/Variables globales et variables locales
Les variables (dont les fonctions) définies avec define sont globales, c'est-à-dire qu'elles existent en dehors de l'expression qui les a créées.
Si une variable ne doit être utilisée que dans l'expression et pas ailleurs, il est intéressant de la définir uniquement en local :
- elle ne mobilise pas de place en mémoire une fois l'expression évaluée ;
- on peut réutiliser le nom de la variable ailleurs sans risque de « collision » (cas de noms de variable classiques comme « i », « x », « foo » ou « toto ») ;
- cela facilite la récursivité : un même nom de variable est utilisé à « plusieurs niveaux » et peut avoir une valeur différente à chaque niveau.
Ceci se fait avec l'opération primitive let.
Définition de variables locales
[modifier | modifier le wikicode]Si des expressions expr1, expr2, …, expr_n contiennent des variables var1, var2, …, var_n et que l'on veut attribuer des valeurs constantes cst1, cst2, …, cst_n à ces variables, on utilise let :
(let ((var1 cst1) … (var_n cst_n)) expr1 … expr_n)
On a donc une liste de paires (variable constante) suivie d'une liste d'expressions.
- Exemple
scheme>(let ((x 1)) (+ x 1)) ⇒ 2 scheme>(+ x 1) ⇒ Error: variable x is not bound
- En notation infixée, l'expression donnerait « let x = 1 ; x+1 ».On voit ici que x n'est pas réutilisable en dehors de l'expression.
- Exemple
scheme>(let ((x 1)(y 5)) (+ x y) ) ⇒ 6
- En notation infixée, l'expression donnerait « let x = 1 ; let y = 5 ; x+y ».
Utilisation d'une expression à variables locales
[modifier | modifier le wikicode]Considérons des expressions faisant intervenir des variables. Si on veut que les valeurs des variables ne soient pas définies dans les expressions elles-mêmes, mais que les variables soient tout de même locales, on utilise lambda. Avec une seule variable var prenant la valeur cst, on a :
((lambda (var) expr1 … expr_n )(cst))
Les expressions expr1, …, expr_n peuvent éventuellement être des fonctions globales. Avec n variables var1, var2, …, var_n prenant les valeurs cst1, cst2, …, cst_n :
((lambda (var1 … var_n) expr1 … expr_n)(cst1 … cst_n))
On peut ainsi définir une procédure locale, en mettant l'expression totale dans une variable avec let :
(let ;;; définition de la fonction ((fct (lambda (var1 … var_n) expr1 … expr_n ))) ;;; utilisation de la fonction (fct cst1 … cst_n))
on n'a ici pour l'opération let qu'une seule paire (variable constante), la variable étant le nom de la fonction et la constante étant la fonction elle-même, les variables de la fonction étant définies avec lambda.
- Exemple
(let ((double (lambda (x) (* 2 x)))) (double 5)) ⇒ 10
Voir aussi
[modifier | modifier le wikicode]- Dans Wikipédia