Comprendre les symboles non intransigeants et l'expansion des macros?

Je veux démontrer mon manque de connaissances avec un exemple.

En utilisant les deux définitions de macro suivantes,

(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))))))

la première macro masque toutes les variables nommées maxqui peuvent se produire dans le corps et la seconde non, ce qui peut être montré avec l'exemple suivant:

(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)))))

Pour autant que j'ai appris l'évaluation d'un macro appel fonctionne comme ceci:

La macro est évaluée deux fois. Le corps est d'abord évalué et retourne un formulaire. Ce formulaire est ensuite évalué à nouveau.

Jusqu'ici tout va bien.

Mais si je suppose que la macro renvoie vraiment un morceau de texte qui se trouve être une forme lisp, qui est ensuite interprétée, j'obtiens un conflit qui me rend incapable de comprendre l'exemple ci-dessus.

Quel morceau de texte la deuxième macro qui utilise make-symbolretourne-t-elle, afin qu'il n'y ait pas d'observation À mon avis, un nom de symbole choisi au hasard extrêmement improbable aurait du sens.

Si j'utilise les pp-macroexpand...deux macros, renvoyez la même extension.

Est-ce que quelqu'un peut m'aider à sortir de cette confusion?

Comme mentionné dans les commentaires, vous devez activer ce paramètre pour voir comment la macro-expansion fonctionne plus précisément. Notez que cela ne change que la façon dont macroexpandest affiché, les macros fonctionnent toujours de la même façon dans les deux cas:

(setq print-gensym t)

Ensuite, la première instance se développe en (incorrect):

(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)))))

Et le second se développe pour (corriger):

(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)))))

Pour mieux comprendre la différence, envisagez d'évaluer ceci:

(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

Comme vous pouvez le voir, le résultat de (make-symbol "max")n'a aucune valeur. Cela garantit l'exactitude de la première passe d'évaluation sur la macro. Avec la deuxième passe d' #:maxévaluation , gagne une valeur car elle est maintenant liée en tant que variable dynamique.