使用 cond 运算符的 Parens 'options'？

Question

我决定整理以下函数。这个想法是它使用cond，但它也包含ifs，这使得认知处理变得困难。这是 ansi common lisp 一书中的 bst 代码。

(defun percolate (bst)                      
  (cond ((null (node-l bst))                
         (if (null (node-r bst))
             nil
             (rperc bst)))
        ((null (node-r bst)) (lperc bst))
        (t (if (zerop (random 2))
               (lperc bst)
               (rperc bst)))))

我的想法是通过在cond 中添加更多案例来删除 ifs，然后用左边的原因很好地证明整个事情，右边的效果。 这是我想出的：

(defun percolate (bst)                      ; [6,7,7a]
  (cond (((and (null (node-l bst)) (null (node-r bst)))  nil)
         ((null (node-l bst))                            (rperc bst))
         ((null (node-r bst))                            (lperc bst))
         (t                                              (if (zerop (random 2))
                                                             (lperc bst)
                                                             (rperc bst))))))

但是，这会产生错误

*** - SYSTEM::%EXPAND-FORM: (AND (NULL (NODE-L BST)) (NULL (NODE-R BST))) should be a
      lambda expression

我可以在堆栈溢出上找到其他有关此问题的帖子，例如here，但我仍然不明白。 cond 是否以某种方式偏离了正常的 lisp 语法？我想确定我所做的假设是错误的。

为了记录，下面的代码被解释器接受了，但显然我们不想这样写。

(defun percolate (bst)                      ; [6,7,7a]
  (let ((both-null (and (null (node-l bst)) (null (node-r bst))))
        (l-null    (null (node-l bst)))
        (r-null    (null (node-r bst))))
  (cond ((both-null                                              nil)
         (l-null                                         (rperc bst))
         (r-null                                         (lperc bst))
         (t                                              (if (zerop (random 2))
                                                             (lperc bst)
                                                             (rperc bst)))))))

Answer 1

cond 语法：

cond {clause}*

clause::= (test-form form*) 

例子

(cond (var)
      (var a b c)
      (var (f a) (f b) (f c))
      ((and var-a var-b) (f c) (f d))
      ((f a) b (f c) d)
      (t (f a) (f b) (f c)))

意思：

• 零个或多个子句。
• 每个子句都在一个列表中，以一个测试表格开头，然后是零个或多个表格

let 语法：

let ({var | (var [init-form])}*)
  declaration*
  form*

意思：

• 一个列表中有零个或多个可变子句
• 每个变量子句要么是一个变量，要么是一个变量列表和可选的 init-form
• 变量子句列表后跟可选的零个或多个声明，然后是零个或多个主体形式

例子：

(let ()
   )

(let (a)
  a)

(let (a
      (b t))
  (and a b))

(let ((a t)
      (b (not t)))
  (or a b))

Answer 2

我在写这篇文章的过程中发现了一个可能的答案。

我仍然会发帖，因为很高兴收到任何进一步的澄清和讨论。

让我们首先陈述我们所知道的。使用 let，需要有一对括号来包含所有分配的单个词法变量：

(let ((both-null (and (null (node-l bst)) (null (node-r bst))))
      (l-null    (null (node-l bst)))
      (r-null    (null (node-r bst))))

但假设 cond 遵循相同的模式（我曾假设）是错误的。

Cond 工作得很好没有周围的括号。 解释器接受以下表格：

(defun percolate (bst)                      ; [6,7,7a]
  (cond ((and (null (node-l bst)) (null (node-r bst)))  nil)
        ((null (node-l bst))                            (rperc bst))
        ((null (node-r bst))                            (lperc bst))
        (t                                              (if (zerop (random 2))
                                                            (lperc bst)
                                                            (rperc bst)))))

但是（这是让我很生气的部分），事实证明 解释器会接受额外的括号，如果有人无意中复制了 let 形式的语法。

... 除非！ - cond 表达式中的第一个形式本身是复合形式，即不是原子。

我非常感谢社区提供的任何其他答案，这些答案可以进一步解释和/或扩展或更正我在此处找到的内容。

更新：我对这些表单有效性的测试是将它们粘贴到 REPL 中。事实证明这还不够，您必须按照 Rainer Joswig 在 cmets 中的说明进行编译。

所以，一些结论

• 确保记住 cond 不遵循 let 的语法模型
• 要小心，因为如果你陷入这种假设，你可以暂时摆脱它，然后由于上面给出的原因突然它就不起作用了。
• 如果您一直在用额外的括号编写 cond，请正确练习并学会在没有括号的情况下识别它。