PROSAGA码农传奇-lisp-是否可能/使用卫生宏进行编译时计算优化的例子是什么？

<div class =“post-text”itemprop =“text”>
  
    是的，卫生的宏可以做这种事情。这里有一个叫做宏的例子
     <code>
 plus
 </code>
     在Racket中就像
     <code>
 +
 </code>
     除了在宏展开时，它对相邻文字数的序列求和。因此，它可以完成您在宏扩展时在运行时完成的一些工作（因此，有效地，在编译时）。所以，例如
  
   <pre>
 <code>
 (plus a b 1 2 3 c 4 5)

</code>
 </pre>
  
    扩展到
  
   <pre>
 <code>
 (+ a b 6 c 9)

</code>
 </pre>
  
    关于这个宏的一些注释。
  
  <UL>
    <LI>
      它可能不是非常惯用的Racket，因为我是一个大多数未经改造的CL黑客，这意味着我住在一个山洞里，穿着动物皮，并且说'ug'很多。特别是我相信我应该使用
       <code>
 syntax-parse
 </code>
       但我无法理解。
    </LI>
    <LI>
      它甚至可能不对。
    </LI>
    <LI>
      算术有微妙之处，这意味着这个宏可以返回不同的结果
       <code>
 +
 </code>
      。特别是
       <code>
 +
 </code>
       被定义为从左到右成对添加，而
       <code>
 plus
 </code>
       通常不是：所有文字都特别加入第一（假设你已经完成了（需要球拍/ flonum，和
       <code>
 +max.0
 </code>
       ＆amp; c与我的机器上的值相同）
       <code>
 (+ -max.0 1.7976931348623157e+308 1.7976931348623157e+308)
 </code>
       有一个值
       <code>
 1.7976931348623157e+308
 </code>
      ，而
       <code>
 (plus -max.0 1.7976931348623157e+308 1.7976931348623157e+308)
 </code>
       有一个值
       <code>
 +inf.0
 </code>
      ，因为这两个文字首先被添加而且溢出了。
    </LI>
    <LI>
      一般来说，这是一件无用的事情：我认为可以安全地假设任何合理的编译器都会为您做这些优化。它的唯一目的是表明可以执行检测和编译的编译时常量。
    </LI>
    <LI>
      值得注意的是，至少从像我这样的caveman-lisp用户的角度来看，你可以这样对待
       <code>
 +
 </code>
       因为最后一个
       <code>
 syntax-case
 </code>
      ：它可以说
       <code>
 (apply plus ...)
 </code>
       例如（虽然在这种情况下当然没有巧妙的优化）。
    </LI>
  </UL>
  
    这里是：
  
   <pre>
 <code>
 (require (for-syntax racket/list))

(define-syntax (plus stx)
  (define +/stx (datum->syntax stx +))
  (syntax-case stx ()
    [(_)
     ;; return additive identity
     #'0]
    [(_ a)
     ;; identity with one argument
     #'a]
    [(_ a ...)
     ;; the interesting case: there's more than one argument, so walk over them
     ;; looking for literal numbers.  This is probably overcomplicated and
     ;; unidiomatic
     (let* ([syntaxes (syntax->list #'(a ...))]
            [reduced (let rloop ([current (first syntaxes)]
                                 [tail (rest syntaxes)]
                                 [accum '()])
                       (cond
                         [(null? tail)
                          (reverse (cons current accum))]
                         [(and (number? (syntax-e current))
                               (number? (syntax-e (first tail))))
                          (rloop (datum->syntax stx
                                                (+ (syntax-e current)
                                                   (syntax-e (first tail))))
                                 (rest tail)
                                 accum)]
                         [else
                          (rloop (first tail)
                                 (rest tail)
                                 (cons current accum))]))])
       (if (= (length reduced) 1)
           (first reduced)
           ;; make sure the operation is our +
           #`(#,+/stx #,@reduced)))]
    [_
     ;; plus on its own is +, but we want our one.  I am not sure this is right
     +/stx]))

</code>
 </pre>
  <HR />
  
    事实上可以更积极地做到这一点，所以
     <code>
 (plus a b 1 2 c 3)
 </code>
     变成了
     <code>
 (+ a b c 6)
 </code>
    。这可能更令人兴奋，可能得到不同的答案含义。值得注意的是CL规范
    <a href="http://www.lispworks.com/documentation/HyperSpec/Body/12_aaa.htm" rel="nofollow noreferrer">
      对此说
    </A>
    ：
  
  <BLOCKQUOTE>
    
      对于在数学上是关联的（并且可能是可交换的）函数，符合的实现可以以与关联（和可能可交换的）重新排列一致的任何方式处理参数。这不会影响参数形式的评估顺序[...]。未指定的仅是处理参数值的顺序。这意味着实施可能会有所不同，其中应用了自动强制[...]。
    
  </BLOCKQUOTE>
  
    因此，这样的优化在CL中显然是合法的：我不清楚它在Racket中是否合法（尽管我认为它应该是合法的）。
  
   <pre>
 <code>
 (require (for-syntax racket/list))

(define-for-syntax (split-literals syntaxes)
  ;; split a list into literal numbers and the rest
  (let sloop ([tail syntaxes]
              [accum/lit '()]
              [accum/nonlit '()])
    (if (null? tail)
        (values (reverse accum/lit) (reverse accum/nonlit))
        (let ([current (first tail)])
          (if (number? (syntax-e current))
              (sloop (rest tail)
                     (cons (syntax-e current) accum/lit)
                     accum/nonlit)
              (sloop (rest tail)
                     accum/lit
                     (cons current accum/nonlit)))))))

(define-syntax (plus stx)
  (define +/stx (datum->syntax stx +))
  (syntax-case stx ()
    [(_)
     ;; return additive identity
     #'0]
    [(_ a)
     ;; identity with one argument
     #'a]
    [(_ a ...)
     ;; the interesting case: there's more than one argument: split the
     ;; arguments into literals and nonliterals and handle approprately
     (let-values ([(literals nonliterals)
                   (split-literals (syntax->list #'(a ...)))])
       (if (null? literals)
           (if (null? nonliterals)
               #'0
               #`(#,+/stx #,@nonliterals))
           (let ([sum/stx (datum->syntax stx (apply + literals))])
             (if (null? nonliterals)
                 sum/stx
                 #`(#,+/stx #,@nonliterals #,sum/stx)))))]
    [_
     ;; plus on its own is +, but we want our one.  I am not sure this is right
     +/stx]))

</code>
 </pre>
</DIV>