anchor.diff:  
   (defmethod execute ((this discarding-executor) (task function) &key
                                                                    (priority :medium)
  -                                                                 (important-p t))
  -  (if important-p
  -      (put-into (task-queue-of this) task priority)
  -      (try-put-replacing (task-queue-of this) task priority)))
  +                                                                 (important-p t)
  +                                                                 processing-thread)
  +  (if (or (not important-p) (and processing-thread
  +                                 (equal (current-thread) processing-thread)))
  +      (try-put-replacing (task-queue-of this) task priority)
  +      (put-into (task-queue-of this) task priority)))
   
   
   (definline make-discarding-executor (&optional queue-size)
  
positive.code: ;;;
  ;;;
  (defclass single-threaded-executor (disposable)
    ((executor :initarg :executor :initform (error ":executor missing"))))
  
  
  (defmethod initialize-instance :after ((this single-threaded-executor) &key special-variables)
    (with-slots (executor) this
      (bt:make-thread (lambda ()
                        (progv special-variables (mapcar (constantly nil) special-variables)
                          (run executor)))
                      :name "single-threaded-executor")))
  
  
  (define-destructor single-threaded-executor (executor)
  
negative.code: (defmethod execute ((this single-threaded-executor) (task function) &key
                                                                        (priority :medium)
                                                                        (important-p t))
    "Execute task in the dedicated thread. Block execution of the #'execute caller if maximum
  number of queued tasks is reached and :important-p is set to 't. Discard task if maximum number
  of queued tasks is reached, but :important-p is set to nil or posting thread and processing
  thread are the same."
    (with-slots (executor processing-thread) this
      (execute executor task :priority priority :important-p important-p
               :processing-thread processing-thread)))
  
  ;;;
  ;;;
  