anchor.diff:     printed to the stream
   
      A call to the function with no arguments returns the output string"
  -  (let ((arr (make-array 100
  -                         :element-type 'character :fill-pointer 0
  -                         :adjustable T))
  -        (*print-pretty* pretty)
  -        (printed? nil)
  -        (print-empty? (null ignore-empty-strings-and-nil))
  -        (delimiter
  -          (typecase delimiter
  -            ((or null string) delimiter)
  -            (t (princ-to-string delimiter)))))
  -    (labels ((coerce-it (item)
  -               (typecase item
  -                 ((or null string character) item)
  -                 (T (princ-to-string item))))
  -             (write-it (item s)
  -               (typecase item
  -                 (character (write-char item s))
  -                 (string (write-sequence item s))))
  -             (not-empty? (item)
  -               (and item (typecase item
  -                           (string (plusp (length item)))
  -                           (character t))))
  -             (p (item &aux (item (coerce-it item)))
  -               (with-output-to-string (s arr)
  -                 (when (or print-empty? (not-empty? item))
  -                   (when (and printed? delimiter)
  -                     (write-sequence delimiter s))
  -                   (write-it item s)
  -                   (setf printed? t)))))
  -      (lambda (&rest args)
  -        (declare (dynamic-extent args))
  -        (if args
  -            (mapc #'p args)
  -            (coerce arr 'string))))))
  -
  -(defun make-string-builder (&optional
  -                              delimiter
  -                              (ignore-empty-strings-and-nil t))
  -  "Create a function that will build up a string for you
  -   Each call to the function with arguments appends those arguments to the string
  -   with an optional delimiter between them.
  -
  -   if ignore-empty-strings-and-nil is true neither empty strings nor nil will be
  -   printed to the stream
  -
  -   A call to the function with no arguments returns the output string"
  -  (let ((formatter (make-formatter :delimiter delimiter))
  +  (let ((formatter (make-formatter :delimiter delimiter :pretty pretty :stream stream))
           (include-empty? (not ignore-empty-strings-and-nil)))
       (flet ((include-arg? (arg)
                (or include-empty?
  
positive.code:       (lambda (&rest args)
          (cond
            ((null args)
             (let (*print-pretty*)
               (format stream format-string (value))))
            (args
             (destructuring-bind (format-string &rest args) args
                 (value format-string args))))
          ))))
  
  (defmacro with-formatter ((name &key delimiter stream) &body body)
    "A macro makes a function with name for body that is a string formatter
  see make-formatter"
    (alexandria:with-unique-names (fn-sym)
      `(let ((,fn-sym (make-formatter :delimiter ,delimiter :stream ,stream)))
         (flet ((,name (&rest args) (apply ,fn-sym args)))
           ,@body))))
  
  (defmacro with-formatter-output ((name &key delimiter stream) &body body)
    "A macro makes a function with name for body that is a string formatter
  see make-formatter.
  This form returns the result of that formatter"
    `(with-formatter (,name :delimiter ,delimiter :stream ,stream )
       ,@body
       (,name)))
  
  (defun make-string-builder-old (&optional
                              delimiter
                              (ignore-empty-strings-and-nil t)
                              (pretty nil))
    "Create a function that will build up a string for you
     Each call to the function with arguments appends those arguments to the string
     with an optional delimiter between them.
  
negative.code: 
  binds *print-pretty* to nil
  "
    (let* ((*print-pretty* pretty)
           (format-string (if delimiter
                              (format nil "~~{~~?~~^~a~~}" delimiter)
                              "~{~?~}")))
  