anchor.diff:    (print-unreadable-object (self strm :type t)
       (format strm "~S" (get-forms self))))
   
  +(defmethod initialize-instance :after ((self function-call) &rest args)
  +  (setf (slot-value self 'function)
  +    (let ((lambda-list (mapcar #'get-name (get-bindings self))))
  +      (compile nil `(lambda (,@lambda-list)
  +                      (declare (special ,@lambda-list))
  +                      (progn ,@(get-forms self)))))))
  +             
   (defun make-function-call (forms bindings)
     (make-instance 'function-call :forms forms :bindings bindings))
   
  
positive.code:   (let ((fact (find-fact (get-token context) (get-location binding))))
      (cl:assert (not (null fact)) ()
        "No fact for location ~D." (get-location binding))
      `(,(get-name binding) ,fact)))
  
  (defmethod make-lexical-binding ((binding lexical-slot-binding) context)
    (let ((fact (find-fact (get-token context) (get-location binding))))
      (cl:assert (not (null fact)) ()
        "No fact for location ~D." (get-location binding))
      (let ((name (get-name binding))
            (value (get-slot-value fact (get-slot-name binding))))
        `(,name ,@(if (quotablep value) `(',value) `(,value))))))
    
  (defmethod make-lexical-binding ((binding local-slot-binding) context)
    (let ((name (get-name binding))
          (value (get-slot-value (get-fact context)
                                 (get-slot-name binding))))
      `(,name ,@(if (quotablep value) `(',value) `(,value)))))
  
  (defun create-lexical-context (funcall context)
    (flet ((make-context ()
             `(lambda ()
                (let (,@(mapcar #'(lambda (binding)
                                    (make-lexical-binding binding context))
                                (get-bindings funcall)))
                  ,@(get-forms funcall)))))
      (eval (make-context))))
  
  (defmethod evaluate ((self function-call) context)
    (funcall (create-lexical-context self context)))
  
  (defmethod equals ((self function-call) (obj function-call))
    (tree-equal (get-forms self) (get-forms obj)))
  
negative.code:   ((forms :initarg :forms
            :reader get-forms)
     (bindings :initarg :bindings
               :reader get-bindings)
     (function :reader get-function))
    (:documentation
     "This class manages the mechanics of executing arbitrary Lisp code from
     conditional elements and rule RHSs."))
  