anchor.diff:  (defun p (x)
     (stack-p x))
   
  +(declaim (inline bulk-task-hintify))
   (defun bulk-task-hintify (x &optional (hint 0))
  -  (if (bulk-task-p x)
  -      (cons (truncate (* hint (length (bulk-task-subtasks x))))
  -            x)
  -      x))
  +  (etypecase x
  +    ((or function symbol task) x)
  +    (bulk-task
  +     (cons (truncate (* hint (length (bulk-task-subtasks x))))
  +           x))))
   
   (defun push (stack x &optional (hint 0))
     (with-mutex ((stack-lock stack))
  
positive.code:        (let* ((index (position nil data :from-end t
                                          :test-not #'eql))
                (task  (and index (aref data index))))
           (etypecase task
             (null
              (setf (fill-pointer data) 0)
              (return nil))
             (cons
              (multiple-value-bind (subtask index)
                  (bulk-find-task task)
                (if subtask
                    (let ((bulk-task (cdr task)))
                      (funcall subtask bulk-task)
                      (when (= (atomic-decf (bulk-task-remaining bulk-task))
                               1)
                        (funcall (bulk-task-fun bulk-task) bulk-task))
                      (return t))
                    (setf (aref data index)   nil
                          (fill-pointer data) index))))
             ((or task symbol function)
              (setf (aref data index) nil
                    (fill-pointer data) index)
              (if (task-p task)
                  (funcall (task-fun task) task)
                  (funcall task))
              (return t))))))))
  
negative.code:                              :read-only t))
  
  (defstruct (bulk-task
              (:constructor nil))
    ;; count waiting to be executed
    (waiting   (error "Missing arg") :type word)
    ;; count not done yet
    (remaining (error "Missing arg") :type word)
    (subtasks  (error "Missing arg") :type (simple-array (or symbol function) 1)
                                     :read-only t)
    (cleanup   nil                   :type (or list function)
                                     :read-only t))
  
  (deftype task-designator ()
  