anchor.diff:             :subtask-function (lambda (subtask self index)
                                  (declare (ignore subtask self))
                                  (funcall function index)))))
  -    (work-queue:push-self future parallel-future:*context*)
  +    (work-queue:push-self future (or (work-queue:current-queue)
  +                                     parallel-future:*context*))
       future))
   
   (defun call-n-times (count function aggregate-function &optional cleanup)
  -  (let* ((worker-count (or (work-queue:worker-count parallel-future:*context*)
  +  (let* ((worker-count (or (work-queue:worker-count
  +                            (or (work-queue:current-queue)
  +                                parallel-future:*context*))
                              (error "No current queue")))
            (max          (expt worker-count 2)))
       (if (<= count max)
  
positive.code:          (function (if (functionp function)
                         function
                         (fdefinition function)))
           (accumulators (make-array (work-queue:worker-count parallel-future:*context*)
                                     :initial-element seed))
           (future
             (if key
  
negative.code:                           (setf (promise-%values promise)
                                  (multiple-value-list (apply thunk args)))
                            (%promise-upgrade promise :done :waiting)))))
      (work-queue:push-self promise (or (work-queue:current-queue)
                                        parallel-future:*context*))
      promise))
  
  (defun promise-value (promise)
  