anchor.diff:                 (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)))))
  +(defun/type call-impl-fn (kernel impl) (kernel function) t
  +  (declare #.*normal-optimize*)
  +  (cond (*worker*
  +         ;; handlers are already established; call directly
  +         (funcall impl))
  +        ((use-caller-p kernel)
  +         ;; establish handlers for stealing in this non-worker thread
  +         (call-with-task-handler impl))
  +        (t
  +         ;; not in a worker thread and not stealing; exec in a worker
  +         (let ((channel (let ((*kernel* kernel)) (make-channel))))
  +           (submit-task channel impl)
  +           (receive-result channel)))))
   
   (defmacro define-defpun (defpun doc defun &rest types)
     `(defmacro ,defpun (name lambda-list ,@types &body body)
  
positive.code:             lparallel.kernel::use-caller-p
              lparallel.kernel::steal-work
              lparallel.kernel::call-with-task-handler
              lparallel.kernel::limiter-accept-task-p
              lparallel.kernel::limiter-count
              lparallel.kernel::limiter-lock)
  
negative.code:      (make-task
        (lambda ()
          (unwind-protect/ext
           ;; task handler has already been established
           :main  (setf (result future) (with-task-context
                                          (funcall (future-fn future))))
           :abort (setf (result future) (wrap-error 'task-killed-error)))))
       kernel)
      future))
  