anchor.diff:                                 (declare (ignorable ,var))
                                  (progn ,result))))))))
   
  +(declaim (maybe-inline parallel:map parallel:reduce parallel:map-group-reduce))
   (defun parallel:map (type function arg &key (wait t))
     (let* ((arg (coerce arg 'simple-vector))
            (function (if (functionp function)
  
positive.code:                                      table))
                        tables)
                   (let ((vector (coerce (shiftf vector nil) 'simple-vector)))
                     (parallel:dotimes (i (length vector)
                                          (if master-table
                                              (values vector
                                                      (clean-table master))
                                              vector))
                       (let* ((cache  (aref vector i))
                              (values (cdr cache)))
                         (setf (cdr cache) (reduce reduce values))))))))
  
negative.code:                                   &key (group-test #'eql)
                                         group-by
                                         (wait t)
                                         (master-table nil))
    (let* ((arg     (coerce sequence 'simple-vector))
           (nthread (work-queue:worker-count
                     (work-queue:current-queue
  