anchor.diff:  ;;; Destructuring a tree according to a lambda list.
   ;;;
   ;;; We assume that the lambda-list/pattern are syntactically correct.
  -
  +;;;
  +;;; The function DESTRUCTURE-REQUIRED and DESTRUCTURE-OPTIONALS return
  +;;; two values:
  +;;;
  +;;;  * A list of binding forms to be used in a LET*.
  +;;;
  +;;;  * A variable to be used to destructure the remaining pattern.
  +
  +;;; Recall that the required parameters of a parsed lambda list is
  +;;; either the keyword :NONE, or a list of patterns.  
   (defun destructure-required (required var)
     (if (or (eq required :none) (null required))
         (values '() var)
  
positive.code: 	 (final-env-var (if (eq env-var :none) (gensym) env-var))
  	 (form-var (gensym))
  	 (args-var (gensym)))
      `(lambda (,form-var ,final-env-var)
         ;; If the lambda list does not contain &environment, then
         ;; we IGNORE the GENSYMed parameter to avoid warnings.
         ;; If the lambda list does contain &envionrment, we do
         ;; not want to make it IGNORABLE because we would want a
         ;; warning if it is not used then. 
         ,@(if (eq env-var :none)
  	     `((declare (ignore ,final-env-var)))
  	     `())
         (let ((,args-var (cdr ,form-var)))
  	 (let* ,(destructure-lambda-list parsed-lambda-list args-var)
  	   ;; FIXME: insert ignorable variables introduced by
  	   ;; destrucuring here.
  	   ,@body)))))
  
  	 
  
negative.code: 			  bindings)
  		  rest-var)))))
  
  ;;; Recall that the optional parameters of a parsed lambda list is
  ;;; either the keyword :none, or it is a list of &optional entries.
  ;;; Each optional entry has one of the two forms:
  ;;;
  ;;;  * (pattern init-arg)
  ;;;
  ;;;  * (pattern init-arg supplied-p-parameter)
  ;;;
  ;;; If the original lambda-list did not have an init-arg, the parsing
  ;;; process supplied NIL so that the parsed lambda list always has an
  ;;; init-arg.
  ;;;
  ;;; The HyperSpec says that if there is an &optional parameter and the
  ;;; object to be destructured "ends early", then the init-arg is
  ;;; evaluated and destructured instead.  We interpret this phrase to
  ;;; mean that either:
  ;;;
  ;;;   * the object to be destructured is NIL, in which case it "ends
  ;;;     early", and we destructure the init-arg instead.
  ;;;
  ;;;   * the object is a CONS, in which case the CAR of the object is
  ;;;     matched against the pattern.  If it doesn't match, then an
  ;;;     error is signaled and no attemp is made to match agains the
  ;;;     init-arg.
  ;;;
  ;;;   * the object is an atom other than NIL.  Then an error is
  ;;;     signaled.
  (defun destructure-optionals (optionals var)
    (if (or (eq optionals :none) (null optionals))
        (values '() var)
  