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:          (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)))))))
      ;; if we were indeed passed a future, attach the callback to it AND run the
      ;; future if it has finished.
      (if (futurep future)
  
negative.code: 
  (defun finish (future &rest values)
    "Mark a future as finished, along with all values it's finished with."
    (let ((first-val (car values)))
      (cond ((and (futurep first-val)
                  (future-reattach-callbacks future))
             (setf (future-callbacks first-val) (future-callbacks future))
             (run-future first-val))
            (t
             (setf (future-finished future) t
                   (future-values future) values)
             (run-future future)))))
  
  (defun attach-cb (future-values cb)
    "Attach a callback to a future. The future must be the first value in a list
  