list - 当我运行它时，它声明列表约束未绑定(bind)。这是为什么？

Question

(defun combinations (&rest lists) (if (car lists) (mapcan (lambda (inner-val)(mapcar (lambda (outer-val) (cons outer-val inner-val)) (car lists))) (apply #'combinations (cdr lists))) (list nil)))

combinations 函数为每个棒球运动员创建姓名、魅力和位置的所有组合。

(defun main()
  (setq m-list (combinations '(Blacket Bluet Browning Greenfield Whitehall)'(four-lear-clover penny rabbit-foot ribbon silver-dollar) '(center-    field first-base right-field short-stop third-base)))
  (setq contraints  (list '(no Browning penny) '(no Browning silver-dollar) '(no Browning right-field) '(no Browning center-field) '(no Bluet center-field) '(no Bluet right-field) '(no Greenfield first-base) '(no Greenfield short-stop)
    '(no Greenfield third-base) '(no Whitehall center-field) '(no Whitehall right-field) '(no Greenfield four-leaf-clover) '(no Greenfield penny) '(no Whitehall four-lear-clover) '(no Whitehall penny) 
    '(no Blacket four-leaf-clover) '(no Blacket penny) '(no Blacket first-base) '(no Blacket third-base) '(no Blacket ribbon) '(no Bluet ribbon) '(no center-field rabbit-foot)))
  (loop  
   (setf n-constraint (car constraints))
   (setf m-list (remove-l m-list n-constraint))
   (setf constraints (cdr constraints))
   (when (null constraints) (return m-list))))

主要功能用于解决玩家位置和魅力未知的问题。主要功能列出了球员的所有可能组合、他们的魅力和他们的棒球位置。然后它声明一个约束列表，每个列表在开始时都声明 no，以指示 no 之后的两个值不应该是任何组合。进行循环以便从约束列表中获取一个约束。约束的汽车本身就是一个列表。然后 Main 使用 remove-l 函数来消除不符合约束条件的组合。 Remove-l 然后返回一个新的 m-list，其组合比以前少

(defun remove-l (a b)
  (setf n-list '())
  (loop 
    (setf sample (car a))
    (when (and (not (= (find (nth 1 b) sample) nil) (= (find (nth 2 b)sample) nil))) (cons sample (cons n-list nil)))
(setf a (cdr a))(when (null a) (return n-list))))

此处的 Remove-l 函数用于返回一个新列表，其中包含与以前大部分相同的组合。约束列表中的一个约束用于消除某些组合。

(defvar  *data* nil) 

ignore

(defun add-player (player)
  (push player *data*))

ignore

(defun dump-data ()
  (dolist (cd *data*)
   (format t "~{~a:~10t~a~%~}~%" cd)))

ignore

Answer 1

Xach 已经在评论中指出了拼写错误，但我想我会添加一些关于您的代码的评论。

您不应使用 SETQ 或 SETF 定义变量。这些应该只用于为已经定义的变量设置值。使用 LET/LET*对于局部变量，或 DEFVAR/DEFPARAMETER对于全局变量。

遍历列表也是很常见的事情，因此有内置的构造:DOLIST在扩展的 LOOP 中，您可以使用 FOR element IN list。

在修复这些问题并为您的 REMOVE-L 添加一些更好的缩进后，它看起来像这样:

(defun remove-l (a b)
  (let ((n-list '()))
    (dolist (sample a n-list) ; That N-LIST is the return value from the loop
      (when (and (not (= (find (nth 1 b) sample)
                         nil)
                      (= (find (nth 2 b) sample)
                         nil)))
        (cons sample (cons n-list nil))))))

那还是有一些问题。请注意 AND 只有一种形式，而 NOT 有两种形式。 = 用于数字相等，因此您应该使用 NOT 或 NULL检查是否有错误。当然还有 CONS 不是破坏性的问题；你必须将它的返回值设置到某个地方。就像现在一样，循环不做任何事情。你可以使用 PUSH将元素添加到列表。

修复这些，你会得到这样的东西:

(defun remove-l (a b)
  (let ((n-list '()))
    (dolist (sample a n-list)
      (when (and (not (find (nth 1 b) sample))
                 (not (find (nth 2 b) sample)))
        (push sample n-list)))))

您可以通过将两个约束分配给变量(使用 LET 或 DESTRUCTURING-BIND )而不是每次迭代调用两次 NTH 来进一步改进它。 然而，过滤列表也是一件很常见的事情，你的 REMOVE-L 可以很容易地用内置的 REMOVE-IF 表达。 .您可以将 MAIN 更改为如下所示:

(defun main ()
  (let ((m-list ...) ; I left out the long lists. Fill them in.
        (constraints ...))
    ;; This uses LOOPs destructuring assignment. The underscore is
    ;; just an unused variable that holds the NO in each constraint.
    ;; CONSTRAINT-1 and -2 hold the two symbols.
    (loop for (_ constraint-1 constraint-2) in constraints
          do (setf m-list (remove-if (lambda (sample)
                                       ;; I used MEMBER instead of FIND.
                                       ;; It doesn't really matter, but
                                       ;; MEMBER communicates intent better.
                                       (and (member constraint-1 sample)
                                            (member constraint-2 sample)))
                                     m-list)))
    m-list))

编辑: 现在我想起来了，Common Lisp 也有一个内置函数 SUBSETP检查一个列表是否是另一个列表的子集(不考虑顺序)。这样您就不需要解构约束列表。

(defun main ()
  (let ((m-list ...)
        (constraints ...))
    (dolist (constraint constraints m-list)
      (setf m-list (remove-if (lambda (sample)
                                (subsetp (cdr constraint)
                                         sample))
                              m-list)))))

这将是使用 currying 的好地方，它不是内置的，但如果你有 Quicklisp安装后，您可以使用 Alexandria 中的实现或者你可以自己写一个简单的:

(defun curry (function &rest arguments)
  (lambda (&rest more)
    (multiple-value-call function (values-list arguments) (values-list more))))

(defun main ()
  (let ((m-list ...)
        (constraints ...))
    (dolist (constraint constraints m-list)
      (setf m-list (remove-if (curry #'subsetp (cdr constraint))
                              m-list)))))