Dynamische und Lexikalische Variablen in Common Lisp

Wenn eine variable ist lexikalisch Gültigkeitsbereich, das system schaut nach, wo die Funktion ist definiert um den Wert zu finden für eine freie variable. Wenn eine variable ist dynamisch scoped, das system schaut nach, wo die Funktion ist genannt, um den Wert für die freie variable. Variablen in Common Lisp sind alle lexikalischen standardmäßig; jedoch dynamisch Gültigkeitsbereich Variablen definiert werden können, auf der obersten Ebene mit defvar oder defparameter.

Ein einfacheres Beispiel

lexikalische scoping (mit setq):

(setq x 3)

(defun foo () x)

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

dynamischen scoping (mit defvar):

(defvar x 3)

(defun foo () x)

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

Wie funktioniert das wissen lassen wenn eine variable lexikalische oder dynamische? Es nicht. Auf der anderen Seite, wenn foo geht um den Wert von X, wird es zunächst finden, der lexikalische Wert definiert, auf der obersten Ebene. Es überprüft dann, ob die variable soll dynamisch sein. Wenn es so ist, dann foo sieht an die aufrufende Umgebung, die in diesem Fall verwendet lassen Sie überschatten den Wert von X auf 4.

(Hinweis: dies ist eine starke Vereinfachung, aber es wird Ihnen helfen zu visualisieren, den Unterschied zwischen den verschiedenen scoping-Regeln)

Vielleicht wird in diesem Beispiel helfen.

;; 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

Schreiben Beispiel von 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

Noch eine weitere tolle Erklärung, die von Auf Lisp, Kapitel 2.5 Umfang:

Common Lisp ist ein lexikalisch Gültigkeitsbereich Lisp. Schema ist die älteste Dialekt mit lexikalischen Umfang; vor der Regelung, Dynamikumfang wurde als eines der entscheidenden Merkmale von Lisp.

Den Unterschied zwischen lexikalischem und dynamischen Umfang kommt darauf an, wie eine Implementierung befasst sich mit freien Variablen. Ein symbol ist gebunden in einem Ausdruck, wenn festgestellt wurde, als eine variable, die entweder durch die als parameter oder variable-binding Operatoren wie lassen und zu tun. Symbole, die nicht gebunden sind, sagte, um frei zu sein. In diesem Beispiel scope ins Spiel kommt:

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

Innerhalb der defun-Ausdruck ist x gebunden und y frei ist. Freie Variablen sind interessant, weil es nicht offensichtlich ist, was Ihre Werte sein sollen. Es gibt keine Unsicherheit über den Wert einer gebundenen variable—als-scope-test aufgerufen wird, wird der Wert von x sollte alles sein, was übergeben wird, als argument. Was aber soll der Wert von y? Diese Frage beantwortet der Dialekt Umfang zu Regeln.

In einem dynamisch scoped Lisp, um den Wert zu finden, der eine freie variable bei der Ausführung von-scope-test schauen wir zurück durch die Kette von Funktionen, die es aufgerufen. Wenn wir Sie finden eine Umgebung, wo y gebunden war, die Bindung von y wird die in-scope-test. Wenn wir keine finden, nehmen wir den globalen Wert von y. So, in einem dynamisch scoped Lisp, y hätte den Wert, den es hatte in der aufrufenden Ausdruck:

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

Mit dynamischen scope, es bedeutet nichts, dass y gebunden war um 7 bei der scope-test definiert wurde. Alles, was zählt, ist, dass y hatte einen Wert von 5 bei der scope-test aufgerufen wurde.

In einem lexikalisch Gültigkeitsbereich Lisp, anstatt auf der Suche zurück durch die Kette der aufrufenden Funktionen, wir blicken zurück, durch die mit Umgebungen an der Zeit die Funktion definiert wurde. In einem lexikalisch Gültigkeitsbereich Lisp, unserem Beispiel fangen würde, die Bindung von y-scope-test definiert wurde. Also das ist, was passieren würde, in Common Lisp:

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

Hier die Bindung von y auf 5 zu der Zeit des Anrufs hat keine Auswirkungen auf den zurückgegebenen Wert.

Obwohl Sie können immer noch dynamischen Gültigkeitsbereich durch die Deklaration einer variable besonderes zu sein, lexikalische Bereich ist der Standard in Common Lisp. Auf der ganzen, der Lisp-community scheint Sicht die übergabe von dynamischen Bereich mit wenig bedauern. Für eine Sache, die es verwendet, um führen zu schrecklich schwer bugs. Aber lexikalischen Umfang ist mehr als ein Weg zur Vermeidung von Fehlern. Wie der nächste Abschnitt zeigen wird, macht es auch möglich, einige neue Programmiertechniken.