ghostwheel

> Perhaps the dynamic type system can have a fancy linter that does something crazy like running your code... but I'm not aware of any such linter. Names in Clojure codebases and libraries are pretty reliably annotated with trailing exclamation marks, looking like: `save!`. To that end, running Clojure code blindly to test it and its types is a fairly practical practice, coming up in cases like Ghostwheel [1], which uses this for generative testing of clojure.spec types, which can be much more sophisticated than what is commonly used in static systems, even with refinement types. [1]: https://github.com/gnl/ghostwheel#staying-sane-with-function...

Hm the /amount/ of syntax isn't something I think about I guess, this being a Lisp. I think they've taken the approach of making the system thorough and capable and this being a Lisp, we users can skin it with any level of shorthand that we please. Datomic (the database from Cognitect) has a similar approach with its schema, which is quite verbose, but many folks that I know tend to simply write a function which spits out the schema, since it's 'just data'. I tend to use Ghostwheel [1], but there's also spec-tools [2] and others. [1]: https://github.com/gnl/ghostwheel [2]: https://github.com/metosin/spec-tools

> I think this comes down to low ceremony vs high ceremony One of the most cited qualities of languages like Haskell are their "refactorability" - i.e. one can routinely rip out the guts of a 100KLOC codebase and replace fundamental data structures and functionality in order to implement new features in a couple of hours, no problem whatsoever. In Rails, I'd do everything in my power to not touch any "important" code if I can get away with it, because no matter how good the test suite, it's still a test suite. It shows the existence of bugs, it doesn't prove their absence. Many people claim that's not a problem in practice, but I personally tend to avoid more fundamental code changes in dynamic codebases precisely because of that fact. To drive that point home, I'd trust a Haskell codebase without a test suite more than a Rails codebase w

Much as I love Clojure, I agree that clojure.spec, while very powerful, has a mess of a UX. That's why – shameless plug – I wrote Ghostwheel [1], which, to me, turns it into a whole other thing, especially when gen-testing, spec-instrumentation and tracing are used together. Having inferred types in addition to this would be even better, but types are no replacement for generative testing or vice versa. They really complement each other quite nicely, but also have a large overlap in terms of how much they can reduce the need to do manual debugging and enable clean changes/refactorings with minimal effort. [1] https://github.com/gnl/ghostwheel

For Clojure, check out Ghostwheel [1] - a lightweight DSL for writing specs. If you want proper static typing though, ReasonML might be a good choice. Static, compiles to js and native, super easy to learn, and there’s an experimental Lisp frontend with Clojure-like syntax if you can’t live without paredit. [1] https://github.com/gnl/ghostwheel

The short answer is "more or less", the longer answer is the second one in the FAQ: https://github.com/gnl/ghostwheel#faq