anchor.diff:  
   (defun delete-dups (list)
     "Destructively remove duplicates from a list, starting from the end,
  -testing with #'equal.
  +testing with `equal'.
   
   Equivalent to Emacs's `delete-dups`."
     (declare (list list) (inline delete-duplicates))
  
positive.code:   "Destructively remove only the first occurence of ITEM in LIST.
  
  From Lisp 1.5."
    (let ((splice '()))
      (loop for x = list then (cdr x) do
        (cond ((endp x) (return list))
  
negative.code:   (assert (not (memq nil list2)))
    (assert (eq list1 list2)))
  
  (defun mapply (fn list &rest lists)
    "`mapply' is a cousin of `mapcar'.
  
  If you think of `mapcar' as using `funcall':
  
      (mapcar #'- '(1 2 3))
      ≅ (loop for item in '(1 2 3)
              collect (funcall #'- item))
  
  Then `mapply' does the same thing, but with `apply' instead.
  
      (loop for item in '((1 2 3) (4 5 6))
              collect (apply #'+ item))
      => (6 15)
  
      (mapply #'+ '((1 2 3) (4 5 6)))
      => (6 15)
  
  In variadic use, `mapply' acts as if `append' had first been used:
  
      (mapply #'+ xs ys)
      ≡ (mapply #'+ (mapcar #'append xs ys))
  
  But the actual implementation is more efficient.
  
  `mapply' can convert a list of two-element lists in an alist:
  
      (mapply #'cons '((x 1) (y 2))
      => '((x . 1) (y . 2))"
    (let ((fn (ensure-function fn)))
      (multiple-value-call #'mapcar
        (lambda (&rest args)
          (apply fn (apply #'append args)))
        list
        (values-list lists))))
  
  (assert (equal (mapply #'cons '((x 1) (y 2))) '((x . 1) (y . 2))))
  
  (define-compiler-macro mapply (fn list &rest lists)
    (let* ((lists (cons list lists))
           (vars (loop for nil in lists collect (string-gensym 'arg))))
      (with-gensyms (gfn)
        `(let ((,gfn (ensure-function ,fn)))
           (mapcar
            (lambda ,vars
              ,(if (single vars)
                   `(apply ,gfn ,@vars)
                   ;; Use multiple-value-call to avoid consing.
                   `(multiple-value-call ,gfn
                      ,@(loop for var in vars
                              collect `(values-list ,var)))))
            ,@lists)))))
  
  (assert (equal (mapply #'list '((a 1) (b 2)) '((c 3) (d 4)))
                 '((a 1 c 3) (b 2 d 4))))
  
  (defsubst assocdr (item alist &rest args)
    "Like (cdr (assoc ...))"
  