Parinfer: Simpler Lisp Editing
shaunlebron.github.io
shaunlebron.github.io
When you start out with Clojure/Lisp and you aren't totally used to parenthesis you can just use Parinfer to get editor behaviour similar to developing Python. It removes a major pain point of migrating to a Lisp. It used to be the case that you were forced to learn Paredit pretty much from the start.
However it also made me very strict and opinionated about formatting. One of the main downsides of parinfer comes when you have to interact with someone else's poorly indented or opinionated (wrongly) formatting that goes against the clojure style guide. Parinfer can then ruin otherwise working code because things are out of alignment. To fix this, I set up a function to force format files on open, which mostly works but then for the longest time made me the source of a lot of white space commits. It also struggles with egregiously long files.
Thankfully I eventually got my team on board with force formatting all files and treating non standard formatting as linting errors. We also cut down the largest files one of the other devs made, and that helped a lot.
I started part-time in Clojure in 2011 and full-time in 2014. I've never felt like I needed any extra tooling for parens. Instead of typing `foo(x)`, I type `(foo x)`. It seems...almost exactly the same to me.
Same with text editors: people will say you need emacs, Cursive, etc. but I just use vim for Clojure, as well as everything else. It works great.
I tend to move around parens quite a lot while developing, constantly refactoring, so some kind of structural editing was necessary for me from the get-go.
When I tried this in vscode it was problematic
It's still a bit quirky, but I use it every day and I love it. Even though I'm proficient enough with paredit, parinfer is just so much easier to use. Several users have commented to me that the parinfer integration is the main thing stopping them switching away to a different editor - it really makes that much difference.
I remember people, including Rich Hickey, scoffing at it when it came out, which seemed like kind of a snobbish reaction to something that lowers the barriers of entry.
(Think: John Carmack writing something for John Carmack's use, and it turns out you need to be as smart as John Carmack to figure it out.)
I tried Paredit out in the early days; it was heavily inspired by SEdit, the structured editor that came with Xerox's Interlisp-based Lisp machines (an open source version of whose OS is available here: https://interlisp.org). I really liked it, but with time I found it was just another "targeting computer" I had to switch off in order to keep focus on my code, so I ended up not using it for most of my Lisp work.
My favourite structural editing tool for about a year now is symex[1], which is an Emacs package (and unfortunately not that well known compared to paredit, lispy, etc.). It takes some getting used to at first but after a while you only move around and think in terms of s-expressions, you don’t even see parentheses anymore. It really feels like you are a squirrel climbing trees (hence the image on the repo, I guess). I just hope the dev(s) will be able to get rid of the heavy dependencies on other packages soon.
It has gaps around pasting content and how to handle that elegantly as well as comment behaviour, if those two things could be reconciled, it would be even more useful :)...
At first I thought this is something new, because it's cool and I haven't heard of it, even though I'm coding in Clojure for about 3 years now. But this project is already 10 years old and hasn't received much attention for the last few years, which is a pity. I wish it was coming with Calva, my favorite Clojure tooling in VS Code.
You have this basically already. When you move forms in/out on the indentation levels, notice how the brackets/parenthesis automatically re-arrange themselves? That means it's working :) https://calva.io/parinfer/
But so what, is there no automatic balancing of parenthesis in Calva? That seems to diminish the value from the extension by a lot, I couldn't imagine coding Clojure and having to manually balance parenthesis.
Also, the main maintainer of Calva doesn’t use Parinfer, and so isn’t very motivated to add it either. But if someone were to contribute it, I imagine he’d be very receptive.
Neither my plugin nor Chris' script have been updated in 2+ years. That's because it just keeps working. I owe a lot to Shaun and Chris for their work (my plugin is just a little glue code for interacting with the editor, they did all of the hard work).
There are some issues, but it's usable.
I hacked in a hotkey to toggle it on and off (Ctrl-Underline).
The parinfer code from Vim does not work in the parens->indent direction, only indent->parens. I tried to get it working, but it didn't for me.
It doesn't properly understand the #; syntax for commenting out an object. It's possible for it to get into an endless loop when an undo operation restores invalid syntax; there is a kind of fight between undo and parinfer that has to be interrupted by Ctrl-C.
Otherwise it's mostly fine.
I've since settled on Lispy and Lispyville in Emacs, and have run into very few issues over the past few years.
There's something about Lispy’s style of editing that appeals to me — the use of hugging parentheses to enable its bindings, combined with Lispyville making all of my Vim bindings safe, makes me very happy.