anchor.diff:    (find char +whitespace-characters+))
   
   (defmacro as-> (value sigil &body forms)
  +  "Thread the given value through the provided forms.
  +
  +This is very similar to Clojure's macro with the same name.
  +
  +This macro first binds `sigil' to `value'.  Then, it repeatedly binds
  +`sigil' to be the output of each form you provide in `forms'.  These
  +forms should produce the same result.
  +
  +    (as-> value x
  +      (+ x 1)
  +      (* x x)
  +      3)
  +
  +    (let ((x value)
  +          (x (+ x 1))
  +          (x (* x x))
  +          (x 3))
  +      x)"
     (labels
         ((binding (form)
            `(,sigil ,form)))
  
positive.code:        (car result)))))
  
  (defun bodyify (form)
    (if (and (consp form)
             (eq 'progn (car form)))
        (cdr form)
  
negative.code:     (get-output-stream-string stream)))
  
  (defun symbol-nconc-gensym (first-bit &rest other-bits)
    "Create a gensym whose name is the concatenation of all the
  fragments provided.
  
  If one of the provided fragments is a symbol, it is turned into a
  string with `symbol-name'."
    (gensym (apply '%symbol-nconc first-bit other-bits)))
  
  (defun symbol-nconc-intern (package first-bit &rest other-bits)
    "Intern a symbol in the given package whose name is the
  concatenation of all the fragments provided.
  
  If one of the provided fragments is a symbol, it is turned into a
  string with `symbol-name'.
  
  If a non-nil `package' is provided, it will be passed to `intern'."
    (if package
        (intern (apply '%symbol-nconc first-bit other-bits) package)
        (intern (apply '%symbol-nconc first-bit other-bits))))
  
  (defun progn-concatenate (&rest forms)
    "Return a form equivalent to evaluating each form in `forms' but
  with unnecessary `progn' uses removed."
    (let ((result (list 'progn)))
      (dolist (form forms)
        (cond
  