anchor.diff:  (defmacro define-plet-if/fast (name
                                  future/fast
                                  update-task-count/no-lock)
  -  `(defmacro ,name (predicate bindings &body body)
  -     `(%plet/fast ,',future/fast
  +  `(defmacro ,name (kernel predicate bindings &body body)
  +     `(%plet/fast ,kernel
  +                  ,',future/fast
                     ,',update-task-count/no-lock
  -                  (and (accept-task-p) ,predicate)
  +                  (and (accept-task-p ,kernel) ,predicate)
                     ,bindings ,body)))
   
   (define-plet-if/fast plet-if/fast
  
positive.code: (define-update-task-count update-task-count/-1 update-task-count/no-lock/-1)
  
  (defmacro define-future/fast (name update-task-count)
    `(defmacro ,name (&body body)
       (with-gensyms (kernel)
         `(let ((,kernel (the kernel *kernel*)))
            (declare (type kernel ,kernel))
            (future
              ,kernel
              (unwind-protect
                   (progn ,@body)
                (,',update-task-count ,kernel -1)))))))
  
  (define-future/fast future/fast    update-task-count)
  (define-future/fast future/fast/-1 update-task-count/-1)
  
  (defun force/fast (future)
    (declare #.*full-optimize*)
    (if (fulfilledp future)
        (force future)
        (let ((kernel *kernel*)
              (worker *worker*))
          (loop
             (when (fulfilledp future)
               (return (force future)))
             #+lparallel.with-green-threads (thread-yield)
             (steal-work kernel worker)))))
  
  (defmacro %%plet/fast (future/fast update-task-count/no-lock
                         predicate future-count bindings body)
    `(with-lock-predicate/wait*
         :lock            (lock (optimizer-data *kernel*))
         :predicate1      ,predicate
         :predicate2      (accept-task-p)
         :succeed/lock    (,update-task-count/no-lock *kernel* ,future-count)
         :succeed/no-lock (future-let :future ,future/fast
                                      :force force/fast
                                      :bindings ,bindings
                                      :body ,body)
         :fail            (let ,bindings ,@body)))
  
  (defmacro %plet/fast (future/fast update-task-count/no-lock
                        predicate bindings body)
    (with-parsed-let-args (pairs non-pairs syms) bindings
      (declare (ignore non-pairs syms))
      (if pairs
          `(%%plet/fast ,future/fast ,update-task-count/no-lock
                        ,predicate ,(length pairs) ,bindings ,body)
          `(let ,bindings ,@body))))
  
  (defmacro define-plet/fast (name
                              future/fast
                              update-task-count/no-lock)
    `(defmacro ,name (bindings &body body)
       `(%plet/fast ,',future/fast
                    ,',update-task-count/no-lock
                    (accept-task-p)
                    ,bindings
                    ,body)))
  
  
negative.code:                          :collect (gensym (symbol-name name)))))
       ,@body))
  
  (defmacro future-let (&key kernel future force bindings pre-body body)
    (with-parsed-body (nil declares body)
      (with-parsed-let-args (pairs non-pairs syms) bindings
        `(symbol-macrolet ,(loop
                              :for sym :in syms
                              :for (name nil) :in pairs
                              :collect `(,name (,force ,@(unsplice kernel) ,sym)))
           (let (,@(loop
                      :for sym :in syms
                      :for (nil form) :in pairs
                      :collect `(,sym (,future ,@(unsplice kernel) ,form)))
                 ,@non-pairs)
             ,@declares
             ,@(unsplice pre-body)
  