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:       ((cons (cons symbol))
         (destructuring-bind ((operator &rest opargs) &rest args) form
           (expand operator opargs args)))
        (string form)
        ((or character number) (write-to-string form :escape nil))
        (t form))))
  
  (defun formatexpand-forms-partially (forms ~ stream)
    (mapcar (lambda (form)
              (formatexpand-partially form ~ stream))
            forms))
  
  (defmacro ~format ((~ &optional stream) &body body)
    (let* ((stream-var (gensym (string '#:stream))))
      `(with-~format-stream (,stream-var
                             ,@(when stream (list :stream stream)))
         ,@(formatexpand-forms body ~ stream-var))))
  
  (defmacro define-~format (name
  