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