Comprensione dei simboli non integrati e dell'espansione macro?

Voglio dimostrare la mia mancanza di conoscenza con un esempio.

Utilizzando le seguenti due definizioni macro,

(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 prima macro ombreggia qualsiasi variabile denominata maxche può verificarsi nel corpo e la seconda no, che può essere mostrata con il seguente esempio:

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

Per quanto ho imparato, la valutazione di una chiamata macro funziona in questo modo:

La macro viene valutata due volte. Innanzitutto il corpo viene valutato e restituisce un modulo. Questo modulo viene quindi valutato di nuovo.

Fin qui tutto bene.

Ma se suppongo che la macro restituisca davvero una porzione di testo che sembra essere una forma lisp, che viene poi interpretata, ottengo un conflitto che mi rende incapace di capire l'esempio sopra.

Quale pezzo di testo make-symbolrestituisce la seconda macro che utilizza , in modo che non si verifichino ombre? Nella mia comprensione, avrebbe senso un nome di simbolo scelto a caso estremamente estremo.

Se uso pp-macroexpand...entrambe le macro restituisco la stessa espansione.

Qualcuno è in grado di aiutarmi a uscire da questa confusione?

Come menzionato nei commenti, devi attivare questa impostazione per vedere come la macro-espansione funziona in modo più preciso. Nota che cambia solo il modo in cui macroexpandviene visualizzato, le macro funzionano ancora allo stesso modo in entrambi i casi:

(setq print-gensym t)

Quindi la prima istanza si espande in (errato):

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

E il secondo si espande in (corretto):

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

Per comprendere ulteriormente la differenza, considera di valutare questo:

(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

Come puoi vedere, il risultato di (make-symbol "max")non ha valore. Ciò garantisce la correttezza del primo passaggio di valutazione sulla macro. Con il secondo passaggio di valutazione, #:maxacquisisce un valore poiché è ora associato come variabile dinamica.