anchor.diff:    "Destructively remove only the first occurence of ITEM in LIST.
   
   From Lisp 1.5."
  +  ;; Cf. `delq'.
     (let ((splice '()))
       (loop for x = list then (cdr x) do
         (cond ((endp x) (return list))
  
positive.code:   (assert (not (memq nil list2)))
    (assert (eq list1 list2)))
  
  (defun mapply (fn &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 using `apply`.
  
      (mapply #'+ '((1 2 3) (4 5 6)))
      => (6 15)
  
  In variadic use, `mapply` acts as if `mapcar #'append` had first been
  used:
  
      (mapply #'+ xs ys)
      ≡ (mapply #'+ (mapcar #'append xs ys))
  
  But the actual implementation is more efficient."
    (apply #'mapcar
           (lambda (&rest args)
             (apply fn (apply #'append args)))
           lists))
  
  (define-compiler-macro mapply (fn &rest lists)
    "Translate from apply to multiple-value-call."
    (let ((vars (loop for nil in lists collect (string-gensym 'arg))))
      (with-gensyms (gfn)
        `(let ((,gfn (ensure-function ,fn)))
           (mapcar
            (lambda (,@vars)
              (multiple-value-call ,gfn
                ,@(loop for var in vars
                        collect `(values-list ,var))))
            ,@lists)))))
  
  (defsubst assocdr (item alist &rest args)
    "Like (cdr (assoc ...))"
  
negative.code: 
  (defun delete-dups (list)
    "Destructively remove duplicates from a list, starting from the end,
  testing with `equal'.
  
  Equivalent to Emacs's `delete-dups`."
    (declare (list list) (inline delete-duplicates))
  