anchor.diff:  	    :documentation "Who knows?")
      (parameters-are-types :accessor parameters-are-types 
   			 :initarg :parameters-are-types
  -			 :initform nil)))
  +			 :initform nil)
  +   (expansion-function :accessor expansion-function
  +		       :initarg :expansion-function
  +		       :documentation "A function which expands the typespec
  +fully, including defaulting parameters and options.")))
   
   (defmethod initialize-instance :after ((obj presentation-type) &key)
     (unless (slot-boundp obj 'ptype-specializer)
  
positive.code: 	     (setq type expansion))
  	   (return (values type expand-any-p)))))))
  
  ;;; Define a function to do this as part of define-presentation-type?
  
  (defun make-presentation-type-specifier (name-and-params &rest options)
    (with-presentation-type-decoded (name)
      name-and-params
      (flet ((make-keyword (sym)
  	     (intern (symbol-name sym) :keyword)))
        (let ((ptype (gethash name *presentation-type-table*)))
  	(unless ptype
  	  (return-from make-presentation-type-specifier name-and-params))
  	(let* ((options-ll (options-lambda-list ptype))
  	       (defaulting-form
  		   (loop for var in (cdr options-ll)
  			 nconc (cond ((atom var)
  				      `(,(make-keyword var) ,var))
  				     ((atom (car var))
  				      `(,(make-keyword (car var)) ,(car var)))
  				     (t `(,(caar var) ,(cadar var))))))
  	       (defaults (eval `(destructuring-bind ,options-ll
  				 nil
  				 (list ,@defaulting-form)))))
  	  (loop for (key val) on options by #'cddr
  		for default = (getf defaults key)
  		unless (equal val default)
  		nconc (list key val) into needed-options
  		finally (return (if needed-options
  				    `(,name-and-params ,@needed-options)
  				    name-and-params))))))))
  
  
  ;;; Presentation methods.  The basic dispatch is performed via CLOS
  
negative.code: 	 (destructuring-bind ,options-ll (decode-options ,type)
  	   (declare (ignorable ,@(get-all-params options-ll)))
  	   ,form)))))
  
  (defun make-expansion-lambda (params-ll options-ll)
    (let ((params-form (recreate-lambda-list params-ll))
  	(options-form (recreate-lambda-list options-ll))
  	(parameters (gensym))
  	(options (gensym)))
      `(lambda (typespec)
         (with-presentation-type-decoded (name ,parameters ,options)
  	 typespec
  	 (make-type-spec name
  			 (destructuring-bind ,params-ll
  			     ,parameters
  			   ,params-form)
  			 (destructuring-bind ,options-ll
  			     ,options
  			   ,options-form))))))
  
  (defvar *presentation-type-table* (make-hash-table :test #'eq))
  
  