anchor.diff:  
   BODY is needed because we detect unreferenced bindings by looking for
   `ignore' declarations."
  -  (let ((ignored
  -          (filter #'listp
  -                  (mappend (lambda (decl)
  -                             (cdr (assoc 'ignore (cdr decl))))
  -                           (nth-value 1 (parse-body body))))))
  +  (let ((ignored (ignored-functions-in-body body)))
  +    ;; Since we cannot walk the code, our checks are limited to
  +    ;; special cases.
       (labels ((unreferenced? (expr)
  -               (find expr ignored :key #'second))
  +               ;; If the function is declared to be ignored, then we
  +               ;; know for sure it is unreferenced. (This is more
  +               ;; useful than it sounds. After all the compiler warns
  +               ;; you if the function is unused but not declared
  +               ;; ignored.)
  +               (memq expr ignored))
                (lambda? (expr)
  -               (and (listp expr) (eql (car expr) 'lambda)))
  +               ;; Note that `analyze-fbinds' has already done the work
  +               ;; of exposing lambda inside let.
  +               (match expr
  +                 (`(lambda ,@_) t)))
                (simple? (expr)
  +               ;; Special cases where we can be sure the expressions
  +               ;; are simple -- that is, that they contain no
  +               ;; references to the functions bound by `fbindrec'.
                  (let ((expr (expand-macro expr)))
                    (match expr
                      ((and _ (type symbol)) t)
  
positive.code:          ,@others
           ,@body))))
  
  (defun partition-fbinds (fbinds body)
    "Partition FBINDS using the \"Fixing Letrec\" algorithm.
  Returns the bindings in four sets: unreferenced, literal lambdas,
  
negative.code:                               (simple? (second body)))))
                     ;; TODO Locally.
                     (`(progn ,@body)
                       (every #'simple? body))))))
        (loop for binding in fbinds
              for var = (first binding)
              for expr = (second binding)
              if (unreferenced? var)
                collect binding into unreferenced
              else if (lambda? expr)
                     collect binding into lambdas
              else if (simple? expr)
                     collect binding into simple
              else collect binding into complex
              finally (return (values simple complex lambdas unreferenced))))))
  
  (defmacro fbindrec (bindings &body body &environment *lexenv*)
    "Like `fbind', but creates recursive bindings.
  