anchor.diff:        (let* ((undotted-params (undot params)))
           (list (cons 'params undotted-params) (cons 'vararg dotted))))))
   
  -(define-walker normalize-lambdas () ignore-domain)
  +(define-trivial-walker normalize-lambdas ())
   
   (define-normalize-lambdas (lambda params . body)
     (rplaca (cdr form) (normalize-lambda-params params))
  
positive.code:                                   ((symbol? p) (symbol-name p))
                                    (t (error "~S" p)))))))
  
  (defmarco (define-walker name implicit-vars . domain-lit)
    (let* ((form-name name)
           (recurse-name (compound-symbol name "-recurse"))
           (forms-name (compound-symbol name "-forms"))
           (define-name (compound-symbol "define-" name))
           (alist-name (compound-symbol name "-alist")))
      (quasiquote (definitions
        (unquote-splicing (if (null? domain-lit) ()
          (let* ((domain (eval (car domain-lit)))
                 (unit (first domain))
                 (reduce (second domain))
                 (replace-2 (third domain)))
            (quasiquote (
        (define ((unquote forms-name) forms (unquote-splicing implicit-vars))
          ((unquote reduce) (form forms)
            ((unquote form-name) form (unquote-splicing implicit-vars))))
  
        (define ((unquote recurse-name) forms (unquote-splicing implicit-vars))
          ((unquote replace-2) forms ((unquote forms-name) (cddr forms)
                                               (unquote-splicing implicit-vars))))
  
  )))))
  
           
        (define (unquote alist-name) ())
  
        (define ((unquote form-name) form (unquote-splicing implicit-vars))
  
negative.code: 
  ;;; This phase is for miscellaneous simplifications
  
  (define-trivial-walker simplify ())
  
  ;;; Adjust lambdas so that they only take one body form.
  
  