anchor.diff:                     (%continue :speculative-search) ; start speculative search
                      ;; :speculative-search
                      (%continue :speculative-search) ; continue speculative search
  -                   (return-from %expand
  -                     (%finish conservative-template pme-or-place env oldp))))))))))
  +                   (%finish conservative-template conservative-place env oldp)))))))))
       (recurse place-modification-expression :top-level #'identity #'identity)))
   
   (defmacro modify (&rest place-modification-expressions &environment env)
  
positive.code:                                   '(cons (eql :old) (cons t null)))
                             (prog1 t
                               (setf place-modification-expression
                                     (second place-modification-expression))))))
    (labels
      ((recurse (pme-or-place state
                              conservative-template
                              speculative-template)
         (unless (listp pme-or-place)
           (return-from %expand
             (%finish conservative-template pme-or-place env oldp)))
         (destructuring-bind (operator &rest args) pme-or-place
           (multiple-value-bind (pm-name variant)
               (place-modifier:parse-operator operator)
  
negative.code:              `(,operator ,@before-spot ,fill-in ,@after-spot))))
  
  (defun %finish (template place env oldp)
    (print place)
    (multiple-value-bind (vars vals stores writer reader)
        (get-setf-expansion place env)
      (when (/= (length stores) 1)
        (error "~S only supports places with exactly ~
                one store variable but place ~S has ~D: ~S."
               'modify place (length stores) stores))
      (let* ((old-var (and oldp (gensym (string '#:old))))
             (wrapped-old-var (and old-var (list old-var))))
        `(let* (,@vars ,@wrapped-old-var)
           (multiple-value-bind ,stores
               ,(print (funcall
                 template
                 (print (let ((vars-vals-plist (mapcan #'list vars vals)))
                   (if oldp
                       `(setf ,@vars-vals-plist
                              ,old-var ,reader)
                       `(progn (setf ,@vars-vals-plist)
                               ,reader))))))
             ,writer
             ,@wrapped-old-var)))))
  
  