deprecated-coalton-prototype VS clj-kondo

can't jerk

I used to use CL quite a bit, but have since abandoned it for Haskell, so I'm a bit biased.

There's a number of issues with that:

- I'd be missing all the optimizations that can be performed due to purity.

- There's more to Haskell's type system than just vanilla Hindley-Milner, and the implementation of it isn't particularly trivial. https://github.com/stylewarning/coalton is the closest thing and it's still missing a large amount of the type system.

- Doing the implementation would be a significant amount of work to get it to integrate well with the language, and it would be a layer tightly glued on top instead of integrated with the language.

- A major part of Haskell is the standard library, a good chunk of the semantics of Haskell people use on a day to day basis, like monads and etc, are a part of the standard library.

This looks like something Common Lisp does better, however I have too little Clojure experience to compare. CL (and SBCL in particular) does "good enough" static type checks, it throws warning at compile time (when we compile one function with a keystroke). We can also precise our function types gradually. It isn't a HM type system (Coalton[1] could be it) but it's already great (compared to no compile-time types at all).

Oh, about interactive development: that's sure, CL shines here. Objects get updated (lazily) after a class change, we can install Quicklisp libraries without restarting the image, etc. It's very smooth.

1: https://github.com/stylewarning/coalton

Help out with Coalton.

If you like this kind of stuff, maybe you can help implement type classes in Coalton.

(there's a work-in-progress library to add a dialect of ML on top of CL: coalton)

My best suggestion here would be clj-kondo with flycheck-clj-kondo in Emacs. I really can't recommend it enough and would have killed to have it when I was learning Clojure. Not only will it underline all of those references to (now) undefined vars, but it can tell you about numerous little mistakes like mixing up arguments orders in (say) sequence functions, misplaced docstrings that get discarded, style conventions, etc. It's staggering how good it is even for a language as dynamic as Clojure.

The clj-kondo linters are worth reading.

Sure!

Spec: https://github.com/edn-format/edn

Example (linter config): https://github.com/clj-kondo/clj-kondo/blob/634294183a0aa2ca...

Clj-kondo doesn't produce an AST but you could easily combine the analysis output with the AST produced by rewrite-clj by matching on location.

But if you want full support, you can implement a hook: https://github.com/clj-kondo/clj-kondo/blob/master/doc/hooks.md

Please configure and use tools like clj-kondo and kibit. Kibit will report areas where you could write idiomatic clojure instead. Eg, it should catch all those (if (condition) true false) and ask you to replace it with (condition). Or if you really need a boolean value, use boolean to coerce it.

Try clj-kondo, a Clojure linter which will tell you about arity errors and more, before you even evaluate your code.