anchor.diff:    (sort
       seq
       (lambda (x y)
  -        (< (position x order-lst :test test)
  -           (position y order-lst :test test)))
  +      (< (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.
  -  "
  +
  +   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)))
  
positive.code: (defun group (lst n)
    (if (zerop n) (error "zero length"))
    (labels ((rec (lst acc)
             (let ((rest (nthcdr n lst)))
               (if (consp rest)
                 (rec rest (cons (subseq lst 0 n) acc))
                 (nreverse (cons lst acc))))))
      (rec lst nil)))
  
  ;(group (list 1 2 3 4 6) 2)
  
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
  