anchor.diff:                           :collect (gensym (symbol-name name)))))
        ,@body))
   
  -(defmacro future-let (&key future force bindings pre-body 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 ,sym)))
  +                            :collect `(,name (,force ,@(unsplice kernel) ,sym)))
            (let (,@(loop
                       :for sym :in syms
                       :for (nil form) :in pairs
  -                    :collect `(,sym (,future ,form)))
  +                    :collect `(,sym (,future ,@(unsplice kernel) ,form)))
                  ,@non-pairs)
              ,@declares
              ,@(unsplice pre-body)
  
positive.code: 
  (setf *make-optimizer-data* 'make-task-counter-instance)
  
  (defmacro accept-task-p ()
    ;; needs fast inline for small functions
    `(locally (declare #.*full-optimize*)
       (the boolean (optimizer-flag (the kernel *kernel*)))))
  
  (defmacro define-update-task-count/no-lock (name op)
    `(defun/type ,name (kernel delta) (kernel fixnum) t
  
negative.code:        ;; return form below
         (delete-stale-registrations)
         (register-name name)
         (with-gensyms (kernel)
           `(progn
              (,',defun ,(unchecked-name name) (,kernel ,@params)
                  ,,@(unsplice (when types ``(kernel ,@,(first types))))
                  ,,@(unsplice (when types (second types)))
                ,@declares
                (declare (ignorable ,kernel))
                (macrolet ((plet (bindings &body body)
                             `(,',',plet/fast ,',kernel ,bindings
                                ,@body))
                           (plet-if (predicate bindings &body body)
                             `(,',',plet-if/fast ,',kernel ,predicate ,bindings
                                ,@body))
                           ,@(registered-macrolets kernel))
                  ,@body))
              (defun/wrapper ,name ,(unchecked-name name) ,params
                ,@(unsplice docstring)
                (check-kernel)
                (,',call-impl))
              (eval-when (:load-toplevel :execute)
                (register-fn ',name))
              ',name)))))
  
  (defmacro call-impl-in-worker ()
    (with-gensyms (worker channel)
  