anchor.diff:           (future (if (futurep future) future (car future-values)))
            (cb-return-future (make-future))
            (cb-wrapped (lambda (&rest args)
  -                       (apply #'finish
  -                              (append (list cb-return-future)
  -                                      (multiple-value-list (apply cb args)))))))
  +                       (let ((cb-return (multiple-value-list (apply cb args))))
  +                         (apply #'finish (append (list cb-return-future)
  +                                                 cb-return))))))
       ;; if we were indeed passed a future, attach the callback to it AND run the
       ;; future if it has finished.
       (if (futurep future)
  
positive.code:      future. Also supports attaching callbacks to the future such that they will
       be called with the computed value(s) when ready."))
  
  (defun make-future ()
    "Create a blank future."
    (make-instance 'future))
  
  (defun futurep (future)
    "Is this a future?"
  
negative.code:           (push cb-wrapped (future-callbacks future))
            (run-future future))
          ;; not a future, just a value. run the callback directly
          (apply cb-wrapped future-values))
      cb-return-future))
  
  (defmacro attach (future-gen cb)
    "Macro wrapping attachment of callback to a future (takes multiple values into
  