anchor.diff:    (labels ((rec (lst)
                (if lst
                  (mapcan (lambda (x)
  -                           (let ((head (car lst)))
  -                             (if (funcall forkp head)
  -                               (list (cons head x) x)
  -                               (list (cons head x)))))
  +                         (let ((head (car lst)))
  +                           (if (funcall forkp head)
  +                             (list (cons head x) x)
  +                             (list (cons head x)))))
                          (rec (cdr lst)))
                  (list ()))))
       (rec lst)))
  
positive.code:   (sort
      seq
      (lambda (x y)
          (< (position x order-lst :test test)
             (position y order-lst :test test)))
      :key key))
  
  (defun denotative-stable-sort (order-lst seq &key key test)
    " denotative-stable-sort order-lst seq &key key test => sorted-seq
      A stable variation of denotative-sort. See the denotative-sort.
    "
    (stable-sort
      seq
      (lambda (x y) (< (position x order-lst :test test) (position y order-lst :test test)))
  
negative.code: ;;; I was wrong. It seems convinient to have the default method.
  (defmacro dlambda (&body keyword-args-body)
    (with-gensyms (args)
      `(lambda (&rest ,args)
         (case (car ,args)
           ,@(mapcar
               (lambda (x)
                 `(,(if (eq (car x) t)
                      t
                      (list (car x)))
                    (apply (lambda ,@(cdr x))
                           ,(if (eq (car x) t)
                              args
                              `(cdr ,args)))))
               keyword-args-body)))))
  
  ;;; LREC function and ALREC macro
  