anchor.diff:                                    parallel-future:*context*))
       future))
   
  -(defun future-value (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)
  
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:     %promise-wait
      %promise-upgrade)
  
  (defun parallel:promise (thunk &rest args)
    (let ((promise
            (make-promise (lambda (promise)
                            (declare (type promise promise))
  