anchor.diff:                                 (call-with-future-values
                                   cleanup dependencies)))))
                    #'make-future)))
  -    (work-queue:push-self future parallel-future:*context*)
  +    (work-queue:push-self future (or (work-queue:current-queue)
  +                                      parallel-future:*context*))
       future))
   
   (defun future-value (future)
  
positive.code:            :subtask-function (lambda (subtask self index)
                                 (declare (ignore subtask self))
                                 (funcall function index)))))
      (work-queue:push-self future 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*)
                             (error "No current queue")))
           (max          (expt worker-count 2)))
      (if (<= count max)
  
negative.code:          (function (if (functionp function)
                         function
                         (fdefinition function)))
           (accumulators (make-array (work-queue:worker-count
                                      (or (work-queue:current-queue)
                                          parallel-future:*context*))
                                     :initial-element seed))
           (future
             (if key
  