anchor.diff:          (lambda (binding)
             (if (consp binding)
                 (cons (first binding)
  -                    (formatexpand-forms (rest binding) ~ stream))
  +                    (formatexpand-forms-partially (rest binding) ~ stream))
                 binding))
           bindings)
         ,@body)))
  
positive.code:                             ,@body)))))))
  
  (define-~format progn (~ stream) (&rest forms)
    `(progn ,@(formatexpand-forms forms ~ stream)))
  
  (define-~format if (~ stream) (test then &optional (else nil elsep))
    `(if ,test
         ,(formatexpand then ~ stream)
         ,@(when elsep (list (formatexpand else ~ stream)))))
  
  (define-~format when (~ stream) (test &rest body)
    `(when ,test
       ,@(formatexpand-forms body ~ stream)))
  
  (define-~format unless (~ stream) (test &rest body)
    `(unless ,test
       ,@(formatexpand-forms body ~ stream)))
  
  (define-~format cond (~ stream) (&rest clauses)
    `(cond ,@(mapcar
              (lambda (clause)
                (cons (first clause)
                      (formatexpand-forms (rest clause) ~ stream)))
                     clauses)))
  
  (eval-when (:compile-toplevel :load-toplevel :execute)
  
negative.code:   (check-type name symbol)
    (setf (gethash name *~formats*) new))
  
  (defun formatexpand-finalize (form stream &aux optimized)
    (with-open-stream (concatenated-constants (make-string-output-stream))
      (labels ((cut ()
                 (let ((concatenated (get-output-stream-string
                                      concatenated-constants)))
                   (unless (zerop (length concatenated))
                     (push `(write-string ,concatenated ,stream)
                           optimized))))
               (optimize (form)
                 (etypecase form
                   ((cons (eql progn))
                    (mapc #'optimize (rest form)))
                   (string
                    (write-string form concatenated-constants))
                   (t (cut) (push form optimized)))))
        (optimize form)
        (cut))
      (setf optimized (nreverse optimized))
      (if (rest optimized)
          `(progn ,@optimized)
          (first optimized))))
  
  (defun formatexpand (form ~ stream)
    (formatexpand-finalize (formatexpand-partially form ~ stream) stream))
  
  (defun formatexpand-forms (forms ~ stream)
    (let ((result (formatexpand `(progn ,@forms) ~ stream)))
      (if (typep result '(cons (eql progn)))
          (rest result)
          (list result))))
  
  (defun formatexpand-partially (form ~ stream)
    (flet ((expand (operator opargs args)
             (let ((format (find-~format operator :errorp nil)))
               (if format
  