vim-sexp-mappings-for-regular-people VS expand-region.el

The vim-sexp plugin does slurping and barfing of s-expressions. When I used it years ago with Clojure, c/o of tpope's fireplace plugin, I preferred his mappings for it.

I'm a vim user and generally dislike tools typing for me at the same time that I'm typing. I've gotten some value from https://github.com/tpope/vim-sexp-mappings-for-regular-peopl... though when writing Lisp.

vim-sexp-mappings-for-regular-people [1] uses really easy-to-remember shortcuts for these:

- "backward slurp" is "<(" (move opening paren to the left)

- "forward slurp" is ">)" (move closing paren to the right)

- "forward barf" is "<)" (move closing paren to the left)

- "backward barf" is ">(" (move opening paren to the right)

[1]: https://github.com/tpope/vim-sexp-mappings-for-regular-peopl...

I think the paredit stuff is a bit overblown but apart from managing parens for you, another simple example is editing single expressions. e.g. in Java you might have a line: "int a = blah.bar(something, thing, whatever);" If you realize you need to actually pass "whatever" first, not last, unless you know an IDE shortcut that can make the edit for you, you're going to have to type stuff. I would probably just move my cursor to the start, type "whatever, ", move my cursor to the comma after "thing" and highlight to the end then delete. If "whatever" was a longer variable, or even more interestingly an entire sub-function call like "whatever(x, y, z)", I might instead highlight it all, cut, backspace the comma, move cursor to the start, paste, type a comma. Oh no, I might miss a comma or somehow mess up a paren/semicolon or typo a name?! Whatever, it's rare for me, and for most mistakes I'd get a red squiggly alerting me to it immediately. I like typing, and prefer most 'helpful' plugins get out of my way for most things, so such a process isn't that annoying to me.

But I do at least see there's a nicer process if you have something like paredit: you just move you cursor to the "whatever" (even if it's instead "whatever(a,b,c)") and a command will move it to the left/right/etc. and fix up anything that needs fixing up. In Lisp though the base syntax is so simple and uniform that there's not usually much needing "fixing up" -- there's no pesky commas to deal with for instance, and having the opening paren come in front of the function name instead of after simplifies a lot of things. The worst is adding/removing/moving a form that's at the end of a let binding, or perhaps sometimes adding something to the end of a function that previously ended with ))).

I like to use vim (which does have paredit though I have it disabled) and just having the ability to jump between open/close parens by pressing "%" and to cut jumps as a whole, or the insides, without having to move my cursor character by character, is good enough for me. I still use some paredit-like commands in some instances like moving forms around or in those "worst case issues" I mentioned but I use them with these mappings: https://github.com/tpope/vim-sexp-mappings-for-regular-peopl...

There are more advanced things but how much I care about them varies; I don't tend to need them for Lisp, though every so often I'll miss something from Eclipse that I suspect not even emacs does (or does well). e.g. I know emacs can do a "templateized" completion just like a Java IDE when you type a function name and insert its arguments as placeholder variables to later define/type over, I don't know though whether emacs can then let you place the cursor over each one in turn and with something as easy as 'ctrl+1' hoist that var to an assignment form just above (I did this all the time in Eclipse to avoid having to choose a name, type it, and type its correct type). (In Lisp it's complicated by needing to introduce a let binding if it doesn't exist or append to one if it does. It wouldn't surprise me if paredit can do this, it's just that I'm aware of some refactoring tools in Slime but they don't tend to approach what Eclipse or IntelliJ users expect even if in theory they could.)

I use vim with slimv, paredit turned off but a few bindings from https://github.com/tpope/vim-sexp-mappings-for-regular-people are useful.

Slimv comes with a Paredit Mode: https://github.com/kovisoft/slimv Personally I leave it off, though, never been a fan of anything trying to 'help' me automatically while I'm typing apart from indentation. I do appreciate vim-sexp occasionally with these mappings: https://github.com/tpope/vim-sexp-mappings-for-regular-peopl...

https://susam.in/blog/lisp-in-vim-with-slimv-or-vlime/ is a good overview of the differences between slimv and vlime (the two vim plugins) and how to use them.

I don't use Meow, so this may be wildly off the mark (no pun) here. But I use and really like expand-region for selection and marking. With modal editing, I imagine it would be extremely fast and intuitive.

I think the following packages would fit your wishlist, as it is very similar to mine. As mentioned in the replies, there is (https://github.com/magnars/expand-region.el) and (https://github.com/mickeynp/combobulate). I regularly use (https://github.com/Fuco1/smartparens).

Paredit, Speed-of-thought lisp, Helm, perhaps Lispy but I am not using it myself. I found expand-region to work really well when writing and modifying elisp. lisp-extra-font-lock if you want some more blink (and font-lock-studio). Helpful is very good to have instead of built-in help, it displays the source code by default as well as symbol properties. It is a very informative learning experience to see how built-in stuff is implemented. I am quite lazy to press extra in built-in help to see the source code, but with Helpful, you get it auto in the same window, whicih is great for learning. Seeing symbol properties is sometimes a time saver so you don't have to M-: and type an Elisp function to see the symbol properties when debugging. Learn Edebug, it is very useful built-in application for Emacs Lisp development.

Exactly. Consider you have point in a table definition. You can programmatically find which org element you are in, at least for org-mode. Or in a defun for elisp-mode, a sentence or paragraf in plain text and so on. You could just press a shortcut, and based on major-mode you could find boundaries of the element and put it in hidden-list. It would be really fast to work that way. I don't know if it already exists in some package. Or you could go for somewhat easier version, and just check if a region is active, and if it is, hide region, and if not, hide current line, or based on mode, hide element at point. That way we can easily expand/contract region with er/expand-region and press a key to temporary hide/unhide it. It is not difficult to write a function to do that based on text properties. Thing-at-point might be useful here too.

https://github.com/magnars/expand-region.el is your friend. I use the built-in equivalent of it in IntelliJ all the time. it's a bit like a vi text objects in the simplest possible way.

Thanks, I will give paredit a shot.

I'm a regular emacs user, but I normally use expand-region[1] and cut/paste to edit lisp code. Expand-region usually knows what I want to move around after just one or two calls, only requires one key binding, and has visual feedback. And it works great in every language I have used.

https://github.com/magnars/expand-region.el

One thing that I always missed is the ability to select a whole function in C#, but I thought I just didn't know the right package or it was something trivial to do ad-hoc. Surprisingly, up to these days I still couldn't find anything. I bumped into the expand-region package at some point, which is awesome, but still something was missing. After going through the Emacs Lisp Intro tutorial, I learned a bit how to search things in a buffer, and I was also editing csharp files every day, so I decided to try to implement the functions myself. Fast forward some weeks, here I am, with a smile on my face :)

The package for growing the selection is the excellent expand-region by Magnar Sveen

If you want to try out some third-party packages in the beginning, I think the most "bang-for-your-buck" you'll get is with Avy. Also, expand-region. And specifically for writing: olivetti-mode, flyspell, dictionary, and Nicolas Rougier's Nano and Elegant Emacs setups.

You will probably like expand-region.el. It is fantastic for selecting inside brackets, quotes, etc.