anchor.diff:  
   (defmacro future (kernel &body body)
     `(make-future ,kernel (make-task-fn ,@body)))
  -
  -(defun/inline fulfilledp (future)
  -  (declare #.*full-optimize*)
  -  (not (eq (result future) +no-result+)))
  -
  -(defun/inline force (future)
  -  (declare #.*full-optimize*)
  -  (unwrap-result (result future)))
   
   ;;;; declarationp
   
  
positive.code: 
  (import-now alexandria:simple-style-warning
              lparallel.util::symbolicate/package
              lparallel.kernel::kernel
              lparallel.kernel::unwrap-result
              lparallel.kernel::wrap-error
              lparallel.kernel::make-task
              lparallel.kernel::make-task-fn
              lparallel.kernel::submit-raw-task
              lparallel.kernel::%kernel-worker-count
              lparallel.kernel::accept-task-p
              lparallel.kernel::limiter-data
              lparallel.kernel::with-limiter-slots
              lparallel.kernel::*make-limiter-data*
              lparallel.kernel::*worker*
              lparallel.kernel::steal-work
              lparallel.kernel::*kernel*
              lparallel.kernel::call-with-task-handler)
  
  ;;;; spin lock
  
negative.code: 
  (setf *make-limiter-data* 'make-limiter-data)
  
  (defmacro accept-task-p/fast (kernel)
    (check-type kernel symbol)
    `(locally (declare #.*full-optimize*)
       (accept-task-p (the kernel ,kernel))))
  
  (defun/type/inline use-caller-p (kernel) (kernel) t
    (declare #.*full-optimize*)
    (/= (limiter-data-limit (limiter-data kernel))
        (%kernel-worker-count kernel)))
  
  