Scheme 简化条件表达式

是否可以重写下面的表达式，使

（foo）

只出现一次？就目前而言，这并不可怕，但这些对

（foo）

的重复调用使代码难以阅读

(cond
 (a
  (x)
  (foo))
 (b
  (y)
  (foo))
 (else
  (z)
  (bar)))

---

不一定更具可读性：）但这会起作用

(cond ((or a b) ((cond (a (x)) (b (y))) (foo)) (else (z) (bar)))

---

不一定更具可读性：）但这会起作用

(cond ((or a b) ((cond (a (x)) (b (y))) (foo)) (else (z) (bar)))

对

如果

a

或

b

是复杂表达式，则这不会引入额外的测试。

是

---

如果

a

或

b

是复杂的表达式，这不会引入额外的测试。

我不确定这在技术上是“回答您的问题”，但我不同意重复调用

foo

会使代码“难以阅读”。事实上，我想说的是，它们让阅读变得更容易。具体地说，在重构版本中，您有带有尾部代码的条件分支（对foo的调用）。这意味着，作为一名读者，我在阅读条件句时必须记住，后面会发生更多的事情。更重要的是，查看重构代码中的

foo

，我们无法确定在此之前执行了哪些代码；原来的那个没有这个问题

当大量代码重复时，会使代码难以阅读且脆弱。当重复单个调用时（如此处所示），通常会使代码更易于阅读，尤其是当函数具有有意义的名称时

在这里，让我重申一下：

(cond
  [a (x)
     (foo)]
  [b (y)
     (foo)]
  [else (z)
        (bar)])

---

我不确定这在技术上是“回答你的问题”，但我不同意反复调用

foo

会使代码“难以阅读”。事实上，我想说的是，它们让阅读变得更容易。具体地说，在重构版本中，您有带有尾部代码的条件分支（对foo的调用）。这意味着，作为一名读者，我在阅读条件句时必须记住，后面会发生更多的事情。更重要的是，查看重构代码中的

foo

，我们无法确定在此之前执行了哪些代码；原来的那个没有这个问题

当大量代码重复时，会使代码难以阅读且脆弱。当重复单个调用时（如此处所示），通常会使代码更易于阅读，尤其是当函数具有有意义的名称时

在这里，让我重申一下：

(cond
  [a (x)
     (foo)]
  [b (y)
     (foo)]
  [else (z)
        (bar)])

如果你说的

（foo）

是指复杂的事情，我建议：

(let ()
  (define (f) (foo))
  (cond
    (a     (x) (f))
    (b     (y) (f))
    (else  (z) (f))))

或

如果你说的

（foo）

是指复杂的事情，我建议：

(let ()
  (define (f) (foo))
  (cond
    (a     (x) (f))
    (b     (y) (f))
    (else  (z) (f))))

或

还有一个选择：

(let ((myfoo (lambda (x) (x) (foo))))
  (cond (a (myfoo x))
        (b (myfoo y))
        (else (z) (bar))))

还有一个选择：

(let ((myfoo (lambda (x) (x) (foo))))
  (cond (a (myfoo x))
        (b (myfoo y))
        (else (z) (bar))))

---

这不应该仅仅是

（let（（f foo））…

？这取决于情况。如果a和b有影响foo的副作用，那么你会得到不同的结果。我明白了。我倾向于忘记副作用，因为我自己从来没有使用过它们。这不应该仅仅是

（let（（f foo））吗…

？这取决于具体情况。如果a和b有影响foo的副作用，那么你会得到不同的结果。我明白了。我倾向于忘记副作用，因为我自己从来不使用它们。