anchor.diff:    "Return the list form that `mark-or-offset' is inside, or NIL
   if no such form exists."
     (as-offsets ((offset mark-or-offset))
  +    (update-parse syntax 0 offset)
       (let ((form-around (form-around syntax offset)))
  -      (if (and (form-list-p form-around)
  -               (> offset (start-offset form-around)))
  -          form-around
  -          (find-list-parent form-around)))))
  +      (when form-around
  +        (if (and (form-list-p form-around)
  +                 (> offset (start-offset form-around)))
  +            form-around
  +            (find-list-parent form-around))))))
   
   (defun symbol-at-mark (syntax mark-or-offset
                          &optional (form-fetcher 'expression-at-mark))
  
positive.code:     (let ((form-around (form-around syntax offset)))
        (when (form-string-p form-around)
          (at-end-of-form-p syntax form-around offset)))))
  
  ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
  ;;;
  
negative.code:     (when (and (not (null potential-form))
                 (not (= (offset mark) (end-offset potential-form))))
  	(setf (offset mark) (end-offset potential-form)))))
  
  (defmethod forward-delete-expression (mark (syntax lisp-syntax) &optional (count 1)
                                        (limit-action #'error-limit-action))
    (let ((mark2 (clone-mark mark)))
      (when (and (not (structurally-at-end-of-list-p (current-syntax) mark))
                 (forward-expression mark2 syntax count limit-action))
        (delete-region mark mark2)
        t)))
  
  (defmethod backward-delete-expression (mark (syntax lisp-syntax) &optional (count 1)
                                         (limit-action #'error-limit-action))
    (let ((mark2 (clone-mark mark)))
      (when (and (not (structurally-at-end-of-list-p (current-syntax) mark))
                 (backward-expression mark2 syntax count limit-action))
        (delete-region mark mark2)
        t)))
  
  (defmethod forward-kill-expression (mark (syntax lisp-syntax) &optional (count 1) concatenate-p
                                      (limit-action #'error-limit-action))
    (let ((start (offset mark)))
      (forward-expression mark syntax count limit-action)
      (unless (mark= mark start)
        (if concatenate-p
            (if (plusp count)
                (kill-ring-concatenating-push
                 *kill-ring*
                 (region-to-sequence start
                                     mark))
                (kill-ring-reverse-concatenating-push
                 *kill-ring*
                 (region-to-sequence
                  start mark)))
            (kill-ring-standard-push
             *kill-ring*
             (region-to-sequence start mark)))
        (delete-region start mark)
        t)))
  
  (defmethod backward-kill-expression (mark (syntax lisp-syntax) &optional (count 1) concatenate-p
                                       (limit-action #'error-limit-action))
    (let ((start (offset mark)))
      (backward-expression mark syntax count limit-action)
      (unless (mark= mark start)
        (if concatenate-p
            (if (plusp count)
                (kill-ring-concatenating-push *kill-ring*
                                              (region-to-sequence start
                                                                  mark))
                (kill-ring-reverse-concatenating-push *kill-ring*
                                                      (region-to-sequence
                                                       start mark)))
            (kill-ring-standard-push *kill-ring*
                                     (region-to-sequence start mark)))
        (delete-region start mark)
        t)))
  
  (defgeneric forward-one-list (mark syntax)
    (:documentation "Move `mark' forward by one list.
  