anchor.diff:                               `(values ,x)))
                          y))
                (quotation? (x env)
  -               (let ((exp (expand-macro-recursively x env)))
  -                 (and (listp exp)
  -                      (eql (car exp) 'quote))))
  +               (match (expand-macro-recursively x env)
  +                 ((list 'quote _) t)))
                (rest-op? (x env)
                  (declare (ignorable env))
                  #+sbcl
  -               (prog1 nil
  +               (block nil
                    (sb-walker:walk-form
                     x env
                     (lambda (f c e)
                       (cond ((and (eql c :eval) (rest-placeholder? f e))
  -                           (return-from rest-op? t))
  -                          (t f)))))
  +                           (return t))
  +                          (t f))))
  +                 nil)
   
                  #-sbcl
                  (or (and (listp x)
  
positive.code:                    (loop repeat (- n counter) do (make-var))))
                 x)
               (make-spliced-call (f env)
                 (let ((fn (car f)))
                   (if (eql fn 'progn)
                       (make-spliced-call
                        `((lambda (&rest xs)
                            xs)
                          ,@(rest f))
                        env)
                       (let ((splice (splice (cdr f) env)))
                         `(multiple-value-call (function ,fn)
                            ,@splice)))))
               (walk-op (x env)
                 (declare (ignorable env))
                 #+sbcl
  
negative.code:                             y)))
                       (t x))))
        (declare (ignorable #'quotation?))
        (let ((body (walk-op `(progn ,@body) outer-env))
              (rest
                (and (rest-op? `(progn ,@body) outer-env)
                     `(&rest ,(intern (string '_*))))))
          `(lambda (,@(reverse vars) ,@rest)
             (declare (ignorable ,@vars))
  