One benefit of learning functional languages, whether Haskell or Clojure, is that it makes you a better developer in other, non-functional, languages.
can you clarify "how" it makes one a better developer? When I think of how the java streams API is used, it generates lots of garbage (i.e. lots of intermediary allocs), doesn't always make things clearer.. i'm genuinely curious (and in fact i like the streams API, it's just often misused by collecting at the wrong step..).
If you're working on graphic engines, quants, system programming, you won't really be using a GC language anyways. There, being a better programmer is a lot about low level in the small design details.
If you're instead working on enterprise or consumer applications, backend processing, big data, information systems, saas, etc. There, you'll find Clojure makes you a better programmer, because it teaches a lot about in the medium to large design skills for growing such systems, where high/medium level decisions matters more and micro-opromizations a lot less.
Things that I've learned from Clojure are:
* Better grasp of OOP and polymorphism
* Better grasp of recursion and memoization in general
* Better code structure for independent, modular, and reusable designs
* Better isolation of external effects and internal business logic
* Better, safer and more clear data manipulation techniques
* Better domain modeling and data modeling
* Better handling of data at the boundaries of my application
* Logic programming
* Better understanding of mutation/immutable trade-offs
* Better balance between spaghetti code and lasagna code
* Monads and other functional patterns
* Better use of higher order functions that benefit code understanding, extensibility and reuse
* Better understanding of language design, code parsing and generation
* Better understanding of numbers in general and numeric tower details
* Better understanding of dependency injection and stateful components
* Better understanding of parallel computing and various lock and lock-free designs
* Better understanding of asynchronous and concurent computing, use of events, queues, CSP, future/promise, structured concurency, etc.
* The awesomeness of structural edits, homoiconicity, and Lisp in general
* The awesomeness of interactive live programming
* Emacs