anchor.diff:  `name' is a string identifier for worker threads. It corresponds to
   the string returned by `bordeaux-threads:thread-name'."
     (check-type worker-count (integer 1))
  -  (let1 kernel (make-kernel-instance
  -                :scheduler (make-scheduler)
  -                :workers (make-array worker-count)
  -                :workers-lock (make-lock)
  -                :worker-bindings (nconc (copy-alist bindings)
  -                                        (acons '*debugger-hook* *debugger-hook*
  -                                               nil)
  -                                        (copy-alist *kernel-thread-locals*))
  -                :worker-context worker-context
  -                :worker-name name)
  -    (with-kernel-slots (workers worker-bindings) kernel
  -      (push (cons '*kernel* kernel) worker-bindings)
  -      (map-into workers (lambda () (make-worker kernel))))
  +  (let* ((bindings (nconc (copy-alist bindings)
  +                          (list (cons '*debugger-hook* *debugger-hook*))
  +                          (copy-alist *kernel-thread-locals*)))
  +         (worker-info (make-worker-info-instance
  +                       :bindings bindings
  +                       :context worker-context
  +                       :name name))
  +         (kernel (make-kernel-instance
  +                  :scheduler (make-scheduler)
  +                  :workers (make-array worker-count)
  +                  :workers-lock (make-lock)
  +                  :worker-info worker-info)))
  +    (with-kernel-slots (workers worker-info) kernel
  +      (with-worker-info-slots (bindings) worker-info
  +        (push (cons '*kernel* kernel) bindings)
  +        (map-into workers (lambda () (make-worker kernel)))))
       kernel))
   
   (defun check-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: 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-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."
  