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: (assert (equal (intersperse/list 'y '(x z)) '(x y z)))
  
  (defun intersperse/seq (new-elt seq)
    (if (emptyp seq)
        (copy-seq seq)
        (let* ((len1 (length seq))
               (len2 (1- (* 2 len1)))
  
negative.code:                                       &rest args
                                        &key count
                                        &allow-other-keys)
    "In the absence of COUNT, expand directly to `remove-if-not'."
    (if (null count)
        `(remove-if-not ,pred ,seq ,@args)
        decline))
  
  (defun keep (item seq &rest args &key (test #'eql) from-end key count
               &allow-other-keys)
    "Almost, but not quite, an alias for `remove'.
  
  The difference is the handling of COUNT. For `keep', COUNT is the
  number of items to *keep*, not remove.
  
       (remove 'x '(x y x y x y) :count 2)
       => '(y y x y)
  
       (keep 'x '(x y x y x y) :count 2)
       => '(x x)"
    (declare (ignore from-end key))
    (let ((args (remove-from-plist args :test :count)))
      (cond ((null count)
             (apply #'remove item seq :test-not test args))
            ((< count 1)
             (make-sequence-like seq 0))
            (t (fbind ((test (curry test item)))
                 (declare (dynamic-extent #'test))
                 (apply #'filter #'test seq :count count args))))))
  
  (assert (equal '((a 1) (a 2))
                 (keep 'a '((a 1) (b) (c) (a 2) (a 3) (b) (c) (a 4) (a 5))
  