anchor.diff:  
   (def unwalker rest-function-argument-form (name)
     name)
  +
  +(def (class* e) auxiliary-function-argument-form (function-argument-form-with-default-value)
  +  ())
  +
  +(defun walk-auxiliary-argument (form parent env)
  +  (destructuring-bind (name &optional (default-value nil default-value-supplied?))
  +      (ensure-list form)
  +    (with-form-object (arg 'auxiliary-function-argument-form parent :name name)
  +      (when default-value-supplied?
  +        (setf (default-value-of arg) (walk-form default-value :parent arg :environment env))))))
  +
  +(def unwalker auxiliary-function-argument-form (name supplied-p-parameter)
  +  (bind ((default-value (awhen (default-value-of -form-)
  +                          (recurse it))))
  +    (cond ((and name default-value)
  +           `(,name ,default-value))
  +          (name name)
  +          (t (error "Invalid auxiliary argument")))))
   
   (def (function e) unwalk-ordinary-lambda-list (arguments)
     (bind ((optional-seen? nil)
  
positive.code:       name
        `(,name ,specializer)))
  
  (def (class* e) optional-function-argument-form (function-argument-form)
    ((default-value nil)
     (supplied-p-parameter)))
  
  (defun walk-optional-argument (form parent env)
    ;; TODO report bind bug: (bind (((name &optional (default-value nil default-value-supplied?) supplied-p-parameter) (ensure-list form))) )
    (destructuring-bind (name &optional (default-value nil default-value-supplied?) supplied-p-parameter)
        (ensure-list form)
      (with-form-object (arg 'optional-function-argument-form parent
                             :name name
                             :supplied-p-parameter supplied-p-parameter)
        (when default-value-supplied?
          (setf (default-value-of arg) (walk-form default-value :parent arg :environment env))))))
  
  (def unwalker optional-function-argument-form (name supplied-p-parameter)
    (bind ((default-value (awhen (default-value-of -form-)
                            (recurse it))))
      (cond ((and name supplied-p-parameter)
             `(,name ,default-value ,supplied-p-parameter))
            ((and name default-value)
             `(,name ,default-value))
            (name name)
            (t (error "Invalid optional argument")))))
  
  (def (class* e) keyword-function-argument-form (function-argument-form)
    ((keyword-name)
     (default-value nil)
     (supplied-p-parameter)))
  
  (defun effective-keyword-name-of (k)
    (or (keyword-name-of k)
        (intern (symbol-name (name-of k)) :keyword)))
  
  (defun walk-keyword-argument (form parent env)
    (destructuring-bind (name &optional (default-value nil default-value-supplied?) supplied-p-parameter)
        (ensure-list form)
      (let ((name (if (consp name)
                      (second name)
  
negative.code:         (augment-walkenv! env :variable (name-of parsed) parsed)))
      result))
  
  (def (class* ea) function-argument-form (named-walked-form)
    ())
  
  (def print-object function-argument-form
    (format t "~S" (name-of -self-)))
  
  (def (class* ea) required-function-argument-form (function-argument-form)
    ())
  
  (def unwalker required-function-argument-form (name)
    name)
  
  (def (class* ea) specialized-function-argument-form (required-function-argument-form)
    ((specializer)))
  
  (def function walk-specialized-argument (form parent env)
  