anchor.diff:  (defun match-pattern (lexer)
     (unless (end-of-string-p lexer)
       (alexandria:when-let ((result (match-pattern-1 lexer #\/)))
  -      (return-from match-pattern (list :search :forward result)))
  +      (return-from match-pattern `(lem-vi-mode.ex-command:search-forward ,result)))
       (alexandria:when-let ((result (match-pattern-1 lexer #\?)))
  -      (return-from match-pattern (list :search :backward result)))))
  +      (return-from match-pattern `(lem-vi-mode.ex-command:search-backward ,result)))))
   
   (defun parse-ex-line (lexer)
     (skip-whitespace lexer)
     (unless (end-of-string-p lexer)
       (let ((result))
         (cond ((setf result (match-number lexer))
  -             (list :line-number result))
  +             `(lem-vi-mode.ex-command:goto-line ,result))
               ((setf result (case (lookahead lexer)
  -                            (#\. :current-line)
  -                            (#\$ :last-line)
  -                            (#\% :all-lines)))
  +                            (#\. '(lem-vi-mode.ex-command:current-line))
  +                            (#\$ '(lem-vi-mode.ex-command:last-line))
  +                            (#\% '(lem-vi-mode.ex-command:all-lines))))
                (lexer-forward lexer)
  -             (list result))
  +             result)
               ((accept lexer #\')
  -             (prog1 (list :mark (lookahead lexer))
  +             (prog1 `(lem-vi-mode.ex-command:marker ,(lookahead lexer))
                  (lexer-forward lexer)))
               ((match-pattern lexer))))))
   
  
positive.code:                 :for offset := (parse-ex-offset lexer)
                  :collect line
                  :when offset :collect it
                  :unless (and (eq :search (first line))
                               (setf line (match-pattern lexer)))
                  :do (loop-finish))))
      (if (alexandria:length= list 1)
          (first list)
          (cons :patterns list))))
  
  (defun delimiter (lexer)
    (unless (end-of-string-p lexer)
      (cond ((accept lexer #\,)
             (values nil t))
            ((accept lexer #\;)
             (values :goto t))
            (t
             (values nil nil)))))
  
  (defun parse-ex-range (string)
    (let ((lexer (make-lexer :position 0 :string string))
          (range '()))
      (loop :with delim := nil :and contp := nil
            :do (push (parse-ex-range-element lexer) range)
                (setf (values delim contp) (delimiter lexer))
                (unless contp (return))
            (when delim
              (setf (first range) (list :goto (first range)))))
      (nreverse range)))
  
negative.code:   (unless (end-of-string-p lexer)
      (cond ((accept lexer #\+)
             (alexandria:when-let ((number (match-number lexer)))
               `(lem-vi-mode.ex-command:offset-line ,number)))
            ((accept lexer #\-)
             (alexandria:when-let ((number (match-number lexer)))
               `(lem-vi-mode.ex-command:offset-line ,(- number)))))))
  
  (defun parse-ex-range-element (lexer)
    (let ((list (loop
  