Nicht-interne Symbole und Makro-Erweiterung verstehen?

Ich möchte meinen Mangel an Wissen anhand eines Beispiels demonstrieren.

Verwenden Sie die folgenden zwei Makrodefinitionen:

(defmacro for (var from init to final do &rest body)
  "Execute a simple for loop: (for i from 1 to 10 do (print i))."
  (let ((tempvar 'max))
    `(let ((,var ,init)
           (,tempvar ,final))
       (while (<= ,var ,tempvar)
         ,@body
         (setq ,var (1+ ,var))))))

(defmacro for (var from init to final do &rest body)
  "Execute a simple for loop: (for i from 1 to 10 do (print i))."
  (let ((tempvar (make-symbol "max")))
    `(let ((,var ,init)
           (,tempvar ,final))
       (while (<= ,var ,tempvar)
         ,@body
         (setq ,var (1+ ,var))))))

Das erste Makro schattiert alle benannten Variablen, maxdie im Körper auftreten können, und das zweite nicht, was anhand des folgenden Beispiels gezeigt werden kann:

(let ((max 0)) ;; this variable is shadowed if the first macro defintion is used
  (for i from 1 to 3 do
       (setq square (* i i))
       (if (> square max) 
         (princ (format "\n%d %d" i square)))))

Soweit ich erfahren habe, funktioniert die Auswertung eines Makroaufrufs folgendermaßen:

Das Makro wird zweimal ausgewertet. Zuerst wird der Körper ausgewertet und gibt ein Formular zurück. Dieses Formular wird dann erneut ausgewertet.

So weit, ist es gut.

Wenn ich jedoch davon ausgehe, dass das Makro wirklich einen Textblock zurückgibt, der zufällig eine Lisp-Form ist und dann interpretiert wird, entsteht ein Konflikt, der mich dazu bringt, das obige Beispiel nicht zu verstehen.

Welchen Textblock gibt das zweite Makro, das make-symbolreturn verwendet, so dass keine Schattenbildung auftritt? Nach meinem Verständnis wäre ein extrem unwahrscheinlicher, zufällig gewählter Symbolname sinnvoll.

Wenn ich pp-macroexpand...beide Makros verwende, wird dieselbe Erweiterung zurückgegeben.

Kann mir jemand aus dieser Verwirrung helfen?

Wie in den Kommentaren erwähnt, müssen Sie diese Einstellung aktivieren, um zu sehen, wie die Makroerweiterung genauer funktioniert. Beachten Sie, dass sich nur die macroexpandAnzeige ändert . Die Makros funktionieren in beiden Fällen immer noch gleich:

(setq print-gensym t)

Dann wird die erste Instanz auf (falsch) erweitert:

(let ((max 0))
  (let ((i 1)
        (max 3))
    (while (<= i max)
      (setq square (* i i))
      (if (> square max)
          (princ
           (format "\n%d %d" i square)))
      (setq i (1+ i)))))

Und der zweite erweitert sich zu (richtig):

(let ((max 0))
  (let
      ((i 1)
       (#:max 3))
    (while
        (<= i #:max)
      (setq square
            (* i i))
      (if
          (> square max)
          (princ
           (format "\n%d %d" i square)))
      (setq i
            (1+ i)))))

Um den Unterschied besser zu verstehen, sollten Sie Folgendes bewerten:

(setq max 10)
;; => 10
(symbol-value 'max)
;; => 10
(symbol-value (make-symbol "max"))
;; => Caught unbound variable #:max, setting it to nil.
(make-symbol "max")
;; => #:max
(eq (make-symbol "max")
    (make-symbol "max"))
;; => nil

Wie Sie sehen können, hat das Ergebnis von (make-symbol "max")keinen Wert. Dies stellt die Richtigkeit des ersten Auswertungsdurchlaufs des Makros sicher. Erhält mit dem zweiten Auswertungsdurchgang #:maxeinen Wert, da er jetzt als dynamische Variable gebunden ist.