anchor.diff:             (modf ,next-place ,next-value ,@next-args) ))
         (modf-expand value place) ))
   
  +;; <<>>=
  +(defmacro modf-eval (&rest args)
  +  `(progn ,@args) )
  +
  
positive.code: 
  ;; <<>>=
  (defmacro define-modf-method (name nth-arg (new-val &rest args) &body body)
    `(progn
       (defmethod ,(intern (modf-name name) :modf) (,new-val ,@args)
         ,@body )
       (setf (gethash ',name *modf-nth-arg*)
             ,nth-arg )))
  
  ;; <<>>=
  (defmacro modf-eval (&rest args)
    `(progn ,@args) )
  
  ;; @\section{The {\em modf} macro}
  
  ;; @The <<modf>> macro is the main entry point to the library.
  
  ;; The basic syntax of the <<modf>> macro is as follows
  
  ;; <<>>=
  (defun modf-expand (new-val expr)
  
negative.code: (defvar *modf-rewrites*
    (make-hash-table) )
  
  ;; <<>>=
  (defmacro define-modf-rewrite (name (expr) &body body)
    "Define a new rewrite rule.  If a form starting with NAME is encountered, call
  the defined function to return a form that we can deal with (i.e. one defined
  via DEFINE-MODF-EXPANDER, DEFINE-MODF-FUNCTION, and DEFINE-MODF-METHOD)."
    `(setf (gethash ',name *modf-rewrites*)
           (lambda (,expr)
              ,@body )))
  
  ;; @\section{Defining Modf functions and methods}
  
  ;; @Much like you can define (setf accessor) functions and methods, you can do
  ;; the same with Modf.  This is done with <<define-modf-function>> and
  ;; <<define-modf-method>>.  Unfortunately we can't use syntactic sugar like
  ;; (defun (modf car) ...) without defining our own defun macro which is a bit
  ;; heavy handed.
  
  ;; <<>>=
  (defun modf-name (symbol)
    "Make a symbol name that depends on symbol name and package, but is very
  unlikely to be chosen by anyone.  This is for avoiding collisions for my
  benefit, not the users, as these symbols belong to the MODF package."
    (mkstr "BUILDER:"
           (package-name (symbol-package symbol))
           ":" (symbol-name symbol) ))
  
  ;; <<>>=
  (defmacro define-modf-function (name nth-arg (new-val &rest args) &body body)
    "Define a new modf function.  It inverts NAME forms by modifying the NTH-ARG
  term of the arguments of the place form in the MODF macro."
    `(progn
       (defun ,(intern (modf-name name) :modf) (,new-val ,@args)
         ,@body )
  