如何在 Common Lisp 中迭代返回多个值

Question

要返回多个值，可以使用(values v1 v2 v3)

如何从do循环迭代返回多个值？ 换句话说，我想在do循环中构建多值返回的值，但我只能构建一个列表。 我知道values-list ，但使用多个值的重点是不构建列表。

有没有办法在不构建列表的情况下迭代返回多个值？

Answer 1

如果您的 Common Lisp 实现支持堆栈分配，那么这将是处理该问题的一种方法。

例如在 LispWorks 中，这是可能的：

(defun foo (list)
  (let ((vlist (make-list (length list)
                          :initial-element nil)))
    (declare (dynamic-extent vlist))              ; allocate VLIST on the stack
    (values-list (map-into vlist #'1+ list))))    ; return VLIST as values

以类似的方式可以使用DO来设置堆栈分配列表。

LispWorks 识别MAKE-LIST与dynamic-extent声明相结合的堆栈分配。 SBCL 没有，但可以使用 LIST 之类的东西进行堆栈分配。

Answer 2

正如我在评论中所说：如果您不知道您想要多少个值，那么您可能不应该使用多个值：因为限制可以低至 20，您可能会达到该限制，并且任何接收器都需要将值转换为数据结构以了解有多少。 简单地返回数据结构会更好。

所以我会假设你知道你要多少价值。 在这种情况下，您可以为每个值绑定一个变量。 但是，当然，没有人愿意编写那样的代码。 好吧，这就是 Lisp：您不必编写无聊的重复代码！

(defmacro with-indexed-values ((accessor n &optional (initial-value 'nil))
                               &body decls/forms)
  "Evaluate DECLS/FORMS with N indexed values: (ACCESSOR i) will
retrieve the ith value, and (SETF (ACCESSOR I) v) will set it Indices
run from 0.  All of the indexed values are returned as multiple
values.  INITIAL-VALUE, if given is the initial value for the values:
it is evaluated once."
  (unless (<= n multiple-values-limit)
    (error "~A is too many values: limit is ~A" n multiple-values-limit))
  
  (let ((varnames (loop for i below n
                        collect (make-symbol (format nil "V~D" i))))
        (ivname (make-symbol "IV")))
    `(let ((,ivname ,initial-value))
       (let ,(loop for v in varnames collect `(,v ,ivname))
         (flet ((,accessor (i)
                  (case i
                    ,@(loop for v in varnames
                            for i upfrom 0
                            collect `(,i ,v))
                    (otherwise
                     (error "~A isnt an integer in [0, ~A)" i ,n))))
                ((setf ,accessor) (new i)
                  (case i
                    ,@(loop for v in varnames
                            for i upfrom 0
                            collect `(,i (setf ,v new)))
                    (otherwise
                     (error "~A isnt an integer in [0, ~A)" i ,n)))))
           (declare (inline ,accessor (setf ,accessor)))
           ,@decls/forms
           (values ,@varnames))))))

现在：

> (with-indexed-values (v 2)
    (setf (v 0) 2)
    (setf (v 1) (+ (v 0) 1))
    (decf (v 0)))
1
3

或者

 > (with-indexed-values (v 5 (cons nil nil))
     (loop for i below 3
           do (setf (v i) i)))
0
1
2
(nil)
(nil)

（最后两个值是eq 。）

这是同一宏的另一个版本：这个宏将值存储在向量中，并依赖于堆栈分配的向量。 LispWorks 可以做到这一点：我没有检查其他实现。 这个的优点是访问器只是数组引用并且应该很快，但缺点是它依赖于实现堆栈分配向量。

(defmacro with-indexed-values ((accessor n &optional (initial-value 'nil))
                               &body decls/forms)
  "Evaluate DECLS/FORMS with N indexed values: (ACCESSOR i) will
retrieve the ith value, and (SETF (ACCESSOR I) v) will set it Indices
run from 0.  All of the indexed values are returned as multiple
values.  INITIAL-VALUE, if given is the initial value for the values:
it is evaluated once."
  (unless (<= n multiple-values-limit)
    (error "~A is too many values: limit is ~A" n multiple-values-limit))
  (let ((vname (make-symbol "V")))
    `(let ((,vname
            (let ((init ,initial-value))
              (vector ,@(loop repeat n collect 'init)))))
       (declare (dynamic-extent ,vname))
       (flet ((,accessor (i)
                (aref ,vname i))
              ((setf ,accessor) (new i)
                (setf (aref ,vname i) new)))
         (declare (inline ,accessor (setf ,accessor)))
         ,@decls/forms
         (values ,@(loop for i below n
                         collect `(aref ,vname ,i)))))))