anchor.diff:              lparallel.kernel::use-caller-p
               lparallel.kernel::steal-work
               lparallel.kernel::call-with-task-handler
  +            lparallel.kernel::with-task-context
               lparallel.kernel::limiter-accept-task-p
               lparallel.kernel::limiter-count
               lparallel.kernel::limiter-lock)
  
positive.code:                (and (accept-task-p/fast ,kernel) ,predicate)
                 ,bindings ,body))
  
  (defun call-impl-in-worker (call-impl)
    (if *worker*
        (funcall call-impl)
        (let ((channel (make-channel)))
          (submit-task channel (lambda ()
                                 (multiple-value-list (funcall call-impl))))
          (values-list (receive-result channel)))))
  
  (defmacro define-defpun (defpun doc defun &rest types)
    `(defmacro ,defpun (name lambda-list ,@types &body body)
  
negative.code:               (defun/wrapper ,name ,(unchecked-name name) ,lambda-list
                  ,@(unsplice docstring)
                  (let ((,kernel (check-kernel)))
                    (call-impl-fn ,kernel (lambda () (call-impl ,kernel)))))
                (eval-when (:load-toplevel :execute)
                  (with-lock-held (*registration-lock*)
                    (register-fn ',name)))
  