Question

我想用2个局部变量执行一个函数，但这些变量的值应该取决于某些条件。例如，我们说我有2个变量x和y，如果let我想在y > x内交换它们。交换应该是暂时的，我不想用rotatef改变状态。我的代码看起来像：

(setq x 2)
(setq y 1)
(let (if (> x y) ((x y) (y x)) ((x x) (y y)))
  (cons x y)) ; should return (1 . 2)

但let内的表达式无效Lisp。如何有条件地为本地变量赋值？解决方法是将正文放在flet中并使用不同的参数调用它，但它看起来很笨拙：

(flet ((body (x y) (cons x y)))
  (if (< x y)
      (body x y)
      (body y x)))

Answer 1

多值绑定和值

有很多替代品，其中一些已在其他答案中指出。我认为标题中的问题（“Common Lisp中的条件变量绑定”）是multiple-value-bind和values的一个很好的例子。我在下面使用了不同的变量名，只是为了清楚说明x和y的位置，以及原始值的来源。但名字可以是相同的;这只是把它们遮住了。

(let ((a 3)
      (b 2))
  (multiple-value-bind (x y)
      (if (< a b)
          (values a b)
          (values b a))
    (cons x y)))
;=> (2 . 3)

然后，使用一些宏观，我们可以使它更清洁，就像coredump did：

(defmacro if-let (test bindings &body body)
  "* Syntax:
let ({var | (var [then-form [else-form]])}*) declaration* form* => result*
* Description: 
Similar to LET, but each binding instead of an init-form can have a
then-form and and else-form.  Both are optional, and default to NIL.
The test is evaluated, then variables are bound to the results of the
then-forms or the else-forms, as by LET."
  (let ((bindings (mapcar #'(lambda (binding)
                              (destructuring-bind (variable &optional then else)
                                  (if (listp binding) binding (list binding))
                                (list variable then else)))
                          bindings)))
    `(multiple-value-bind ,(mapcar 'first bindings)
         (if ,test
             (values ,@(mapcar 'second bindings))
             (values ,@(mapcar 'third bindings)))
       ,@body)))

(pprint (macroexpand-1 '(if-let (< x y) ((x x y)
                                         (y y x))
                         (cons x y))))

; (MULTIPLE-VALUE-BIND (X Y)
;     (IF (< X Y)
;         (VALUES X Y)
;         (VALUES Y X))
;   (CONS X Y))

(let ((a 3) (b 2))
  (if-let (< a b)
      ((x a b)
       (y b a))
    (cons x y)))
;=> (2 . 3)

与progv

的比较

就使用而言，这与sindikat's answer有一些相似之处，但 multiple-value-bind 会像让那样建立绑定：默认情况下是词法，但全局或本地特殊声明将使绑定动态化。另一方面，progv建立动态绑定。这意味着如果绑定完全由 progv 引入，您将看不到太多差异（除了尝试返回闭包），但是您不能 shadow 绑定。我们可以看到这一点而无需进行任何有条件的工作。这是两个示例代码段。在第一个中，我们看到x的内部引用实际上是指词法绑定，而不是 progv 建立的动态绑定。要引用由 progv 建立的那个，您实际上需要声明内部引用是特殊的。 progv 不接受声明，但我们可以使用本地。

(let ((x 1))
  (progv '(x) '(2)
    x))
;=> 1

(let ((x 1))
  (progv '(x) '(2)
    (locally (declare (special x))
      x)))
;=> 2

multiple-value-bind 实际上以我们期望的方式进行绑定：

(let ((x 1))
  (multiple-value-bind (x) (values 2)
    x))
;=> 2

最好使用 multiple-value-bind 这样的绑定构造，默认情况下建立词法绑定，就像让那样。

Answer 2

如果你不想使用sindikat所提到的progv，你总是可以这样做：

(defmacro let-if (if-condition then-bindings else-bindings &body body)
  `(if ,if-condition
     (let ,then-bindings
       ,@body)
     (let ,else-bindings
       ,@body)))

表达式如

(let-if (> x y) ((x y) (y x)) ((x x) (y y))
       (cons x y))

将扩展为：

(IF (> X Y)
(LET ((X Y) (Y X))
  (CONS X Y))
(LET ((X X) (Y Y))
  (CONS X Y)))

Answer 3

一种解决方案是使用progv而不是let，其第一个参数是要绑定值的符号列表，第二个参数是值列表，其余是正文。

(progv '(x y) (if (< x y) (list x y) (list y x))
  (cons x y)) ; outputs (1 . 2)

Answer 4

`rotatef`

怎么样：

CL-USER> (defvar x 2)
X
CL-USER> (defvar y 1)
Y
CL-USER> (let ((x x)    ; these variables shadow previously defined
               (y y))   ; X and Y in body of LET
           (when (> x y)
             (rotatef x y))
           (cons x y))
(1 . 2)
CL-USER> x              ; here the original variables are intact
2                       ; ^
CL-USER> y              ; ^
1                       ; ^

但是，我认为在每一个这样的实际案例中都有一些解决问题而没有宏的方法。从功能的角度来看，Answer by msandiford可能是最好的。

`psetf`

虽然rotatef是非常有效的方法（它可能会被编译为大约三个在内存中交换指针的机器指令），但它并不常见。

发布问题后不久

Rainer Joswing posted just a great solution as a comment。令我感到羞耻的是，我在几分钟前检查了宏psetf，这应该是非常有效和一般的解决方案。

宏psetf首先计算其偶数参数，然后将评估值分配给奇数位置的变量，就像setf一样。

所以我们可以写：

(let ((x x)
      (y y))
  (when (> x y)
    (psetf x y y x))
  ...)

就是这样，人们可以有条不紊地重新绑定任何东西。我认为它比使用宏更好。这是因为：

我认为这种情况并不常见;
发布的答案中的一些宏重复他们的正文代码，这可能非常大：因此你得到更大的编译文件（使用宏的公平价格，但在这种情况下不是这样）;
每个自定义宏都会让其他人更难理解代码。

Answer 5

另一种选择可能是：

(let ((x (min x y))
      (y (max x y)))
  (cons x y))

Answer 6

我的建议是destructuring-bind或multiple-value-bind。

之一

如果您预计需要这么做，我建议使用宏来生成绑定。我提供了一个可能的宏（未经测试）。

(defmacro cond-let (test-expr var-bindings &body body)
  "Execute BODY with the VAR-BINDINGS in place, with the bound values depending on 
   the trueness of TEST-EXPR.

   VAR-BINDINGS is a list of (<var> <true-value> <false-value>) with missing values 
   being replaced by NIL."

  (let ((var-list (mapcar #'car var-bindings))
        (then-values (mapcar #'(lambda (l)
                                 (when (cdr l) 
                                   (nth 1 l)))
                             var-bindings))
        (else-values (mapcar #'(lambda (l)
                                 (when (cddr l))
                                    (nth 2 l)))
                             var-bindings))
     `(destructuring-bind ,var-list
         (if ,test-expr
             (list ,@then-values)
           (list ,@else-values)))))

Common Lisp中的条件变量绑定

6 个答案:

多值绑定和值

与progv

rotatef

psetf

`rotatef`

`psetf`