Cond inside let 不能正常工作

Question

我在使用一些 Common Lisp 代码时遇到了问题。我有两个类似于以下功能的功能：

(defun recursive-func (func lst num)
  (let ((test
          (some-func func
                     (first lst)
                     (first (rest lst))
                     num))
        (next
          (recursive-func func
                          (rest lst)
                          num)))

    (cond ((null (rest lst)) nil)
          ((null test) next)
          (t (cons test next)))))

(defun some-func (func a b num)
  (if (> a b)
      nil
      (funcall func a b num)))

当列表只有一个元素时我想要 recursive-func return nil，但它没有并调用 some-func 生成评估中止因为 b 是 nil。这是执行的痕迹：

CL-USER> (recursive-func #'(lambda(x y z) (+ x y z)) '(1 2 3 4 5) 5)
  0: (RECURSIVE-FUNC #<FUNCTION (LAMBDA (X Y Z)) {10035F6ABB}> (1 2 3 4 5) 5)
    1: (SOME-FUNC #<FUNCTION (LAMBDA (X Y Z)) {10035F6ABB}> 1 2 5)
    1: SOME-FUNC returned 8
    1: (RECURSIVE-FUNC #<FUNCTION (LAMBDA (X Y Z)) {10035F6ABB}> (2 3 4 5) 5)
      2: (SOME-FUNC #<FUNCTION (LAMBDA (X Y Z)) {10035F6ABB}> 2 3 5)
      2: SOME-FUNC returned 10
      2: (RECURSIVE-FUNC #<FUNCTION (LAMBDA (X Y Z)) {10035F6ABB}> (3 4 5) 5)
        3: (SOME-FUNC #<FUNCTION (LAMBDA (X Y Z)) {10035F6ABB}> 3 4 5)
        3: SOME-FUNC returned 12
        3: (RECURSIVE-FUNC #<FUNCTION (LAMBDA (X Y Z)) {10035F6ABB}> (4 5) 5)
          4: (SOME-FUNC #<FUNCTION (LAMBDA (X Y Z)) {10035F6ABB}> 4 5 5)
          4: SOME-FUNC returned 14
          4: (RECURSIVE-FUNC #<FUNCTION (LAMBDA (X Y Z)) {10035F6ABB}> (5) 5)
            5: (SOME-FUNC #<FUNCTION (LAMBDA (X Y Z)) {10035F6ABB}> 5 NIL 5)
; Evaluation aborted on #<TYPE-ERROR expected-type: NUMBER datum: NIL>.

希望有人能帮帮我，谢谢

Answer 1

首先评估 let 中的绑定，然后才执行 cond 中的测试。你只需要改变一点：

(defun recursive-func (func list num)
  (if (null (rest list))
      nil
      (let ((test (some-func func
                             (first list)
                             (first (rest list))
                             num))
            (next (recursive-func func
                                  (rest list)
                                  num)))
        (cond ((null test) next)
              (t (cons test next))))))

注意 cond 也可以写成：

(if test (cons test next) next)

以你为例：

(recursive-func (lambda (x y z) (+ x y z))
                '(1 2 3 4 5)
                5)
=> (8 10 12 14)

或者，您可以通过以下方式分解任务（在 REPL 中）：

> (maplist (lambda (list)
             (list
              (first list)
              (second list)))
           '(1 2 3 4 5))
=> ((1 2) (2 3) (3 4) (4 5) (5 NIL))

更喜欢 SECOND 而不是 (first (rest ...))。最后的结果在 REPL 中绑定到变量 *. Remove the last (useless) pair with BUTLAST:

(butlast *)
=> ((1 2) (2 3) (3 4) (4 5))

然后，对于此列表中的每一对，调用您的函数 - 这里只是 +. Notice the use of DESTRUCTURING-BIND:

(mapcar (lambda (list)
          (destructuring-bind (a b) list
            (+ a b 5)))
        *)
=> (8 10 12 14)

所以，基本上，您的函数可以写成：

(defun map-pair-funcall (function list number)
  (mapcar (lambda (pair)
            (destructuring-bind (a b) pair
              (funcall function a b number)))
          (butlast (maplist (lambda (list)
                              (list (first list) (second list)))
                            list))))

因此：

(map-pair-funcall #'+ '(1 2 3 4 5) 5)
=> (8 10 12 14)

编辑：

我错过了提供的函数可能 return NIL 的情况。用 (remove NIL (mapcar ...)) 包装调用 mapcar 的表单以过滤掉它。

您可以使用 MAPCON 在一次迭代中执行所有这些操作。该函数遍历子列表，并连接结果列表。因此，被调用的函数应该 return 列出，当你 return NIL 时，结果将被简单地丢弃。

让我们定义 ensure-list（或使用 Alexandria 中的那个）：

(defun ensure-list (expr)
  (if (listp expr) expr (list expr)))

该函数将 returned 值包装在一个列表中，除非它已经是一个列表（特别是 NIL）。然后，函数定义如下：

(defun map-pair-funcall (function list number)
  (mapcon (lambda (list)
            (and (second list)
                 (ensure-list (funcall function
                                       (first list)
                                       (second list)
                                       number))))
          list))

你也可以 LOOP:

(defun map-pair-funcall (function list number)
  (loop 
    for (a b) on list
    for result = (and b (funcall function a b number))
    when result
      collect result))

Cond inside let 不能正常工作

Cond inside let doesn't work properly

conditional

common-lisp

let