anchor.diff:  				   super-sequence super-test super-value-key)
   		t)))))
   
  +(define-presentation-method present (object (type completion) stream
  +				     (view textual-view)
  +				     &key acceptably for-context-type)
  +  (declare (ignore acceptably for-context-type))
  +  (present object (presentation-type-of object)
  +	   :stream stream :view view))
  +
   (define-presentation-type-abbreviation member (&rest elements)
     (make-presentation-type-specifier `(completion ,elements)
   				    :name-key name-key
  
positive.code: (define-presentation-method presentation-typep (object (type character))
    (characterp object))
  
  (define-presentation-type string (&optional length))
  
  (define-presentation-method presentation-typep (object (type string))
  
negative.code: 	(with-output-to-string (s)
  	  (describe s)))))
  
  ;;; Views...
  
  (defclass view ()
    ())
  
  (defun viewp (object)
    (typep object 'view))
  
  (defclass textual-view (view)
    ())
  
  (defclass textual-menu-view (textual-view)
    ())
  
  (defclass textual-dialog-view (textual-view)
    ())
  
  (defclass gadget-view (view)
    ())
  
  (defclass gadget-menu-view (gadget-view)
    ())
  
  (defclass gadget-dialog-view (gadget-view)
    ())
  
  (defclass pointer-documentation-view (textual-view)
    ())
  
  (defparameter +textual-view+ (make-instance 'textual-view))
  
  (defparameter +textual-menu-view+ (make-instance 'textual-menu-view))
  
  (defparameter +textual-dialog-view+ (make-instance 'textual-dialog-view))
  
  (defparameter +gadget-view+ (make-instance 'gadget-view))
  
  (defparameter +gadget-menu-view+ (make-instance 'gadget-menu-view))
  
  (defparameter +gadget-dialog-view+ (make-instance 'gadget-dialog-view))
  
  (defparameter +pointer-documentation-view+
    (make-instance 'pointer-documentation-view))
  
  ;;; Reasonable defaults, I guess...
  
  (defmethod stream-default-view (stream)
    +textual-view+)
  
  (defmethod (setf stream-default-view) (view stream)
    (declare (ignore view stream))
    view)
  
  ;;; XXX The spec calls out that the presentation generic function has keyword
  ;;; arguments acceptably and for-context-type, but the examples I've seen don't
  ;;; mention them at all in the methods defined for present.  So, leave them out
  ;;; of the generic function lambda list...
  (define-presentation-generic-function %present present
      (type-key parameters options object type stream view
       &key))
  
  (defmacro with-output-as-presentation ((stream object type
  				       &rest key-args
  				       &key modifier single-box
  				       (allow-sensitive-inferiors t)
  				       parent
  				       (record-type ''standard-presentation)
  				       &allow-other-keys)
  				       &body body)
    (when (eq stream t)
      (setq stream '*standard-output*))
    (let ((output-record (gensym))
  	(invoke-key-args (cull-keywords '(:record-type
  					  :allow-sensitive-inferiors)
  					key-args)))
       `(flet ((continuation (,stream ,output-record)
  	      (declare (ignore ,output-record))
  	      (let ((*allow-sensitive-inferiors*
  		     (if *allow-sensitive-inferiors*
  			 ,allow-sensitive-inferiors
  			 nil)))
  		,@body)))
  	(if (output-recording-stream-p ,stream)
  	    (invoke-with-new-output-record
  	     ,stream #'continuation ,record-type
  	     :object ,object
  	     :type (expand-presentation-type-abbreviation ,type)
  	     ,@key-args)
  	    (funcall #'continuation ,stream nil)))))
  
  
  (defun present (object &optional (type (presentation-type-of object))
  		&key
  		(stream *standard-output*)
  		(view (stream-default-view stream))
  		modifier
  		acceptably
  		(for-context-type nil for-context-type-p)
  		single-box
  		(allow-sensitive-inferiors t)
  		(sensitive t)
  		(record-type 'standard-presentation))
    (let* ((real-type (expand-presentation-type-abbreviation type))
  	 (context-type (if for-context-type-p
  			   (expand-presentation-type-abbreviation
  			    for-context-type)
  			   real-type)))
      (stream-present stream object real-type
  		    :view view :modifier modifier :acceptably acceptably
  		    :for-context-type context-type :single-box single-box
  		    :allow-sensitive-inferiors allow-sensitive-inferiors
  		    :sensitive sensitive
  		    :record-type record-type)))
  
  (defgeneric stream-present (stream object type
  			    &key view modifier acceptably for-context-type
  			    single-box allow-sensitive-inferiors sensitive
  			    record-type))
  
  (defmethod stream-present ((stream output-recording-stream) object type
  			   &key
  			   (view (stream-default-view stream))
  			   modifier
  			   acceptably
  			   (for-context-type type)
  			   single-box
  			   (allow-sensitive-inferiors t)
  			   (sensitive t)
  			   (record-type 'standard-presentation))
    (let ((*allow-sensitive-inferiors* (if *allow-sensitive-inferiors*
  					 sensitive
  					 nil)))
      (with-output-as-presentation (stream object type
  				  :view view
  				  :modifier modifier
  				  :single-box single-box
  				  :allow-sensitive-inferiors
  				  allow-sensitive-inferiors
  				  :record-type record-type)
        (funcall-presentation-generic-function
         present object type stream view
         :acceptably acceptably :for-context-type for-context-type))))
  
  ;;; Should work well enough on non-CLIM streams...
  (defmethod stream-present (stream object type
  			   &key
  			   (view +textual-view+)
  			   modifier
  			   acceptably
  			   (for-context-type type)
  			   single-box
  			   (allow-sensitive-inferiors t)
  			   (sensitive t)
  			   (record-type 'standard-presentation))
    (declare (ignore modifier single-box allow-sensitive-inferiors sensitive
  		   record-type))
    (funcall-presentation-generic-function
     present object type stream view
     :acceptably acceptably :for-context-type for-context-type)
    nil)
  
  (defun present-to-string (object &optional (type (presentation-type-of object))
  			  &key (view +textual-view+)
  			  acceptably
  			  (for-context-type nil for-context-type-p)
  			  (string nil stringp)
  			  (index 0 indexp))
    (let* ((real-type (expand-presentation-type-abbreviation type))
  	 (context-type (if for-context-type-p
  			   (expand-presentation-type-abbreviation
  			    for-context-type)
  			   real-type)))
      (when (and stringp indexp)
        (setf (fill-pointer string) index))
      (flet ((do-present (s)
  	     (stream-present s object real-type
  			     :view view :acceptably acceptably
  			     :for-context-type context-type)))
        (declare (dynamic-extent do-present))
        (let ((result (if stringp
  			 (with-output-to-string (stream string)
  			   (do-present stream))
  			 (with-output-to-string (stream)
  			   (do-present stream)))))
  	(if stringp
  	    (values string (fill-pointer string))
  	    result)))))
  
  
  ;;; The presentation types
  
  (define-presentation-type t ())
  