10

学习 Common Lisp（使用 GNU CLISP 2.43）.. 所以可能是一个菜鸟错误。示例是“打印 x 和 y 之间的素数”

(defun is-prime (n)
  (if (< n 2) (return-from is-prime NIL))

  (do ((i 2 (1+ i)))
      ((= i n) T)
    (if (= (mod n i) 0) 
        (return NIL))))

(defun next-prime-after (n)
  (do ((i (1+ n) (1+ i)))
      ((is-prime i) i)))

(defmacro do-primes-v2 ((var start end) &body body)
  `(do ((,var (if (is-prime ,start)
                  ,start
                  (next-prime-after ,start))
              (next-prime-after ,var)))
       ((> ,var ,end))
     ,@body))

(defmacro do-primes-v3 ((var start end) &body body)
  (let ((loop-start (gensym))
        (loop-end (gensym))) 
    `(do ((,loop-start ,start)
          (,loop-end ,end)
          (,var (if (is-prime ,loop-start)
                    ,loop-start
                    (next-prime-after ,loop-start))
                (next-prime-after ,var)))
         ((> ,var ,loop-end))
       ,@body )))

do-primes-v2 完美运行。

[13]> (do-primes-v2 (p 10 25) (格式 t "~d " p))
11 13 17 19 23

接下来我尝试使用 gensym 来避免宏扩展中的命名冲突 - do-primes-v3。但是我被困在一个

*** - EVAL：变量 #:G3498 没有值

尝试使用宏扩展来查看我是否可以发现错误，但我不能。

[16]> (macroexpand-1 `(do-primes-v3 (p 10 25) (格式 t "~d " p)))
（做
 ((#:G3502 10) (#:G3503 25)
  (P (IF (IS-PRIME #:G3502) #:G3502 (NEXT-PRIME-AFTER #:G3502))
     (P))))
 ((> P #:G3503)) (格式 T "~d " P)) ;
4

5 回答 5

5

使用DO*而不是DO.

DO在它们尚不可见的范围内初始化绑定。 在可见DO*的范围内初始化绑定。

在这种特殊情况下var需要引用其他绑定loop-start。

于 2009-02-16T14:45:57.337 回答
4

您实际上不需要gensym这里来避免变量捕获，因为您没有引入任何“宏本地”的变量。当您宏展开您的do-primes-v2时，您将看到没有引入宏之外不存在的变量。

但是，您确实需要它来做不同的事情：避免多重评估。

如果你这样调用宏：

(do-primes-v2 (p (* x 2) (* y 3))
  （格式“~a~%”p））

它扩展到

(do ((p (if (is-prime (* x 2)))
            (* x 2)
            （下一个素数（* x 2））
        (p))))
    ((> p (* y 3))
  （格式“~a~%”p））

充其量，这是低效的，因为这些乘法是多次完成的。但是，如果您使用具有副作用的函数作为输入，例如setfor incf，这可能是一个大问题。

于 2009-02-16T14:25:14.377 回答
3

将循环开始和循环结束的绑定移动到封闭的 LET 块或使用 DO*。原因是 DO 中的所有循环变量都是“并行”绑定的，因此对于第一个绑定，（扩展的）循环开始变量还没有绑定。

于 2009-02-16T14:51:56.123 回答
1

我知道这并不能真正回答你的问题，但我认为它是相关的。根据我的经验，您尝试编写的宏类型是一种非常常见的类型。我对您解决问题的方式的一个问题是它不能处理另一个常见用例：功能组合。

我没有时间强调使用宏可能会遇到的一些困难，但是我会强调，如果您构建了面向函数组合的主要迭代器，那么您的宏将变得非常简单，避免了您的问题共。

注意：我对您的一些功能进行了轻微修改。

(defun is-prime (n)
  (cond
    ((< n 2)
     nil)
    ((= n 2)
     t)
    ((evenp n)
     nil)
    (t
     (do ((i 2 (1+ i)))
     ((= i n) t)
       (when (or (= (mod n i) 0))
         (return nil))))))

(defun next-prime (n)
  (do ((i n (1+ i)))
      ((is-prime i) i)))

(defun prime-iterator (start-at)
  (let ((current start-at))
    (lambda ()
      (let ((next-prime (next-prime current)))
         (setf current (1+ next-prime))
         next-prime))))

(defun map-primes/iterator (fn iterator end)
  (do ((i (funcall iterator) (funcall iterator)))
      ((>= i end) nil)
    (funcall fn i)))

(defun map-primes (fn start end)
  (let ((iterator (prime-iterator start)))
    (map-primes/iterator fn iterator end)))

(defmacro do-primes ((var start end) &body body)
  `(map-primes #'(lambda (,var)
                   ,@body)
               ,start ,end))

我也建议您查看Series。生成器模式在 lisp 程序中也很常见。您可能还想查看Alexandria，特别是函数 ALEXANDRIA:COMPOSE ，看看您可以用函数组合做什么很酷的事情。

于 2009-02-17T01:23:04.157 回答
0

我建议完全避免 DO/DO* 和宏，而是使用Series（可以在series.sourceforge.net上找到其实现）。

如果这太复杂了，那么考虑只使用递归或生成器（用于按需生成）生成素数列表。

于 2009-02-16T16:25:52.137 回答