xforms VS parinfer-rust

Maybe https://github.com/cgrand/xforms The for transducer might help, just as the for comprehension helps unpack and map/filter nested stuff.

cgrand/xforms is a very useful hidden gem, if you like transducers/eager evaluation/solving map-vals without meander/specter.

* It's fast enough for 99% of apps out of the box. It's fast enough for 99.99% of the apps with minimal tuning.

* Yes, if your project is very big and macro heavy, it can take some time, but startup times have improved. In any case, I BARELY need to restart my development JVM. I have one currently running that I haven't restarted for 1 week+.

* Depending on what's your cup of tea, there's emacs/CIDER or IntelliJ/Cursive. They both work well. IntelliJ/Cursive is an excellent IDE combination. I use it every day.

* Java interop is very straightforward, not sure what you mean. Sure your code might not be all pure anymore, but that's the price for solving actual problems.

* Good java libraries have wrappers. A ton of original Clojure libraries as well. https://github.com/cgrand/xforms for example allows you to easily do things that I can't even imagine doing in an imperative language.

* Static vs dynamic typing: don't want to get into that.

* "Clojurescript isn't the same language". I use both Clojure and ClojureScript every day and as far as Clojure-only code is concerned, it works in both languages 99.99% of the time. One case you can encounter issues is if you do something host-specific, like dealing with numbers. That's by design. Clojure embraces each host, does not try to reinvent it. When you just use pure Clojure data structure manipulation, it works the same across both languages and works like magic.

parinfer-rust, while LISP only for reasons, is still absolutely amazing overall for its performance compared to the Lua version. I do wish there were more bracketing/scope algorithms out there for other languages. With a parinfer plugin, you only need to start a bracket for it to close what it believes is your scope. Great for enclosing things in functions

While my main daily driver is also IntelliJ, and also for Parinfer, I have found that Neovim + Rust-parinfer works remarkably well.

Another example where rust's benefits show is something like parfiner. Currently I'm using my own ffi interface to https://github.com/eraserhd/parinfer-rust, and it feels significantly faster than the plain-lua version I had before. Getting to write the whole thing in rust just makes life easier and simpler

I use a combination of parinfer-rust and Conjure for my Clojure, Janet, and Fennel development.

My personal configuration is also written in fennel if you would like to take. look: https://github.com/shaunsingh/nyoom.nvim. Neovim's come a long way in what you can do with it. Fennel has a macro system as with any lisp, so you can make the syntax feel right at home with emacs https://github.com/shaunsingh/nyoom.nvim/tree/main/fnl/macros. You can even create dynamic-module like integrations with rust programs (see https://github.com/shaunsingh/nyoom.nvim/blob/main/fnl/parinfer/init.fnl, interacting with https://github.com/eraserhd/parinfer-rust/tree/master/src)

eraserhd/parinfer-rust if you do any sort of Lisp programming

Clojure is an amazing language, and so is Rust. In fact, I think learning both of them is a wonderful way to introduce ourselves to such a broad range of programming ideas that it covers over half of the seven programing ur-languages. It's even worth investigating the differences in the way these languages have developed over time (Clojure being Rich's project and Rust taking a community approach). These ideas aren't in opposition to each other. If they were, the indispensable editor plugin I use to write Clojure wouldn't exist for crying out loud.

Have you seen an excellent parinfer-rust implementation of Parinfer? It's quite fast and can be integrated with other editors, like Emacs, Kakoune, Vim, etc. I think you can try to see if your integration passes their tests.

I am currently using parinfer. It’s not exactly minimal, but it doesn’t require much configuration and doesn’t have any special keybinds.