anchor.diff:  
   (defun shortest (seqs)
     "Return the shortest seq in SEQS."
  -  (flet ((shorter (x y)
  -           (select (longer x y)
  -             (x y)
  -             (y x))))
  -    (reduce #'shorter seqs)))
  +  (reduce (lambda (x y)
  +            (if (eql (longer x y) x) y x))
  +          seqs))
   
   (defun slice-bounds (seq start end)
     "Normalize START and END, which may be negative, to offsets
  
positive.code:   (replace seq value :start1 start :end1 end)
    value)
  
  (defun counted-filter (pred key seq count reversed?)
    "Helper for FILTER."
    (fbind (pred key)
      (declare (dynamic-extent #'pred #'key))
      (let ((ret '()))
        (block nil
          (map nil
               (lambda (item)
                 (when (pred (key item))
                   (push item ret)
                   (when (zerop (decf count))
                     (return))))
               seq))
        (if reversed?
            ret
            (nreverse ret)))))
  
  (defun filter (pred seq &rest args &key count from-end (start 0) end
                                          (key #'identity)
                 &allow-other-keys)
    "Almost the opposite of `remove-if-not'.
  The difference is the handling of COUNT."
    (if (null count)
        (apply #'remove-if-not pred seq args)
        (let* ((count (max 0 count))      ;COUNT can be negative.
               (seq (if from-end (reverse seq) seq))
               (items (counted-filter pred
                                      key
                                      (nsubseq seq start end)
                                      count
                                      from-end)))
          (make-sequence-like seq (length items) :initial-contents items))))
  
  (assert (equal '(0 2 4 6 8) (filter #'evenp (iota 100) :count 5)))
  (assert (equalp #(0 2 4 6 8) (filter #'evenp (coerce (iota 100) 'vector) :count 5)))
  
negative.code:                                     &rest args
                                      &key (test '#'eql) count
                                      &allow-other-keys)
    "In the absence of COUNT, expand directly to `remove'."
    (if (null count)
        `(remove ,item ,seq :test-not ,test ,@(remove-from-plist args :test))
        decline))
  