anchor.diff:  ;;   second return value.
   ;;
   ;;   Rather than using COMPILE, this approach does not require special
  -;;   binding onto *BREAK-ON-SIGNALS* for some implementations.
  +;;   binding onto *BREAK-ON-SIGNALS* for some implementations.FD
   ;;
   ;;   COMPILE itself may inject a null lexical environment, even when
   ;;   compiling anonymous lambda forms, on some implementations. This may
  
positive.code: ;; ----
  
  (define-condition compile-condition ()
    ;; FIXME: Portable "In-what-section" declaration
    ())
  
  (define-condition lambda-compile-condition (compile-condition)
    ((form
  
negative.code:   ;; The same declaration will be used in a THE form effectively
    ;; wrapping the form denoting the resulting lambda fujction, itself.
  
    (with-symbols (%warnings #+NIL %errors %form %fn %functype)
      (let ((functype
             (unparse-ftype-function-declaration args body 'lambda* env)))
        `(let ((,%form (quote (lambda ,args ,@body)))
               ,%warnings #+NIL ,%errors)
           (handler-bind ((warning #'(lambda (c)
                                       (npushl c ,%warnings)
                                       #+NIL (muffle-warning c)))
                          (error #'(lambda (c)
                                     (error 'lambda-compile-error
                                            :condition c
                                            :form ,%form))))
             (let ((,%fn (coerce ,%form 'function))
                   (,%functype ,(list 'quote functype)))
               (cond
                 (,%warnings
                  (values (the ,functype ,%fn) ,%warnings
                          ,%functype))
                 (t (values (the ,functype ,%fn) nil ,%functype)))))))))
  
  ;; ^ Operate similar to COMPILE, principally, for anonymous lambda forms
  