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.

Programmation Scheme

Version imprimable

[ Modifier le sommaire ]

La boucle d'évaluation

Récursivité

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

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

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

Dans Wikipédia

La boucle d'évaluation < ↑ > Récursivité