anchor.diff:  (deftype status ()
     `(member :waiting :done))
   
  -(defstruct (promise
  +(defstruct (parallel:promise
               (:constructor make-promise (function))
               (:include work-stack:task))
     %values
  
positive.code:                                    parallel-future:*context*))
      promise))
  
  (defun promise-value (promise)
    (declare (type promise promise))
    (when (work-queue:worker-id)
      (work-queue:progress-until
  
negative.code:                                   parallel-future:*context*))
      future))
  
  (defun parallel:future-value (future)
    (declare (type future future))
    (when (work-queue:worker-id)
      (work-queue:progress-until (lambda ()
                                   (eql (future:status future) :done))))
    (future:wait future :done)
    (values-list (future-%values future)))
  
  (defun parallel:future-value* (future)
    (loop
      (multiple-value-call
          (lambda (&optional (value nil value-p) &rest values)
            (cond ((future-p value)
                   (setf future value))
                  (value-p
                   (return (multiple-value-call #'values
                             value (values-list values))))
                  (t
                   (return (values)))))
        (future-value future))))
  
  (defmacro parallel:bind ((&rest bindings)
                           &body body)
  