anchor.diff:      new-instance ))
   
   ;; <<>>=
  -(defun modf-expand (new-val expr enclosed-obj-sym)
  +(defun modf-expand (new-val expr enclosed-obj-sym env)
     (cond ((or (atom expr) (eql (car expr) 'modf-eval))
            `(let ((,enclosed-obj-sym ,expr))
               ,new-val ))
  +        ((macro-function (car expr) env)
  +         (modf-expand new-val (funcall (macro-function (car expr) env) expr env)
  +                      enclosed-obj-sym env))
           ;; First, try rewrite rules
           ((gethash (car expr) *modf-rewrites*)
            (modf-expand new-val (funcall (gethash (car expr) *modf-rewrites*) expr)
  -                      enclosed-obj-sym ))
  +                      enclosed-obj-sym env))
           ;; Okay, we are going to call modf-expand
           (t (let* ((obj-sym (gensym))
                     (new-val (if enclosed-obj-sym
  
positive.code:                                        (container-arg-n expr)
                                         expr obj-sym ))))))
                (nth (container-arg-n expr) expr)
                obj-sym )))))
  
  ;; <<>>=
  (defmacro modf (place value &rest more)
    "Make a new object \(which may use some of the old object) such that PLACE
  evaluates to VALUE.
  
  
negative.code: form."
    (if more
        (destructuring-bind (next-symbol next-place next-value &rest next-more) more
          `(let ((,next-symbol ,(modf-expand value place nil env)))
             (modf ,next-place ,next-value ,@next-more) ))
        (modf-expand value place nil env) ))
  
  (defun find-container (place)
    (cond ((atom place)
  