anchor.diff:    (assert (eq (buffer mark1) (buffer mark2)))
     (let ((offset1 (offset mark1))
   	(offset2 (offset mark2)))
  -    (when (> offset1 offset2)
  -      (rotatef offset1 offset2))
  -    (downcase-buffer-region (buffer mark1) offset1 offset2)))
  +    (as-region (offset1 offset2)
  +      (downcase-buffer-region (buffer mark1) offset1 offset2))))
   
   (defmethod downcase-region ((offset1 integer) (mark2 mark))
     (let ((offset2 (offset mark2)))
  -    (when (> offset1 offset2)
  -      (rotatef offset1 offset2))
  -    (downcase-buffer-region (buffer mark2) offset1 offset2)))
  +    (as-region (offset1 offset2)
  +      (downcase-buffer-region (buffer mark2) offset1 offset2))))
   
   (defmethod downcase-region ((mark1 mark) (offset2 integer))
     (let ((offset1 (offset mark1)))
  -    (when (> offset1 offset2)
  -      (rotatef offset1 offset2))
  -    (downcase-buffer-region (buffer mark1) offset1 offset2)))
  +    (as-region (offset1 offset2)
  +      (downcase-buffer-region (buffer mark1) offset1 offset2))))
   
   (defun upcase-buffer-region (buffer offset1 offset2)
     (do-buffer-region (object offset buffer offset1 offset2)
  
positive.code:   (assert (eq (buffer mark1) (buffer mark2)))
    (let ((offset1 (offset mark1))
  	(offset2 (offset mark2)))
      (when (> offset1 offset2)
        (rotatef offset1 offset2))
      (upcase-buffer-region (buffer mark1) offset1 offset2)))
  
  (defmethod upcase-region ((offset1 integer) (mark2 mark))
    (let ((offset2 (offset mark2)))
      (when (> offset1 offset2)
        (rotatef offset1 offset2))
      (upcase-buffer-region (buffer mark2) offset1 offset2)))
  
  (defmethod upcase-region ((mark1 mark) (offset2 integer))
    (let ((offset1 (offset mark1)))
      (when (> offset1 offset2)
        (rotatef offset1 offset2))
      (upcase-buffer-region (buffer mark1) offset1 offset2)))
  
  (defun capitalize-buffer-region (buffer offset1 offset2)
    (let ((previous-char-constituent-p nil))
  
negative.code: ;;; not, strictly speaking, part of that protocol.
  
  (in-package :drei-base)
  
  (defgeneric invoke-as-region (mark1 mark2 continuation)
    (:documentation "Invoke `continuation' with two arguments
  ordering a proper region."))
  
  (defmethod invoke-as-region ((mark1 integer) (mark2 integer)
                               (continuation function))
    (if (>= mark2 mark1)
        (funcall continuation mark1 mark2)
        (funcall continuation mark2 mark1)))
  
  (defmethod invoke-as-region ((mark1 mark) (mark2 mark)
                               (continuation function))
    (if (mark>= mark2 mark1)
        (funcall continuation mark1 mark2)
        (funcall continuation mark2 mark1)))
  
  (defmacro as-region ((mark1 mark2) &body body)
    "Rebind `mark1' and `mark2' to be a proper region. That
  is, `(mark>= mark2 mark1)' will hold. `Mark1' and `mark2' must be
  symbols bound to marks or integers (but they must be of the same
  type). It is a good idea to use this macro when dealing with
  regions."
    `(invoke-as-region ,mark1 ,mark2
                       #'(lambda (,mark1 ,mark2)
                           ,@body)))
  
  (defmacro as-full-region ((mark1 mark2) &body body)
    "Bind `mark1' and `mark2' to marks that delimit a full
    region (a region where the beginning and end are at the
    beginning and end of their lines, respectively). The new marks
    will be copies of the marks `mark1' and `mark2' are already
    bound to. `Mark1' and `mark2' must be symbols bound to marks."
    `(as-region (,mark1 ,mark2)
       (let ((,mark1 (clone-mark ,mark1))
             (,mark2 (clone-mark ,mark2)))
         (beginning-of-line ,mark1)
         (end-of-line ,mark2)
         ,@body)))
  
  (defmacro as-offsets ((&rest marks)
                        &body body)
  