anchor.diff:    '(sequence t))
   
   (define-presentation-method present ((object list) (type sequence)
  -				     stream
  -				     (view textual-view)
  -				     &key acceptably for-context-type)
  +                                     stream
  +                                     (view textual-view)
  +                                     &key acceptably for-context-type)
     (declare (ignore for-context-type))
     (loop for tail on object
  -	for (obj) = tail
  -	do (progn
  -	     (present obj type		; i.e., the type parameter
  -			:stream stream :view view
  -			:acceptably acceptably
  -			:sensitive nil)
  -	     (when (cdr tail)
  -	       (write-char separator stream)))))
  +        for (obj) = tail
  +        do (progn
  +             (present obj type          ; i.e., the type parameter
  +                        :stream stream :view view
  +                        :acceptably acceptably
  +                        :sensitive nil)
  +             (when (cdr tail)
  +               (write-char separator stream)))))
   
   (define-presentation-method present ((object vector) (type sequence)
  -				     stream
  -				     (view textual-view)
  -				     &key acceptably for-context-type)
  +                                     stream
  +                                     (view textual-view)
  +                                     &key acceptably for-context-type)
     (declare (ignore for-context-type))
     (loop for i from 0 below (length object)
  -	for obj = (aref object i)
  -	do (progn
  -	     (present obj type		; i.e., the type parameter
  -			:stream stream :view view
  -			:acceptably acceptably
  -			:sensitive nil)
  -	     (when (< i (1- (length object)))
  -	       (write-char separator stream)))))
  +        for obj = (aref object i)
  +        do (progn
  +             (present obj type          ; i.e., the type parameter
  +                        :stream stream :view view
  +                        :acceptably acceptably
  +                        :sensitive nil)
  +             (when (< i (1- (length object)))
  +               (write-char separator stream)))))
   
   
   (define-presentation-method accept ((type sequence)
  -				    stream
  -				    (view textual-view)
  -				    &key)
  +                                    stream
  +                                    (view textual-view)
  +                                    &key)
     (loop
        with separators = (list separator)
  -     for element = (accept type		; i.e., the type parameter
  -			   :stream stream
  -			   :view view
  -			   :prompt nil
  -			   :additional-delimiter-gestures separators)
  +     for element = (accept type         ; i.e., the type parameter
  +                           :stream stream
  +                           :view view
  +                           :prompt nil
  +                           :additional-delimiter-gestures separators)
        collect element
        do (progn
  -	  (when (not (eql (peek-char nil stream nil nil) separator))
  -	    (loop-finish))
  -	  (read-char stream)
  -	  (when echo-space
  -	    ;; Make the space a noise string
  -	    (input-editor-format stream " ")))))
  +          (when (not (eql (peek-char nil stream nil nil) separator))
  +            (loop-finish))
  +          (read-char stream)
  +          (when echo-space
  +            ;; Make the space a noise string
  +            (input-editor-format stream " ")))))
   
   
   (define-presentation-type sequence-enumerated (&rest types)
  
positive.code:       maybe-supertype
        (declare (ignore super-name))
        (if (equal params super-params)
  	  (values t t)
  	  (values nil nil)))))
  
  (define-presentation-generic-function
      %presentation-type-specifier-p
  
negative.code:                (return-from presentation-subtypep (values yesp surep))))))
          ((eq super-name 'and)
           (let ((result t))
             (dolist (and-type super-parameters
                      (return-from presentation-subtypep (values result result)))
               (cond
                 ((and (consp and-type) (eq (car and-type) 'satisfies))
  