anchor.diff:  A new thread which uses the current kernel should be given these
   bindings (see bordeaux-threads:*default-special-bindings*)."
     (check-kernel)
  -  (with-kernel-slots (worker-bindings) *kernel*
  -    (copy-alist worker-bindings)))
  +  (with-kernel-slots (worker-info) *kernel*
  +    (with-worker-info-slots (bindings) worker-info
  +      (copy-alist bindings))))
   
   (defun kernel-worker-count ()
     "Return the number of workers in the current kernel."
  
positive.code: 
  (in-package #:lparallel.kernel)
  
  (defslots kernel ()
    ((scheduler       :reader scheduler :type scheduler)
     (workers         :reader workers   :type vector)
     (workers-lock)
     (worker-bindings                   :type list)
     (worker-context                    :type function)
     (worker-name                       :type string)))
  
  (defslots worker ()
    ((thread           :reader thread)
     (running-category :reader running-category :initform nil)))
  
  (defslots channel ()
    ((queue  :reader channel-queue  :type queue)
  
negative.code:   (funcall worker-context (lambda () (%call-with-kernel-handler fn))))
  
  (defun enter-worker-loop (kernel worker)
    (with-kernel-slots (worker-info) kernel
      (with-worker-info-slots (context) worker-info
        (call-with-worker-context
         context
         (lambda () (worker-loop kernel worker))))))
  
  (defun make-worker (kernel)
    (with-kernel-slots (worker-info) kernel
      (with-worker-info-slots (bindings name) worker-info
        (let* ((worker (make-worker-instance :thread nil))
               (blocker (make-queue))
               (worker-thread (with-thread (:bindings bindings :name name)
                                (pop-queue blocker)
                                (enter-worker-loop kernel worker))))
          (with-worker-slots (thread) worker
            (setf thread worker-thread))
          (push-queue 'proceed blocker)
          worker))))
  
  (defun make-kernel (worker-count
                      &key
                      (bindings `((*standard-output* . ,*standard-output*)
                                  (*error-output*    . ,*error-output*)))
                      (worker-context #'funcall)
                      (name "lparallel-worker"))
    "Create a kernel with `worker-count' number of worker threads.
  