anchor.diff:                               (container-arg-n expr)
                                expr form ))))))
               (nth (container-arg-n expr) expr)
  -            enclosed-obj-sym )))
  -        ((expansions-defined? expr)
  -         (let ((enclosed-obj-sym (gensym)) )
  -           (multiple-value-bind (builder)
  -               (funcall (gethash (accessor-in expr) *modf-expansions*)
  -                        expr form new-val )
  -             (modf-expand
  -              `(let ((,form
  -                      ,(let ((enclosed-obj (nth (container-arg-n expr)
  -                                                expr )))
  -                         (let ((it (and (consp enclosed-obj)
  -                                        (container-arg-n enclosed-obj) )))
  -                           (if it
  -                               (replace-nth it
  -                                            enclosed-obj
  -                                            enclosed-obj-sym )
  -                               enclosed-obj )))))
  -                 ,builder )
  -              (nth (container-arg-n expr) expr)
  -              enclosed-obj-sym ))))
  -        (t (error "Don't know how to handle \"~A\"" expr)) ))
  +            enclosed-obj-sym )))))
  +        ;; (t (error "Don't know how to handle \"~A\"" expr)) ))
   
   ;; <<>>=
   (defmacro modf (place value &rest more)
  
positive.code: (defmacro modf-fn (symbol)
    "Expand to the defined Modf function.  Basically, \(MODF-FN SYM) is the
  functional analog of #'\(SETF SYM)."
    (symbol-function (modf-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 )
       (eval-when (:compile-toplevel :load-toplevel :execute)
         (setf (gethash ',name *modf-nth-arg*)
               ,nth-arg ))))
  
  ;; <<>>=
  (defmacro define-modf-method (name nth-arg (new-val &rest args) &body body)
    "Define a new modf method.  It inverts NAME forms by modifying the NTH-ARG
  term of the arguments of the place form in the MODF macro.  This method can
  specialize on any of ARGS."
    `(progn
       (defmethod ,(intern (modf-name name) :modf) (,new-val ,@args)
         ,@body )
       (eval-when (:compile-toplevel :load-toplevel :execute)
         (setf (gethash ',name *modf-nth-arg*)
               ,nth-arg ))))
  
  ;; @\section{The {\em modf} macro}
  
  
negative.code: ;; order.  It recognizes one special form, modf-eval, which instructs it to not
  ;; try to invert the enclosed form and just evaluate it.
  
  ;; @\subsection{How does modf expansion work?}
  
  ;; @In order to expand modf expressions, we need to work from the inside out.
  ;; This means the inner most form is the first we need to deal with.  For a
  ;; moment let's limit ourselves to the simple case of cons cells.  When <<modf>>
  ;; recieves an expression like (car (cdr x)), it needs to first figure out how
  ;; to replace the cdr of x while storing the car of x.  Thus the first part of
  ;; the modf expansion should look like
  
  ;; (let ((tmp x)) ; Grab x to protect against multiple evaluation
  ;;   ;; The builder code
  ;;   (cons (car x)
  ;;         ... )
  
  ;; Then, <<modf>> needs to replace ``...'' with the method of replacing the car
  ;; of a cons cell.  Since we know we will be operating on the cdr of x, we first
  ;; grab that value (just like we grabbed x above)
  
  ;; (let ((tmp x))
  ;;   (cons (car x)
  ;;         (let ((tmp (cdr x)))
  ;;           ... )))
  
  ;; We do this as an optimization, this way we only need to drill down into the
  ;; structure one time.  We then expand the outer accessor
  
  ;; (let ((tmp x))
  ;;   (cons (car x)
  ;;         (let ((tmp (cdr x)))
  ;;           (cons ...
  ;;                 (cdr tmp) ))))
  
  ;; Notice that at each level we only have need of one <<tmp>> symbol.  The last
  ;; question is, what do we fill into the ``...''.  That spot will be filled with
  ;; the new value.
  
  ;; Now, how can we implement this in code?  The nature of the problem is
  ;; actually a bit backwards from how we normally think about it.  We need a
  ;; function that will build up the expansion as we talk the code tree, and
  ;; passes it to the next level of recursion.  The next level then wraps that
  ;; expansion.  Looking at the procedure above, we see the information such a
  ;; function needs to work:
  
  ;; \begin{enumerate}
  ;;  \item The previous level's expansion.  In the above example that is:
  
  ;; (cons new-val (cdr tmp))
  
  ;;  \item The data it will be operating on
  
  ;;  \item
  
  ;; \end{enumerate}
  
  ;; To be completed later
  
  (defun container-arg-n (expr)
    (cond ((eql (car expr) 'cl:apply)
           (1+ (gethash (cadadr expr) *modf-nth-arg* 'no-nth-arg)) )
          (t (gethash (car expr) *modf-nth-arg* 'no-nth-arg)) ))
  
  (defun modf-fn-defined? (expr)
    (cond ((eql (car expr) 'cl:apply)
  