xforms VS ghcid

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.

You can use ghcid. It compiles the code, and shows if there are any errors as you save your file. Have two terminals. One for editing your file...other one with ghcid ($ ghcid path/to/filename.hs). Right click on the ghcid terminal and click `always on top`. That way, It will be always visible as you are typing and saving code.

With a combination of ghcid, an hiedb filewatcher and the -fdefer-type-errors flag you can get pretty solid IDE behavior. Currently only ghc 9.4.4 is supported but happy to personally help people set this up if interested!

With an editor integration, you could rig it up to where you could right-click on a Spec, choose "Run spec" from a context menu, and have your editor add that comment to and save dev.hs. Another editor integration could read and parse the contents of ghcid.txt. We have this already for the compiler output, but it doesn't yet parse the test output. But sans an editor integration, you will still see the test output in the console where Ghcid is running.

Sounds like you want ghcid. You can use it run tests on a successful build, and it will watch files in your project and quick-rebuild when there are changes. There shouldn't be any need to modify your Cabal files or test dependencies.

In addition, for Haskell, I usually have ghcid running, which likewise re-runs on every file change, but gives faster feedback about any type errors than the full compiler, and also is configured to evaluate

Have you looked into ghcid? https://github.com/ndmitchell/ghcid

VS Code + Haskell extension is usually best, but ghcid is an alternative which is much simpler, easier to set up, less pretty and powerful but still pretty easy and effective to use. Here's a workflow:

In general, though, I recommend just looking at the cabal files for various libraries and executables. Something like ghcid is good, since it contains a library, an executable, and a test suite.

you should also checkout the ghci vim plugin https://github.com/ndmitchell/ghcid/tree/master/plugins/nvim