macros - 为 xor 定义方案宏

Question

请注意以下宏正在运行。

(define-syntax xor
  (syntax-rules ()
    ((xor a1 a2)
     (if a1
       (false? a2)
       (true? a2)))
    ((xor a1 a2 a3 ...)
     (let ((a (xor a1 a2)))
       (xor a a3 ...)))))

不过，一般情况下参数列表中的a3似乎是不能正常工作的。

(define-syntax xor
  (syntax-rules ()
    ((xor a1 a2)
     (if a1
       (false? a2)
       (true? a2)))
    ((xor a1 a2 ...)
     (let ((a (xor a1 a2)))
       (xor a ...)))))

因此我想知道第二种情况下的省略号到底发生了什么。

Q1.这是否意味着除了省略号之外的每个参数列表都应该是唯一的才能正常运行？

例如给定输入(xor #t #t #t)，第一个将产生#t，而第二个将产生#f.

我使用的解释器是mit-scheme。

Q2.有没有可能让它短路？

谢谢，

Answer 1

省略号告诉您有关第二个符号的信息。 a2 ... 可以是零个或多个元素，您需要在重复的内容中使用 a2 才能使其正常工作。在你的第二个宏中， a2 的结果缺少重复元素的省略号，你在 a 之后有 ellipsis 这不是匹配模式，也没有省略号。这两个事实都使宏无效。

第一个宏是正确的，因为您有一个术语匹配两个元素。您的第二个术语也匹配两个术语，但是由于运行了第一个匹配的模式，您确定您的第二个模式有两个以上的参数，因为它匹配两个 a3 ... 至少是一个元素。

我不确定 true? 的用途。稍微简化一下:

(define-syntax xor
  (syntax-rules ()
    ((xor a1 a2)
     (if a1 (not a2) a2))
    ((xor a1 a2 a3 ...)
     (xor (xor a1 a2) a3 ...))))

(xor 1 2 3 4 5)  ; ==> 5  (odd number of true values)
(xor 1 2 3 4)    ; ==> #f (even number of true values)
(xor 1 2 3 4 #f) ; ==> #f (even number of true values)
(xor 1 #f #f #f) ; ==> #t (odd number of true values)

现在这将计算参数表达式的奇校验。它不能短路，因为它是触发器。 (xor #t #t #f#f#t) ; ==> #t 因为它有奇数个真实参数。这就是它的作用，虽然它是菊花链 xor 逻辑，但它实际上并没有剩下唯一的一个真正的逻辑。由于您永远无法将其短路，因此您不妨使用执行完全相同操作的过程:

(define (xor . args)
  (= (remainder (count values args) 2) 1))

(xor 1 2 3 4 5)  ; ==> #t (odd number of true values)
(xor 1 2 3 4)    ; ==> #f (even number of true values)
(xor 1 2 3 4 #f) ; ==> #f (even number of true values)
(xor 1 #f #f #f) ; ==> #t (odd number of true values)

计数可以在 SRFI-1 list library 中找到.

xor 还有另一种解释，这是我读到这个问题时想到的第一个解释，因为这是短路起作用的唯一情况。当且仅当一个表达式为真时，它为真，否则结果为假。在这里，当遇到第二个假值时，您可以短路到 #f 而无需评估其余参数。

(define-syntax xor
  (syntax-rules ()
    ((_) #f)
    ((_ a) a)
    ((_ a b ...)
     (if a
         (not (or b ...))
         (xor b ...)))))

(xor 1 2 3 4 5)  ; ==> #f (more than one true value)
(xor 1 2 3 4)    ; ==> #f (more than one true value)
(xor 1 2 3 4 #f) ; ==> #f (more than one true value)
(xor 1 #f #f #f) ; ==> #t (only one true value)

;; Slightly more complex version where 
;; the result is always the one true value or #f
(define-syntax xor
  (syntax-rules ()
    ((_) #f)
    ((_ a) a)
    ((_ a b ...)
     (let ((tmp a))
       (if tmp 
           (and (not (or b ...)) tmp)
           (xor b ...))))))

(xor 1 2 3 4 5)  ; ==> #f
(xor 1 2 3 4)    ; ==> #f
(xor 1 2 3 4 #f) ; ==> #f
(xor 1 #f #f #f) ; ==> 1 (the actual true value, consistent)

大多数算法不会因使用过程而有任何速度损失，但我想在某些情况下，此宏可能会像宏一样派上用场。一个不保留值的程序版本与另一个程序版本非常相似:

(define (xor . args)
  (= (count values args) 1))