anchor.diff:    :inherit-from t)
   
   (define-presentation-method highlight-presentation ((type blank-area)
  -						    record
  -						    stream
  -						    state)
  +                                                    record
  +                                                    stream
  +                                                    state)
     (declare (ignore record stream state))
     nil)
   
   ;;; Do other slots of this have to be bound in order for this to be useful?
   ;;; Guess we'll see.
   (defparameter *null-presentation* (make-instance 'standard-presentation
  -						 :object nil
  -						 :type 'blank-area
  -						 :view +textual-view+))
  +                                                 :object nil
  +                                                 :type 'blank-area
  +                                                 :view +textual-view+))
   
   (define-presentation-type number ()
     :inherit-from 't)
  
positive.code: 
  (define-default-presentation-method presentation-type-history (type)
    (if (and *application-frame*
  	   (frame-maintain-presentation-histories *application-frame*))
        (with-presentation-type-decoded (name)
  	type
  	(let* ((ptype (get-ptype-metaclass name))
  	       (history (history ptype)))
  	  (case history
  	    ((t)
  	     (let* ((history-table (frame-presentation-history
  				    *application-frame*))
  		    (history-object (gethash name history-table)))
  	       (unless history-object
  		 (setf history-object
  		       (make-instance 'presentation-history)
  		       (gethash name history-table)
  		       history-object))
  	       history-object))
  	    (nil
  	     nil)
  	    (otherwise
  	     (funcall-presentation-generic-function presentation-type-history
  						    type)))))))
  
  ;;; Not in the spec, but I think this is necessary (or at any rate, the easiest
  ;;; way) to control whether or not to use histories in a given context.
  
negative.code: (defmacro define-subtypep-method (&rest args)
    (let ((gf (gethash 'presentation-subtypep *presentation-gf-table*)))
      (multiple-value-bind (qualifiers lambda-list decls body)
          (parse-method-body args)
        (let ((type-arg (nth (1- (type-arg-position gf)) lambda-list)))
  
          (unless (consp type-arg)
            (error "Type argument in presentation method must be specialized"))
          (unless (eq (car type-arg)  'type)
            (error "Type argument mismatch with presentation generic function
   definition"))
          (destructuring-bind (type-var type-name) type-arg
            (let ((method-ll `((,(type-key-arg gf)
                                (eql (prototype-or-error ',type-name)))
                               ,@(copy-list lambda-list))))
              (setf (nth (type-arg-position gf) method-ll) type-var)
              `(defmethod %presentation-subtypep ,@qualifiers ,method-ll
                 (declare (ignorable ,(type-key-arg gf))
                          ,@(cdr decls))
                 (block presentation-subtypep
                   ,@body))))))))
  
  ;;; PRESENTATION-SUBTYPEP suffers from some of the same problems as
  ;;; CL:SUBTYPEP, most (but sadly not all) of which were solved in
  