anchor.diff:         collect (car var-spec)))
   
   #+sbcl
  -(defun lexical-functions (environment)
  +(defmethod lexical-functions ((environment sb-kernel:lexenv))
     (mapcar #'first (sb-c::lexenv-funs environment)))
   
   ;;;; ** CMUCL
   
   #+cmu
  -(defun environment-p (environment)
  -  (subtypep (class-of environment) (find-class 'c::lexenv)))
  +(defmethod environment-p ((environment c::lexenv))
  +  t)
   
   #+cmu
  -(defun lexical-variables (environment)
  +(defmethod lexical-variables ((environment c::lexenv))
     (loop
        for var-spec in (c::lexenv-variables environment)
        ;; variable refs are (NAME . LAMBDA-VAR), we want to void
  
positive.code:                                             (and (ccl::var-ea var-spec)
                                                   (consp (ccl::var-ea var-spec))
                                                   (eql :symbol-macro (car (ccl::var-ea var-spec)))))
                                            vars)))))  
  
  #+openmcl
  (defun lexical-functions (environment)
      (loop
       for env = environment
            then (ccl::lexenv.parent-env env)
       while (and env
  
negative.code: 
  ;;;; * Portable lexical environment access
  
  (defgeneric environment-p (environment)
    (:documentation "Returns T if ENVIRONMENT is a lexical
    environment object (something suitable for passing to
    macroexpand-1 or similar)"))
  
  (defgeneric lexical-variables (environment)
    (:documentation "Return the names of all the local variables
    in ENVIRONMENT. Does not return neither symbol-macrolets nor
    ignared variables."))
  
  (defgeneric lexical-functions (environment)
    (:documentation "Returns the names of all the local functions
    in ENVIRONMENT. Names may be symbols of lists of the form (setf
    name)."))
  
  ;;;; ** OpenMCL
  
  #+openmcl
  (defmethod environment-p ((e ccl::lexical-environment))
    t)
  
  #+openmcl
  (defmethod lexical-variables ((environment ccl::lexical-environment))
    (loop
       for env = environment
            then (ccl::lexenv.parent-env env)
  