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: 
  ;;;; * Portable lexical environment access
  
  ;;;; ** OpenMCL
  
  #+openmcl
  (defun environment-p (environment)
    (subtypep (class-of environment) 'ccl::lexical-environment))
  
  #+openmcl
  (defun lexical-variables (environment)
    (loop
       for env = environment
            then (ccl::lexenv.parent-env env)
  
negative.code:                                  (find-package :SETF))
                              (list 'cl:setf (read-from-string (symbol-name name)))
                              name)))
                      (remove-if (lambda (func-spec)
                                   ;; weed out all the macrolets
                                   (eql 'ccl::macro (second func-spec)))
                                 funs))))
  
  ;;;; ** SBCL
   
  #+sbcl
  (defmethod environment-p ((environment sb-kernel:lexenv))
    t)
  
  #+sbcl
  (defmethod lexical-variables ((environment sb-kernel:lexenv))
    (loop
       for var-spec in (sb-c::lexenv-vars environment)
       when (and (atom (cdr var-spec))
  