anchor.diff:       future. Also supports attaching callbacks to the future such that they will
        be called with the computed value(s) when ready."))
   
  -(defun make-future ()
  +(defun make-future (&key preserve-callbacks (reattach-callbacks t))
     "Create a blank future."
  -  (make-instance 'future))
  +  (make-instance 'future :preserve-callbacks preserve-callbacks
  +                         :reattach-callbacks reattach-callbacks))
   
   (defun futurep (future)
     "Is this a future?"
  
positive.code:    (preserve-callbacks :accessor future-preserve-callbacks :initarg :preserve-callbacks :initform nil
      :documentation "When nil (the default) detaches callbacks after running
                      future.")
     (finished :accessor future-finished :initform nil
      :documentation "Marks if a future has been finished or not.")
     (events :accessor future-events :initform nil
  
negative.code:          (future (if (futurep future) future (car future-values)))
           (cb-return-future (make-future))
           (cb-wrapped (lambda (&rest 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)
  