Написание макроса myletstar (гигиены) на схеме

Ваш второй самый близкий. Гигиенический макрос let* можно написать с помощью _ 2_. (Если вы пишете это в виде реализации схемы, а не рэкет, вы также можете просто составить define-syntax и syntax-rule для того же эффекта.)

(define-syntax-rule (let* ([x1 e1]
                           [x2 e2] ...)
                      body ...)
  (let ([x1 e1])
    (let* ([x2 e2] ...)
      body ...))

А если вы чувствуете себя по-настоящему педантичным, вы можете сделать гигиеничный let макрос:

(define-syntax-rule (let ([x e] ...)
                      body ...)
  ((lambda (x ...) body ...) e ...))

R6RS, Приложение B дает следующее определение из let*:

(define-syntax let*
  (syntax-rules ()
    ((let* () body1 body2 ...)
     (let () body1 body2 ...))
    ((let* ((name1 expr1) (name2 expr2) ...)
       body1 body2 ...)
     (let ((name1 expr1))
       (let* ((name2 expr2) ...)
         body1 body2 ...)))))

Что касается let*, я не думаю, что гигиена является проблемой. Имена в let, которые вы хотите раскрыть, и вы не вводите никаких других привязок.

(require compatibility/defmacro)
(define-macro let*1
  (lambda (assgn . body)
    (let loop ((lst assgn))
      (if (null? lst)
          `(begin ,@body)
          `((lambda (,(caar lst))
              ,(loop (cdr lst)))
            ,(cadar lst))))))

(expand-once 
 #'(let*1 
     ((a 1) (b 2) (c 3)) 
       (list a b c)))

; ==> #'((lambda (a)
;          ((lambda (b)
;            ((lambda (c)
;               (begin
;                 (list a b c)))
;             3))
;          2))
;       1)

Мне кажется, это нормально. Теперь вы можете сделать то же самое, используя syntax-rules. В этом методе не используется язык схем, и поэтому вы пытаетесь сделать (caar lst), и предполагается, что вы хотите это в результирующем расширении.

(expand-once #'(let*2 ((a 1) (b 2) (c 3)) (list a b c)))
; ==> #'(let loop ((lst '((a 1) (b 2) (c 3))))
;         (if (null? lst)
;             (list a b c)
;             ((lambda ((caar lst))
;                (loop (cdr lst)))
;              (cadar lst)
;              1)))

Обратите внимание, как ваш код на самом деле дословно копируется в получившееся раскрытие. Это потому, что предполагается, что все, что не деструктурируется в шаблоне, находится в лексической области самого синтаксиса. Вот как это сделать:

(define-syntax let*2
  (syntax-rules ()
    ;; handle stop condition (no more bindings)
    ((let*2 ()  body ...) 
     (begin body ...))
    ;; handle one expansion
    ((let*2 ((name expr) more-bindings ...) body ...)
     (let ((name expr))
       (let*2 (more-bindings ...)
         body ...))))) 
(expand-once 
 #'(let*2 
     ((a 1) (b 2) (c 3)) 
       (list a b c)))

; ==> #'((lambda (a) 
;          (let*2 ((b 2) (c 3)) 
;            (list a b c))) 1)

expand-once выполняет только один уровень, но, используя расширитель макросов, вы увидите, что он продолжается до тех пор, пока не будут развернуты все части.

Итак, когда вам нужна гигиена? Это когда вы вводите привязки в свой макрос. Стандартный пример - это обычно swap!, который меняет местами значения двух привязок:

(define-syntax swap!
  (syntax-rules ()
    ((swap! var1 var2)
     (let ((tmp var1))
       (set! var1 var2)
       (set! var2 tmp)))))

С syntax-rules каждая привязка не является шаблоном, хотя должна быть в лексической области макроса, и все, что не является новой привязкой, которая создается новой при каждом раскрытии. Таким образом, я могу спокойно сделать это:

(let ((tmp 1) (another 2))
  (swap! tmp another)
  (list tmp another))
; ==> (2 1)

В старом стиле вам понадобится следующее:

(define-macro swap!
  (lambda (var1 var2)
    (let ((tmp (gensym "tmp")))
      `(let ((,tmp ,var1))
         (set! ,var1 ,var2)
         (set! ,var2 ,tmp)))))

Это работает для приведенного выше примера, но если бы я сделал:

(let ((set! 1) (let 2))
  (swap! set! let)
  (list set! let))

Правила синтаксиса будут оцениваться как (2 1), а define-macro не будут работать.