Блог

У меня есть код, подобный этому:

 (define-syntax macron
  (syntax-rules ()
    ((_ name)
     (lambda (x)
       (eval (cons 'name x) (interaction-environment))))))

(define x (map (macron lambda)
               '(((x) (display x)) ((a b) (  a b)))))

(let ((square (car x)) 
      (sum (cadr x))) 
  (display (square 10)) 
  (newline) 
  (display (sum 1 2 3)) 
  (newline))
  

код работает, он использует макрос в качестве значения, оборачивая его лямбдой. Мой вопрос в том, как я могу поместить внутри макроса синтаксических правил литеральный символ 'name вместо (cons 'lambda ...) , чтобы выходной код был:

 (lambda (x)
  (eval (cons 'name x) (interaction-environment)))
  

таким образом, это работает с кодом, подобным этому:

 (define (name x)
  (display x)
  (newline))

(for-each (macron lambda) ;; lambda can be anything
          '((1) (2) (3)))
  

и он печатает все числа.

Я знаю, что могу изменить имя в шаблоне на что-то другое, но я хочу узнать больше о правилах синтаксиса и его крайних случаях. Итак, возможно ли иметь имя, если я использую его в качестве шаблона ввода?

Я ищу ответы с R7RS, в которых рассмотрено больше подобных крайних случаев.

Все макросы выполняются во время компиляции, поэтому материал во время выполнения может не существовать. Это означает, что вы должны думать об этом как о синтаксическом сахаре и использовать его как susch. например.

 (for-each (macron something) '((1) (2) (3)))
  

Затем должно быть расширение, основанное на этом. Ваше текущее расширение заключается в том, что оно превращается в это:

 (for-each (lambda (x)
            (eval (cons 'someting x) (interaction-environment))
          '((1) (2) (3)))
  

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

 (define (macron-proc name)
  (lambda (x)
    (eval (cons name x) (interaction-environment))))

(for-each (macron-proc 'something) '((1) (2) (3)))
  

Я создал язык программирования, в котором были сносные макросы:

 (define xor (flambda (a b) `(if ,a (not ,b) ,b)))
(define (fold comb init lst)
  (if (null? lst)
      init
      (fold comb (comb (car lst) init) (cdr lst))))
(fold xor #f '(#t #t)) ; ==> #f
  

Это не очень хороший подход, если вы нацелены на эффективный скомпилированный конечный продукт. Первые макросы действительно были такими, и они удалили его в LISP 1.5 до Common Lisp. Схема избегала макросов в течение многих лет и выбрала syntax-rules в R4RS в качестве необязательной функции. R6RS — единственная версия, которая имеет полнофункциональные макросы.

С процедурой вместо макросов это фактически то же самое, что и следующий код с удаленным bad eval :

 (for-each (lambda (x)
            (apply something x))
          '((1) (2) (3)))
  

Что означает, что вы можете реализовать macron намного проще:

 (define-syntax macron
  (syntax-rules ()
    ((_ name)
     (lambda (x)
       (apply name x)))))
  

Но, глядя на это сейчас, вам вообще не нужен макрос. Это частичное применение.

 (define (partial proc arg)
  (lambda (lst)
    (apply proc arh lst)))

(map (partial   3) '((1 2) (3 4) (4 5)))
; ==> (6 10 12)
  

На самом деле существует SRFI-26 с именем cut / cute , который позволяет нам сделать что-то подобное, где он оборачивает это в лямбда:

 (map (cut apply   3 <>) '((1 2) (3 4) (4 5)))
  

syntax-rules — это макросы с наименьшей мощностью. Вы не можете делать ничего негигиеничного, и вы не можете создавать новые идентификаторы на основе других. Например. «невозможно реализовать стиль racket, struct где вы можете выполнять (struct complex [real imag]) и создавать макрос complex? , complex-real и complex-imag как процедуры. Вам нужно поступить так, как это делает SRFI-57, и потребовать от пользователя указать все имена, чтобы вам не нужно было объединять с новыми идентификаторами.

Прямо сейчас R7RS-small имеет только syntax-rules . Я думаю, что было ошибкой не использовать более мощный макрос в качестве альтернативы, поскольку теперь R7RS-large не может быть реализован с помощью R7RS-small.