SBCL 中奇怪的宏展开错误

Question

我想使用适用于 Windows x86_64 的 SBCL 1.3.3 在 Lisp 中编写一个斐波那契数计算函数 fib。使用惰性计算来避免重复。到目前为止的工作代码是：

(defvar *fibs* (make-hash-table))

(defun get-value (idx)
  (if (functionp (gethash idx *fibs*))
    (setf (gethash idx *fibs*)
      (funcall (gethash idx *fibs*)))
    (gethash idx *fibs*)))

(defun fib (n)
  (loop for i from 0 below n
    if (< i 2) do (setf (gethash i *fibs*) 1)
    else do (setf (gethash i *fibs*)
      (eval `(lambda () (+ (get-value ,(- i 2))
                           (get-value ,(- i 1)))))))
  (get-value (- n 1)))

现在，我不想在fib 内部调用eval，所以我在这里介绍宏：

(defvar *fibs* (make-hash-table))

(defun get-value (idx)
  (if (functionp (gethash idx *fibs*))
    (setf (gethash idx *fibs*)
      (funcall (gethash idx *fibs*)))
    (gethash idx *fibs*)))

(defmacro code-for (idx)
  `(lambda () (+ (get-value ,(- idx 2))
                 (get-value ,(- idx 1)))))

(defun fib (n)
  (loop for i from 0 below n
    if (< i 2) do (setf (gethash i *fibs*) 1)
    else do (setf (gethash i *fibs*) (code-for i)))
  (get-value (- n 1)))

但它说：

; in: DEFUN FIB
;     (CODE-FOR I)
; 
; caught ERROR:
;   during macroexpansion of (CODE-FOR I). Use *BREAK-ON-SIGNALS* to intercept.
;   
;    Argument X is not a NUMBER: I
; 
; compilation unit finished
;   caught 1 ERROR condition

很奇怪：我在代码中没有参数X，而I总是用作整数。

经过一番研究，我发现在宏 loop 中存在 code-for 的宏扩展，并且 code-for 将 i 接收为符号 (?) 而不是数字，这就是抱怨。不过，我不知道为什么代码是错误的，或者如何改进它。

编辑 12.04.2018。

正如 tfb 所指出的，解决问题的最佳方法取决于问题所在。整个问题是向学生解释什么是惰性评估，如何在 Lisp 中完成它以及为什么它可能是必要的。斐波那契数不是本示例的主要目标。

coredump 显示了问题的根本原因（宏扩展）及其解决方案（i 的额外绑定）。不幸的是，由于过多的额外解释，这使得所有代码都不适合展示。所以我最终通过递归更改loop：

(defvar *fibs* (make-hash-table))

(defun get-value (idx)
  (if (functionp (gethash idx *fibs*))
    (setf (gethash idx *fibs*)
      (funcall (gethash idx *fibs*)))
    (gethash idx *fibs*)))

(defun fib (n &optional (i (- n 1)))
  (if (< i 2) (setf (gethash i *fibs*) 1)
    (setf (gethash i *fibs*)
      (lambda () (+ (get-value (- i 2))
                    (get-value (- i 1))))))
  (if (zerop i) (get-value (- n 1))
    (fib n (- i 1))))

Answer 1

[注意 coredump 的回答解释了你的宏有什么问题：我专注于函数的问题以及解决问题的更好方法。]

我不确定您为什么认为这里需要EVAL 或宏：您可以使用LAMBDA 创建一个函数。这是您的代码的一个有效版本：

(defvar *fibs* (make-hash-table))

(defun get-value (idx &optional (default nil))
  ;; return the value and whether it was there.  If it's a function,
  ;; call it and stash the result
  (multiple-value-bind (got presentp)
      (gethash idx *fibs* default)
    (values
     (typecase got
       (function (setf (gethash idx *fibs*)
                       (funcall got)))
       (t got))
     presentp)))

(defun fib (n)
  (loop for i from 0 below n
        if (< i 2) do (setf (gethash i *fibs*) 1)
        else do (setf (gethash i *fibs*)
                      (let ((i i))
                        ;; rebind I as we don't want to depend on whatever
                        ;; LOOP does, which probably is mutate a single
                        ;; binding of I
                        (lambda () (+ (get-value (- i 2))
                                      (get-value (- i 1)))))))
  ;; just return the first value as we know the second will be T, and
  ;; it's not interesting
  (values (get-value (- n 1))))

但这是一种相当糟糕的方法。相反，您可以使用如下所示的显式记忆函数：

(defun fibonacci (n)
  ;; an explicitly-memoized version of the Fibonacci function
  (let ((memo (make-hash-table :test #'eql)))
    (labels ((fib (m)
               (cond
                ((< m 1)
                 (error "defined on naturals (excluding 0)"))
                ((< m 3)
                 1)
                (t
                 (multiple-value-bind (v p) (gethash m memo)
                   (if p
                       v
                     (setf (gethash m memo) (+ (fib (- m 1))
                                                (fib (- m 2))))))))))
      (fib n))))

更好的是，定义一个可以让你记忆任何函数的宏：有一些包可以让你这样做，虽然我不确定它们是什么（一个是我的，但我不确定那里有不是更好的，或者实际上现在是找到我的正确的地方！）

Answer 2

为什么你的宏会失败

这是code-for 看到的：

(code-for i)

第一个参数是符号i。但是，您正在尝试在宏展开期间使用此符号执行算术运算。这失败了。

现在，我不想在 fib 中调用 eval，所以我引入宏

这通常是对宏的错误使用。所有的宏操作都是代码，无法知道 runtime 值将等于什么。

eval 和宏都不需要

您可以轻松构建闭包：

(lambda () (+ (get-value (- i 2))
              (get-value (- i 1))))

您在这里遇到的唯一问题是 lambda 关闭的 i 正在被循环突变。当你最终调用闭包时，它的值会有所不同。你必须建立一个新的绑定：

(let ((i i)) (lambda ...))