anchor.diff:     :last (lambda (last)
              (destructuring-bind (condition &body body) last
                (if body
  -                 `(when ,condition ,@body)
  +                 `(when (nth-value ,nth ,condition) ,@body)
                    condition)))))
   
   
  
positive.code:        ,else
         (multiple-value (,@(when identityp (list :identity identity)))
           (progn ,@forms))))
  
  (defun %make-list-accumulator ()
    '(values accumulate finish)
  
negative.code:           (error "(~S ~S) requires at least one form or an explicit ~S."
                   'multiple-value name :identity))))
  
  (define and (&key (identity nil identityp) (nth 0)) (&rest forms)
    (%handling-identity
     'and identity identityp forms
     (lambda ()
       (%recursively forms (lambda (current rest)
                             (%catching-values
                              (lambda (values)
                                `(if (nth ,nth ,values)
                                     ,rest
                                     (values-list ,values)))
                              current))))))
  
  (define or (&key (identity nil identityp) (nth 0)) (&rest forms)
    (%handling-identity
     'or identity identityp forms
     (lambda ()
       (%recursively forms (lambda (current rest)
                             (%catching-values
                              (lambda (values)
                                `(if (nth ,nth ,values)
                                     (values-list ,values)
                                     ,rest))
                              current))))))
  
  (define cond (&key (nth 0)) (&rest clauses)
    (%recursively
     clauses
     (lambda (current else)
       (destructuring-bind (condition &body body) current
         (if body
             (let ((test `(nth-value ,nth ,condition)))
               (if (rest body)
                   `(cond (,test ,@body)
                          (t ,else))
                   `(if ,test
                        ,(first body)
                        ,else)))
             (%catching-values
              (lambda (values)
                `(if (nth ,nth ,values)
                     ,(if body
                          `(progn ,@body)
                          `(values-list ,values))
  