我有一个一般性的问题，我应该如何去做并创建适当的宏扩展函数或宏。
这是我在 LIPS 解释器中宏的定义(您可以在此处测试它 https://jcubic.github.io/lips/)
function macro_expand(single) {
return async function(code, args) {
var env = args['env'] = this;
async function traverse(node) {
if (node instanceof Pair && node.car instanceof Symbol) {
try {
var value = env.get(node.car);
if (value instanceof Macro && value.defmacro) {
var result = await value.invoke(node.cdr, args, true);
if (result instanceof Pair) {
return result;
}
}
} catch (e) {
// ignore variables
}
}
var car = node.car;
if (car instanceof Pair) {
car = await traverse(car);
}
var cdr = node.cdr;
if (cdr instanceof Pair) {
cdr = await traverse(cdr);
}
var pair = new Pair(car, cdr);
return pair;
}
var new_code = code;
if (single) {
return quote((await traverse(code)).car);
} else {
while (true) {
new_code = await traverse(code);
if (code.toString() === new_code.toString()) {
break;
}
code = new_code;
}
return quote(new_code.car);
}
};
}
问题是它是虚拟的宏扩展并忽略有关变量的错误，因此它无法计算宏准引用，因为它会抛出找不到变量的异常。所以我最终在我的扩展列表中使用了准报价(注意：最新版本中的代码甚至不会尝试扩展准报价，因为它被标记为不可展开)。
什么是编写宏扩展的方法？使用宏扩展函数时，我是否应该扩展评估函数以不同的方式工作？
我正在测试biwascheme如何创建这个函数，https://www.biwascheme.org/但它也不能像我希望这个函数那样工作：
它扩展：
biwascheme> (define-macro (foo name . body) `(let ((x ,(symbol->string name))) `(print ,x)))
biwascheme> (macroexpand '(foo bar))
=> ((lambda (x) (cons (quote print) (cons x (quote ())))) "bar")
biwascheme>
我希望它扩展到：
(let ((x "bar")) (quasiquote (print (unquote x))))
我的口齿不清的回归：
lips> (define-macro (foo name . body)
`(let ((x ,(symbol->string name))) `(print ,x)))
;; macroexpand is a macro
lips> (macroexpand (foo bar))
(quasiquote (let ((x (unquote (symbol->string name))))
(quasiquote (print (unquote x)))))
即使我quasiquote设置为可扩展，它也不会扩展准引用，因为它找不到名称，因此会抛出被宏扩展忽略的异常。
任何代码甚至是伪代码都有助于在我的 LISP 中编写此函数或宏。
编辑：
我已经开始更新我的代码以在评估函数中合并宏扩展，并在定义宏宏中进行了一项更改。当宏扩展被调用时，它不是第一次调用代码，这就是问题所在。
以前：
var rest = __doc__ ? macro.cdr.cdr : macro.cdr;
if (macro_expand) {
return rest.car;
}
var pair = rest.reduce(function(result, node) {
return evaluate(node, { env, dynamic_scope, error });
});
后：
var rest = __doc__ ? macro.cdr.cdr : macro.cdr;
var pair = rest.reduce(function(result, node) {
return evaluate(node, eval_args);
});
if (macro_expand) {
return quote(pair);
}
它现在可以正常工作，所以我的expand_macro宏工作正常，这就是您应该编写macro_expand的方式。
EDIT2：我进一步重构了代码，事实证明我不需要在定义宏宏中macro_exapnd代码，只需取消引号对(删除数据标志)。
这是一个用Racket编写的玩具宏扩展器，它处理CL风格的宏。 我在编写本文的过程中使用了 Racket 宏和其他工具，因此它本身不是自举的。 显然这样的事情可以做到，但这样做会更加毛茸茸的。
这样做的目的只是为了演示一个简单的宏扩展器是如何工作的：它在任何意义上都不是适合实际使用的东西。
特殊形式
首先，我们需要处理特殊形式。 特殊形式是具有神奇语义的东西。 这个扩展器对它们的工作原理有一个非常简单的概念：
特殊形式是- 复合形式，其第一个元素是特殊运算符;
- 表单其余部分的每个元素要么是某种未展开的特殊事物，要么是正常扩展的，这是通过在定义中说
expr来完成的;
完成 - 此操作的方式是通过一个相当无意识的模式匹配器完成的，这可能只是因为扩展器知道少量的特殊形式才足够。
因此，以下是特殊形式的定义，以及其中三种形式的定义：
(define special-patterns (make-hasheqv))
(define (special-pattern? op)
(and (symbol? op)
(hash-has-key? special-patterns op)))
(define (special-pattern op)
(hash-ref special-patterns op))
(define-syntax-rule (define-special-pattern (op spec ...))
(hash-set! special-patterns 'op '(op spec ...)))
(define-special-pattern (quote thing))
(define-special-pattern (lambda args expr ...))
(define-special-pattern (define thing expr ...))
(define-special-pattern (set! thing expr))
现在我们可以询问某物是否是一种特殊形式(代码中的特殊模式)并检索其模式：
> (special-pattern? 'lambda)
#t
> (special-pattern 'lambda)
'(lambda args expr ...)
请注意，像if这样的东西不是宏扩展器的特殊运算符，即使它们实际上是特殊的：在像(if test then else)这样的形式中，所有子窗体都应该被扩展，所以宏扩展器没有理由知道它们。 只有像lambda这样的事情，宏扩展器才需要了解某些子窗体不应该被扩展。
宏定义
宏是复合形式，其第一个元素被识别为命名宏。 对于每个这样的宏，都有一个宏扩展器函数，它将负责扩展表单：该函数传递整个表单。 有一些语法，这是define-macro的，它以类似于defmacro在CL中的方式包装这个函数(但没有&whole支持，或者支持arglist解构或任何类似的东西)。
(define macros (make-hasheqv))
(define (macro? op)
(and (symbol? op)
(hash-has-key? macros op)))
(define (macro op)
(hash-ref macros op))
(define-syntax-rule (define-macro (m arg ... . tail) form ...)
(hash-set! macros 'm (lambda (whole)
(apply (lambda (arg ... . tail) form ...)
(rest whole)))))
有了这个，我们可以定义一个简单的宏：这里有四个定义let.
首先，这是最基本的一个：它甚至不使用define-macro而是它变成的：外部函数获取整个形式，然后在它不是宏名称的位上调用内部函数。 然后内部函数费力地将(let ((x y) ...) ...)变成((lambda (x ...) ...) y ...)，这是let的正确展开。 (请注意，这些都不涉及CL的(let (x) ...))。
(hash-set! macros 'let
;; this is what define-macro turns into
(lambda (whole)
(apply (lambda (bindings . body)
(cons (cons 'lambda
(cons (map first bindings) body))
(map second bindings)))
(rest whole))))
现在这里是，但使用define-macro来减轻痛苦：
(define-macro (let bindings . body)
;; Really primitive version
(cons (cons 'lambda (cons (map first bindings) body))
(map second bindings)))
另一个版本使用list*让事情变得不那么可怕：
(define-macro (let bindings . body)
;; without backquote, but usung list* to make it a bit
;; less painful
(list* (list* 'lambda (map first bindings) body)
(map second bindings)))
最后是使用反引号(又名准引号)的版本。
(define-macro (let bindings . body)
;; with backquote
`((lambda ,(map first bindings) ,@body)
,@(map second bindings)))
以下是由于卫生故障而中断的prog1宏定义的版本：
(define-macro (prog1 form . forms)
;; Broken
`(let ([r ,form])
,@forms
r))
以下是您需要如何编写它以使其更卫生(尽管按照 Scheme 有些极端的标准，它仍然不卫生)：
(define-macro (prog1 form . forms)
;; Working
(let ([rn (string->uninterned-symbol "r")])
`(let ([,rn ,form])
,@forms
,rn)))
请注意，这个宏变成了另一个宏：它扩展到let：扩展器需要处理这个问题(它确实如此)。
宏扩展器
宏扩展器由两个功能组成：expand-macros是实际执行扩展的东西，它为特殊形式调度到expand-special。
这是expand-macros：
(define (expand-macros form)
;; expanding a form
(if (cons? form)
;; only compound forms are even considered
(let ([op (first form)])
(cond [(macro? op)
;; it's a macro: call the macro function & recurse on the result
(expand-macros ((macro op) form))]
[(special-pattern? op)
;; it's special: use the special expander
(expand-special form)]
[else
;; just expand every element.
(map expand-macros form)]))
form))
关于此的注意事项：
- 只有复合形式可以是宏观形式;
- 这是一个 Lisp-1，所以复合形式的汽车是完全正常的，可以是宏形式：
((let (...) ...) ...)很好; - 宏以递归方式扩展，直到无事可做。
这是expand-special：这比expand-macro要繁琐得多，而且可能是错误的：它试图做的是将特殊形式的定义与给定的形式相匹配。
(define (expand-special form)
;; expand a special thing based on a pattern.
(match-let* ([(cons op body) form]
[(cons pop pbody) (special-pattern op)])
(unless (eqv? op pop)
(error 'expand-special "~s is not ~s" pop op))
(let pattern-loop ([accum (list op)]
[tail body]
[ptail pbody]
[context 'expr])
(cond [(null? tail)
(unless (or (null? ptail)
(eqv? (first ptail) '...))
(error 'expand-special "~s is not enough forms for ~s"
body op))
(reverse accum)]
[(null? ptail)
(error 'expand-special "~s is too many forms for ~s"
body op)]
[else
(match-let* ([(cons btf btr) tail]
[(cons ptf ptr) ptail]
[ellipsis? (eqv? ptf '...)]
[ctx (if ellipsis? context ptf)]
[ptt (if ellipsis? ptail ptr)])
(pattern-loop (cons (if (eqv? ctx 'expr)
(expand-macros btf)
btf)
accum)
btr ptt ctx))]))))
这里繁琐的一点是省略号(...)的处理，它在匹配器中用于指示"这里有更多东西"：我不记得它是否可以处理省略号，这不是模式中的最后一件事，但我强烈怀疑不是。 请注意，尽管底层宏系统也使用省略号，但它们并不相关：这只是依赖于...是合法符号名称的事实。
另请注意，这当然会在需要时递归回expand-macros。
根据这些定义，我们现在可以扩展一些宏：
> (expand-macros '(let ((x y)) x))
'((lambda (x) x) y)
> (expand-macros '(prog1 a b))
'((lambda (r) b r) a)
请注意，Racket的打印机不会专门打印未经内部打印，但上述r是未内部打印的。
使用简单的跟踪实用程序，您可以定义宏扩展器的跟踪版本：
> (expand-macros '(let ([x 1]) (prog1 x (display "1"))))
[expand-macros (let ((x 1)) (prog1 x (display "1")))
[expand-macros ((lambda (x) (prog1 x (display "1"))) 1)
[expand-macros (lambda (x) (prog1 x (display "1")))
[expand-special (lambda (x) (prog1 x (display "1")))
[expand-macros (prog1 x (display "1"))
[expand-macros (let ((r x)) (display "1") r)
[expand-macros ((lambda (r) (display "1") r) x)
[expand-macros (lambda (r) (display "1") r)
[expand-special (lambda (r) (display "1") r)
[expand-macros (display "1")
[expand-macros display
-> display]
[expand-macros "1"
-> "1"]
-> (display "1")]
[expand-macros r
-> r]
-> (lambda (r) (display "1") r)]
-> (lambda (r) (display "1") r)]
[expand-macros x
-> x]
-> ((lambda (r) (display "1") r) x)]
-> ((lambda (r) (display "1") r) x)]
-> ((lambda (r) (display "1") r) x)]
-> (lambda (x) ((lambda (r) (display "1") r) x))]
-> (lambda (x) ((lambda (r) (display "1") r) x))]
[expand-macros 1
-> 1]
-> ((lambda (x) ((lambda (r) (display "1") r) x)) 1)]
-> ((lambda (x) ((lambda (r) (display "1") r) x)) 1)]
'((lambda (x) ((lambda (r) (display "1") r) x)) 1)
此处提供了此代码的版本。