anchor.diff:  (defclass with-clause (clause subclauses-mixin variable-clause-mixin) ())
   
   (defclass with-subclause (var-and-type-spec-mixin)
  -  ((%form :initarg :form :reader form)
  -   (%form-present :initarg :form-present :reader form-present)))
  +  (;; The initialization form, or NIL if there is no form.
  +   (%form :initarg :form :reader form)
  +   ;; TRUE if and only if there is an explicit initialization form
  +   ;; present.
  +   (%form-present-p :initarg :form-present-p :reader form-present-p)))
   
   (define-elementary-parser parse-and-with-subclause body (#:and)
     (multiple-value-bind (var type-spec rest1)
  
positive.code: 		    :form2 form2)
  		  rest2)))))
  
  (define-elementary-parser parse-for/as-across body (#:across)
    (multiple-value-bind (form rest)
        (parse-form body)
      (values (make-instance 'for/as-across-subclause
  	      :array-form form)
  	    rest)))
  
  (define-elementary-parser parse-for/as-hash-keys body (#:hash-key #:hash-keys)
    (pop body)
  
negative.code:     (if (or (null rest1)
  	    (not (symbol-equal (car rest1) '#:by)))
  	(values (make-instance class-name
  		  :list-form form
  		  :step-fun-form #'cdr)
  		rest1)
  	(multiple-value-bind (step-fun-form rest2)
  	    (parse-form (cdr rest1))
  	  (values (make-instance class-name
  		    :list-form form
  		    :step-fun-form step-fun-form)
  		  rest2)))))
  
  ;;; Parse a FOR/AS IN/ON subclause.  The list we are given starts
  ;;; with the variable and the optional type-spec.
  (defun parse-for/as-in/on (body)
    (multiple-value-bind (var type-spec rest1)
        (parse-var-and-type-spec body)
      ;; FIXME: handle type-spec.
      (declare (ignore type-spec))
      (cond ((symbol-equal (car rest1) '#:in)
  	   (parse-for/as-in/on (cdr body) 'for/as-in-list-subclause var))
  	  ((symbol-equal (car rest1) '#:on)
  	   (parse-for/as-in/on (cdr body) 'for/as-on-list-subclause var))
  	  (t
  	   (values nil body)))))
  	  
  (defun parse-for/as-in (body)
    (multiple-value-bind (var type-spec rest1)
        (parse-var-and-type-spec body)
      ;; FIXME: handle type-spec.
      (declare (ignore type-spec))
      (if (symbol-equal (car rest1) '#:in)
  	(
    
  
  (define-elementary-parser parse-for/as-in body (#:in)
    (parse-for/as-in/on (cdr body) 'for/as-in-list-subclause))
  
  (define-elementary-parser parse-for/as-on body (#:on)
    (parse-for/as-in/on (cdr body) 'for/as-on-list-subclause))
  
  ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
  ;;;
  ;;; Clauses FOR/AS ACROSS
  ;;;
  ;;;    for-as-across::= var [type-spec] across vector 
  
  (defclass for/as-across-subclause (for/as-subclause) 
    ((%array-form :initarg :array-form :reader array-form)))
  
  (define-elementary-parser parse-for/as-across body (#:across)
    (multiple-value-bind (form rest)
        (parse-form body)
      (values (make-instance 'for/as-across-subclause
  	      :array-form form)
  	    rest)))
  
  ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
  ;;;
  ;;; Clause FOR/AS = THEN
  ;;;
  ;;;    for-as-equals-then::= var [type-spec] = form1 [then form2] 
  
  (defclass for/as-equals-then-subclause (for/as-subclause)
    ((%form1 :initarg :form1 :reader form1)
     (%form2 :initarg :form2 :reader form2)))
  
  (define-elementary-parser parse-for/as-equals-then body (#:=)
    (multiple-value-bind (form1 rest1)
  