anchor.diff:             (values))))))
   
   (defun dump-logs (&optional (output-stream *standard-output*))
  +  "Write out all recorded log lines to the given output stream."
     (with-lock-held (*log-buffer-lock*)
       (loop :for chunk :across *log-buffer* :do
          (loop :for line :across chunk :do
  
positive.code:     (get-output-stream-string stream)))
  
  (defun symbol-nconc-gensym (first-bit &rest other-bits)
    (gensym (apply '%symbol-nconc first-bit other-bits)))
  
  (defun symbol-nconc-intern (package first-bit &rest other-bits)
    (if package
        (intern (apply '%symbol-nconc first-bit other-bits) package)
        (intern (apply '%symbol-nconc first-bit other-bits))))
  
  (defun progn-concatenate (&rest forms)
    (let ((result (list 'progn)))
      (dolist (form forms)
        (cond
  
negative.code:        ,sigil)))
  
  (defmacro -> (value &body forms)
    "Thread the given value through the provided forms.
  
  This is very similar to Clojure's macro with the same name.
  
  This macro is just a simpler form of `as->' where the sigil is
  automatically inserted as the first argument to each function call.
  As a convenience, some forms will be re-written to use `funcall'
  automatically.  For example, these forms should have the same result.
  
      (let ((fn-4 (lambda (arg) (1+ arg))))
        (-> value
          (fn arg1 arg2)
          (fn2)
          #'fn3
          fn-4))
  
      (let ((fn-4 (lambda (arg) (1+ arg))))
        (as-> value #:sigil
          (fn #:sigil arg1 arg2)
          (fn2 #:sigil)
          (funcall #'fn3 #:sigil)
          (funcall fn-4 #:sigil)))"
    (let ((sigil (gensym "SIGIL")))
      (labels
          ((prepare (form)
  