Programmation Scheme/Variables globales et variables locales

Un livre de Wikilivres.
Sauter à la navigation Sauter à la recherche


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)) expr1expr_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) expr1expr_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 (var1var_n) expr1expr_n)(cst1cst_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  (var1var_n) expr1expr_n )))
;;; utilisation de la fonction
   (fct cst1cst_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



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