anchor.diff:  (defun make (nthread &optional constructor &rest arguments)
     (declare (type (and unsigned-byte fixnum) nthread)
              (dynamic-extent arguments))
  -  (let* ((state   (list :running))
  -         (queue   (sb-queue:make-queue))
  -         (stacks  (map-into (make-array nthread) #'work-stack:make))
  -         (threads (make-array nthread))
  +  (let* ((threads (make-array nthread))
            (default-bindings (getf arguments :bindings))
            (arguments (loop for (key value) on arguments by #'cddr
                             unless (eql key :bindings)
                               nconc (list key value)))
  -         (wqueue  (if constructor
  -                      (apply constructor
  -                             :lock    (make-mutex)
  -                             :cvar    (make-waitqueue)
  -                             :nthread nthread
  -                             :state   state
  -                             :queue   queue
  -                             :stacks  stacks
  -                             :threads threads
  -                             arguments)
  -                      (%make-queue nthread
  -                                   state
  -                                   queue
  -                                   stacks
  -                                   threads))))
  -    (finalize wqueue (let ((lock  (queue-lock  wqueue))
  -                           (cvar  (queue-cvar  wqueue))
  +         (wqueue  (apply (or constructor #'%make-queue)
  +                         :locks   (map-into (make-array nthread) #'make-mutex)
  +                         :cvar    (make-waitqueue)
  +                         :nthread nthread
  +                         :state   (list :running)
  +                         :queue   (sb-queue:make-queue)
  +                         :stacks  (map-into (make-array nthread) #'work-stack:make)
  +                         :threads threads
  +                         arguments)))
  +    (finalize wqueue (let ((cvar  (queue-cvar  wqueue))
                              (state (queue-state wqueue)))
                         (lambda ()
  -                        (with-mutex (lock)
  -                          (setf (car state) :done)
  -                          (condition-broadcast cvar)))))
  +                        (setf (car state) :done)
  +                        (condition-broadcast cvar))))
       (let ((binding-names (mapcar #'car default-bindings))
             (binding-values (mapcar #'cdr default-bindings)))
         (dotimes (i nthread wqueue)
  
positive.code:           (try)
            (unless (condition-wait cvar lock :timeout timeout)
              (grab-mutex lock))
            (setf timeout (min 1.0 (* timeout 1.5))))))))
  
  (defun %make-worker (wqueue i &optional binding-names binding-compute)
    (let* ((lock   (queue-lock   wqueue))
           (cvar   (queue-cvar   wqueue))
           (state  (queue-state  wqueue))
           (queue  (queue-queue  wqueue))
  
negative.code: (in-package "WORK-QUEUE")
  
  (defstruct (queue
              (:constructor %make-queue))
    (locks   (error "foo") :type (simple-array mutex 1)
                           :read-only t)
    (cvar    (make-waitqueue) :type waitqueue
                           :read-only t)
  