anchor.diff:  
   (def unwalker named-lambda-function-form (special-form name arguments body declares)
     `(function
  -    (,special-form ,name ,(unwalk-lambda-list arguments)
  +    (,special-form ,name ,(unwalk-ordinary-lambda-list arguments)
        ,@(unwalk-declarations declares)
        ,@(recurse-on-body body))))
   
  
positive.code:   ((arguments)))
  
  (def unwalker lambda-function-form (arguments body declares)
    `#'(lambda ,(unwalk-lambda-list arguments)
         ,@(unwalk-declarations declares)
         ,@(recurse-on-body body)))
  
  
negative.code: 
  (def layered-function walk-lambda-like (ast-node args body env)
    (:method (ast-node args body env)
      (setf (values (arguments-of ast-node) env) (walk-ordinary-lambda-list args ast-node env))
      (walk-implict-progn ast-node body env :declare t)
      ast-node))
  
  (def (function e) walk-ordinary-lambda-list (lambda-list parent env &key allow-specializers)
    (bind (((:values requireds optionals rest keywords allow-other-keys? auxiliaries) (parse-ordinary-lambda-list lambda-list :normalize nil))
           (result (nconc
                    (loop
                       :for required :in requireds
                       :collect (if allow-specializers
                                    (walk-specialized-argument required parent env)
                                    (make-form-object 'required-function-argument-form parent :name required)))
                    (loop
                       :for optional :in optionals
                       :collect (walk-optional-argument optional parent env))
                    (when rest
                      (list (make-form-object 'rest-function-argument-form parent :name rest)))
                    (loop
                       :for keyword :in keywords
                       :collect (walk-keyword-argument keyword parent env))
                    (when allow-other-keys?
                      (list (make-form-object 'allow-other-keys-function-argument-form parent)))
                    (loop
                       :for auxiliary :in auxiliaries
                       :collect (walk-auxiliary-argument auxiliary parent env)))))
      (dolist (parsed result)
        (unless (typep parsed 'allow-other-keys-function-argument-form)
          (augment-walkenv! env :variable (name-of parsed) parsed)))
      result))
  
  (def (class* e) function-argument-form (walked-form)
    ((name)))
  