Make evil-mode more lisp friendly?

Question

I'm asking for several tips to make editing lisp like languages in evil mode better. In particular there is one feature that I would really like but couldn't manage to get it to work. For example given the following code (cursor is indicated by |):

(line| of code
    (other line of code))

I would like to delete the whole expression with dd (which normally would delete only the line I'm in). Basically I would like to operate on expressions rather then on lines for all the evil commands that are working on lines normally.

Edit: For anyone interested evil-cleverparens looks interesting, too and it has a list of other similar packages at the end of the README.

Answer 1

Another potential solution is evil-smartparens, which works with smartparens-strict-mode to ensure that the current file is always balanced.

It doesn't behave exactly like you specify. For example:

dd (| stands for the point) on this:

(let| ((foo 1.01))
  (frobnicate foo))

Yields this:

(let ((foo 1.01))
  )

However, you may find that the defaults are well chosen in general, and perhaps they will work for you.

Answer 2

Not exactly what you want, but this is what I use:

;; textobject for the sexp immediately before/after point
(defun my/evil-next-thing (count &optional beg end type inclusive)
  (ignore-errors
    (save-excursion
      (call-interactively 'sp-select-next-thing count)
      (if (> (point) (mark))
          (exchange-point-and-mark))
      ;; check, it doesn't make sense to take the "inside" of a symbol
      (if (or inclusive
              (not (and
                    (string-match
                     (string (char-after (point)))
                     "[^[:punct:]([{]")
                    (string-match
                     (string (char-before (mark)))
                     "[^[:punct:])\]}]"))))
          (evil-range (point) (mark))
        (evil-range (1+ (point)) (1- (mark)))))))

(evil-define-text-object evil-a-next-thing (count &optional beg end type)
  "Select the range defined by sp-select-next-thing."
  (my/evil-next-thing count beg end type t))
(evil-define-text-object evil-i-next-thing (count &optional beg end type)
  "Select the range defined by sp-select-next-thing."
  (my/evil-next-thing count beg end type))

(define-key evil-outer-text-objects-map "n" #'evil-a-next-thing)
(define-key evil-inner-text-objects-map "n" #'evil-i-next-thing)

Note: This requires the smartparens package.

To delete your expression, you would use 0dan, which is admittedly a bit longer, but it's a far less intrusive modification to evil.

Answer 3

di( or da( that's not lisp specific stuff, just vim/evil text objects.