anchor.diff:       task (tasks (svref workers (mod-decf random-index (length workers))))))
     #-ecl (values) #+ecl nil)
   
  -(defun/type maybe-wake-a-worker (scheduler) (scheduler) t
  +(defun/type maybe-wake-a-worker (scheduler)
  +    (scheduler) #-ecl (values) #+ecl null
     (declare #.*full-optimize*)
     (with-scheduler-slots (wait-lock wait-cvar wait-count notify-count) scheduler
       (with-lock-predicate/wait wait-lock (plusp (counter-value wait-count))
         (incf notify-count)
  -      (condition-notify wait-cvar))))
  +      (condition-notify wait-cvar)))
  +  #-ecl (values) #+ecl nil)
   
  -(defun/type schedule-task (scheduler task priority) (scheduler
  -                                                     (or task null) t) t
  +(defun/type schedule-task (scheduler task priority)
  +    (scheduler (or task null) t) #-ecl (values) #+ecl null
     (declare #.*full-optimize*)
     (ccase priority
       (:low     (with-scheduler-slots (low-priority-tasks) scheduler
                   (push-spin-queue task low-priority-tasks)))
       (:default (push-to-random-worker task scheduler)))
  -  (maybe-wake-a-worker scheduler))
  +  (maybe-wake-a-worker scheduler)
  +  #-ecl (values) #+ecl nil)
   
  -(defmacro do-workers ((worker-var workers start-index from-start-p)
  +(defmacro do-workers ((worker-var workers home-index from-home-index-p)
                         &body body)
  -  (with-gensyms (worker-index)
  -    `(do-indexes (,worker-index
  -                  (length (the simple-vector ,workers))
  -                  ,start-index
  -                  ,from-start-p)
  -       (let ((,worker-var (svref (the simple-vector ,workers) ,worker-index)))
  -         (declare (type worker ,worker-var))
  -         ,@body))))
  +  (with-gensyms (workers-var index-var)
  +    `(let ((,workers-var ,workers))
  +       (declare (type simple-vector ,workers-var))
  +       (do-indexes (,index-var
  +                    (length (the simple-vector ,workers-var))
  +                    ,home-index
  +                    ,from-home-index-p)
  +         (let ((,worker-var (svref (the simple-vector ,workers-var)
  +                                   ,index-var)))
  +           (declare (type worker ,worker-var))
  +           ,@body)))))
   
   (defun/type next-task (scheduler worker) (scheduler worker) (or task null)
     (declare #.*full-optimize*)
  
positive.code:        (declare (type fixnum ,left))
         (loop
            (when (zerop ,left)
              (return))
            (decf ,left)
            ,@body))))
  
  (defmacro do-indexes ((var size-form start from-start-p) &body body)
    (with-gensyms (size)
      `(let ((,var (the index ,start))
             (,size (the index ,size-form)))
         (declare (type index ,var ,size))
         (repeat/fixnum ,size
           ,(let ((next `(mod-incf ,var ,size)))
              (if from-start-p
                  `(progn ,@body ,next)
                  `(progn ,next ,@body)))))))
  
  ;;;; scheduler
  
  
negative.code:              (with-pop-success task queue
                 (return-from next-task task))
               (values))
             (try-pop-all ()
               (with-scheduler-slots (workers) scheduler
                 (do-workers (worker workers (worker-index worker) nil)
                   (try-pop (tasks worker))))
  