Dynamique et Lexicales variables en Common Lisp

Lorsqu'une variable est lexicalement étendue, le système ressemble à l'endroit où la fonction est défini pour trouver la valeur d'une variable indépendante. Lorsqu'une variable est de façon dynamique étendue, le système ressemble à l'endroit où la fonction est appelé pour trouver la valeur de la variable indépendante. Les Variables en Common Lisp sont tous lexicale par défaut; toutefois, de façon dynamique étendue variables peuvent être définies au plus haut niveau à l'aide de defvar ou defparameter.

Un exemple plus simple

portée lexicale (avec setq):

(setq x 3)

(defun foo () x)

(let ((x 4)) (foo)) ; returns 3

dynamique de la portée (avec defvar):

(defvar x 3)

(defun foo () x)

(let ((x 4)) (foo)) ; returns 4

Comment le savoir si une variable est lexicales ou dynamique? Il ne le fait pas. D'autre part, lorsque toto va trouver la valeur de X, il va d'abord trouver le lexique de la valeur définie au niveau supérieur. Ensuite, il vérifie si la variable est censé être dynamique. Si c'est le cas, foo ressemble à l'appel de l'environnement, qui, dans ce cas, utilise le laisser faire de l'ombre à la valeur de X à 4.

(note: ceci est une simplification excessive, mais il vous aidera à visualiser la différence entre les différentes règles de portée)

Peut-être cet exemple va nous aider.

;; the lexical version
(let ((x 10)) 
(defun lex-foo ()
(format t "Before assignment~18tX: ~d~%" x)
(setf x (+ 1 x))
(format t "After assignment~18tX: ~d~%" x)))
(defun lex-bar ()
(lex-foo)
(let ((x 20)) ;; does not do anything
(lex-foo))
(lex-foo))
;; CL-USER> (lex-bar)
;; Before assignment X: 10
;; After assignment  X: 11
;; Before assignment X: 11
;; After assignment  X: 12
;; Before assignment X: 12
;; After assignment  X: 13
;; the dynamic version
(defvar *x* 10)
(defun dyn-foo ()
(format t "Before assignment~18tX: ~d~%" *x*)
(setf *x* (+ 1 *x*))
(format t "After assignment~18tX: ~d~%" *x*))
(defun dyn-bar()
(dyn-foo)
(let ((*x* 20))
(dyn-foo))
(dyn-foo))
;; CL-USER> (dyn-bar)
;; Before assignment X: 10
;; After assignment  X: 11
;; Before assignment X: 20
;; After assignment  X: 21
;; Before assignment X: 11
;; After assignment  X: 12
;; the special version
(defun special-foo ()
(declare (special *y*))
(format t "Before assignment~18tX: ~d~%" *y*)
(setf *y* (+ 1 *y*))
(format t "After assignment~18tX: ~d~%" *y*))
(defun special-bar ()
(let ((*y* 10))
(declare (special *y*))
(special-foo)
(let ((*y* 20))
(declare (special *y*))
(special-foo))
(special-foo)))
;; CL-USER> (special-bar)
;; Before assignment X: 10
;; After assignment  X: 11
;; Before assignment X: 20
;; After assignment  X: 21
;; Before assignment X: 11
;; After assignment  X: 12

Exemple de réécriture à partir de PCL.

;;; Common Lisp is lexically scoped by default.
λ (setq x 10)
=> 10
λ (defun foo ()
(setf x (1+ x)))
=> FOO
λ (foo)
=> 11
λ (let ((x 20))
(foo))
=> 12
λ (proclaim '(special x))
=> NIL
λ (let ((x 20))
(foo))
=> 21

Encore une autre explication de Sur Lisp, chapitre 2.5 Portée:

Common Lisp est un lexicalement étendue de Lisp. Le schéma est le plus ancien dialecte portée lexicale; avant Régime dynamique de la portée a été considéré comme l'un des traits caractéristiques du Lisp.

La différence entre lexique et dynamique de la portée dépend de la façon dont une mise en œuvre traite de variables libres. Un symbole est lié à une expression si elle a été établie comme une variable, soit en apparaissant comme un paramètre ou d'une variable de liaison des opérateurs tels que que et ne. Les symboles qui ne sont pas liés sont dit d'être libre. Dans cet exemple, la portée entre en jeu:

(let ((y 7)) 
(defun scope-test (x)
(list x y)))

Dans le defun expression, x est lié et y est gratuit. Variables libres sont intéressants parce qu'il n'est pas évident que leurs valeurs doivent être. Il n'y a pas d'incertitude sur la valeur d'une variable liée—lors de champ-test est appelée, la valeur de x doit être tout ce qui est passé comme argument. Mais quelle doit être la valeur de y? C'est la réponse à la question par le dialecte du champ d'application des règles.

Dans la dynamique d'une étendue de Lisp, pour trouver la valeur d'une variable lors de l'exécution de champ-test, nous regardons en arrière à travers la chaîne de fonctions qui l'a appelée. Lorsque nous trouvons un environnement où y était lié, que la liaison de y sera celui utilisé dans le champ d'application de test. Si nous trouvez pas, nous prenons la valeur globale de y. Ainsi, dans la dynamique d'une étendue de Lisp, y aurait de la valeur qu'il avait dans l'appel de l'expression:

> (let ((y 5)) (scope-test 3))
(3 5)

Avec dynamique de la portée, cela signifie que rien de ce qui y était lié à 7 lors de champ-test a été défini. Tout ce qui compte c'est que y'avait une valeur de 5, lorsque le champ d'application-test a été appelé.

Dans un lexicalement étendue de Lisp, au lieu de regarder en arrière à travers la chaîne de l'appel de fonctions, nous regardons en arrière à travers les environnements contenant à la fois la fonction a été définie. Dans un lexicalement étendue de Lisp, par exemple, serait attraper la liaison de y où la portée de test a été défini. Donc, c'est ce qui serait le cas en Common Lisp:

> (let ((y 5)) (scope-test 3))
(3 7)

Ici la liaison de y à 5 à l'heure de l'appel n'a aucun effet sur la valeur retournée.

Mais vous pouvez toujours obtenir la dynamique portée par la déclaration d'une variable spéciale, portée lexicale est la valeur par défaut en Common Lisp. Dans l'ensemble, la communauté Lisp semble à la vue de l'adoption de la dynamique de la portée avec un peu de regret. Pour une chose, il a utilisé pour mener à horriblement insaisissable bugs. Mais la portée lexicale est plus qu'un moyen d'éviter les bugs. La prochaine section va montrer, il rend également possible que certaines nouvelles techniques de programmation.