vim-sexp-mappings-for-regular-people VS doom-emacs

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.

$ rm -rf ~/.config/emacs # Remove the existing directory if necessary git clone --depth 1 https://github.com/hlissner/doom-emacs ~/.config/emacs ~/.config/emacs/bin/doom install

Sounds like what you want is emacs, but preconfigured. In that case, have you tried Doom Emacs, Spacemacs or any of the myriad of others like those?

darren@pop-os:~$ git clone --depth 1 https://github.com/hlissner/doom-emacs ~/.emacs.d Cloning into '/home/darren/.emacs.d'... remote: Enumerating objects: 1156, done. remote: Counting objects: 100% (1156/1156), done. remote: Compressing objects: 100% (1042/1042), done. remote: Total 1156 (delta 85), reused 650 (delta 71), pack-reused 0 Receiving objects: 100% (1156/1156), 1.13 MiB | 7.29 MiB/s, done. Resolving deltas: 100% (85/85), done.

I used to do something like -{ nixosConfig, config, lib, pkgs, ... }: -let - xdgConfig = config.xdg.configHome; -in { - home.activation = { - foo = lib.hm.dag.entryAfter [ "writeBoundary" ] '' - doomdir="${xdgConfig}/doom"; - # $VERBOSE_ARG - if [ -d "$doomdir" ]; then - $DRY_RUN_CMD git -C "$doomdir" pull http master || true - else - # git clone and change url - http="https://git." - $DRY_RUN_CMD git clone "$http" "$doomdir" - # the new url needs ssh keys setup - git -C "$doomdir" remote add http "$http" - git -C "$doomdir" remote set-url origin "gitea@git." - fi - emacsdir="${xdgConfig}/emacs" - if [ -d "$emacsdir" ]; then - if [ -d "$emacsdir/.local" ]; then - $DRY_RUN_CMD $emacsdir/bin/doom sync - fi - else - $DRY_RUN_CMD git clone --depth 1 https://github.com/hlissner/doom-emacs "$emacsdir" - fi - ''; - }; -}

`;; Needed to add javascript-eslint to the the next-checker after lsp so that it would actually load, as that wasn’t happening by deafult ;; also needed to runit after the lsp-afer-initalize-hook because otherwise ‘lsp wasn’t a valid checker (add-hook ‘lsp-after-initialize-hook (lambda () (flycheck-add-next-checker ‘lsp ‘javascript-eslint))) ;; https://github.com/hlissner/doom-emacs/issues/1530 ;; Potential alternative to the above ;; (after! (:and lsp-mode flycheck) ;; (flycheck-add-next-checker ‘lsp ‘javascript-eslint))

The performance lag of Spacemacs was addressed by Doom Emacs ( https://github.com/hlissner/doom-emacs ). Have you tried Doom Emacs by any chance. After syncing everything, the performance is stellar in my opinion.

but I just realized, you're probably better off using doom emacs. The defaults are sane, customizations are almost always optional and the community's really active/helpful. (Disclaimer: I'm a doom emacs user with ~2k lines of config)

While Doom is more opinionated, it's not too difficult make Emacs your own, most of the choices are optimized anyway. Currently the head of Spacemacs devs is not active on the project anymore. Also I don't think it's hard to upstream code to Doom, as long as the code is thoroughly written, take a similar example on both sides: the introduction of a completion engine as layer/module (same packages are installed): - https://github.com/syl20bnr/spacemacs/pull/14901: 23 comments, 7 participants - https://github.com/hlissner/doom-emacs/pull/4664: 576 comments, 20 participants

Also Doom emacs has one. https://github.com/hlissner/doom-emacs https://github.com/hlissner/doom-emacs/tree/master/modules/lang/common-lisp

Nowadays, I use https://github.com/hlissner/doom-emacs with WSL2 but only for org-mode. For code, I have either Sublime Text or VS Code.