With your help, I would like to make a list that explores the strengths of Haskell.
Please add, comment or elaborate on these strengths and give examples, stories etc.
To discuss, or elaborate on a point, please select it along with the hashtag and click the “quote” popup to include the quote in your post. This will make it easier to search for posts on a certain topic.
If you suggest new points I’ll edit this post to expand the list (or I’ll try to fix my mistakes if you suggest corrections ).
#strength000 - The Compiler is “Industrial Grade” (Haskell is reliable enough that you can trust it with the production code that your business depends on)
#strength001 - Static Typing i.e. Compile Time Checking Of Code (This forces some work to be done before code is run and it forces some loss of [dynamic typing] flexibility, but it helps software not to crash for a user!)
#strength002 - Developer Productivity (Once a team gels and knows Haskell well enough they can have very high productivity)
#strength003 - Garbage Collected (Haskell avoids the complexity and dangers of managing memory manually. This contributes to making Haskell more productive (as in the previous point) as a “high level language” where you can focus more on your main task than the low level workings of a computer)
#strength004 - Function Type Signatures (Signatures are sometimes described as documentation that gets checked by the compiler i.e. you can rely on the type signature to be accurate. This has also been called a nice lightweight proof embedded in your code.)
#strength006 - Advanced Type System (Increases safety and flexibility. You can rest assured that right now there teams working on integrating new, valuable, advanced type level features.)
#strength007 - A Community Of Individuals Large Enough to Support a Healthy Ecosystem Of Libraries And Tools
#strength008 -(edited to add “Identifiably”) Identifiably Pure Functions (You can count on reliably getting the same results out of a pure function. This enhances programmers’ ability to reason about Haskell code.)
#strength009 - Great Concurrency https://downloads.haskell.org/~ghc/7.0.3/docs/html/users_guide/lang-parallel.html
#strength010 - Great Support for Parallelism (see link above)
#strength011 - Lazy Evaluation (Avoids unnecessary evaluation of code, allows for infinite data structures and custom control flow structures. (I think this somehow relates to ease of refactoring?)
#strength012 - Elegant Syntax With Less Noise Than Most Languages
#strength013 - Increasingly
Awesome Good Language Server Support (a few years ago there wasn’t much language server support and now it can do some pretty cool things)
#strength014 - Great For Domain Modelling With Algebraic Data Types
#strength015 - Good Support for Generating Documentation
#strength016 - Immutable Values Everywhere (This often makes functions simpler to understand than Python (for example) since in Haskell you don’t need to determine if a function does or does not mutate a value passed to it)
#strength017 - Type Inference (You don’t need to always write out types) [Thank You @jaror]
#strength018 - Good Support for eDSLs, such as Parser Combinators (partly due to good support for custom operators). [Quoted from @jaror, Thank You!]
#strength019 - Coherent Type Classes (which allow you to write safe, polymorphic, and efficient data structures, such as sets based on binary search trees. Almost all languages can only achieve two of those three points.) [Also quoted from @jaror, Thank You Again]
#strength021 - Maintainable Code - Refactor With Confidence (This is largely a consequence of static typing (point 001) but arguably it is about a confluence of features [see State Of The Haskell Ecosystem # Maintenance Thank you for the link @gilmi! ]
#strength022 - Great Support For Automatic Testing ( see the Quickcheck Library)
#strength023 - Type Driven Development State Of The Haskell Ecosystem # Type Driven Development [Thank You @gilmi]
#strength024 - Compiler Extensibility (GHC successfully enables all kinds of features to be tried and used before a commitment needs to be made to extend the language )
#strength025 - Haskell Has A High Level Of Internal Consistency With A Sharp Focus On The Pure, Functional Paradigm (With its roots in academia and the lambda calculous and a perhaps obsessive, uncompromising pursuit of “purity”, Haskell is highly opinionated and feels like it has a very solid foundation. In other words it feels like its not a somewhat random, hacked together, kitchen sink language.)
#strength026 - Developers Express A Sense Of “Peace of Mind” When Putting Code Into Production. (a result of a combination of the above features)
#strength027 - The New Haskell Foundation (A central organization with a mission to nurture the Haskell ecosystem and its already succeeding at securing significant financial resources from corporate and individual donors.)
#strength028 - There Are A Slew Of Businesses Willing To Support The Ecosystem (They are making increasingly significant financial contributions to the Haskell Foundation and also paying some employees to work on Haskell infrastructure)
#strength029 - The Haskell Community Has A Bunch of Teams, Organizations And Committees Devoted To Helping Haskell Succeed In Various Specialized Ways.
#strength030 - Haskell Is Not Controlled Or Tied To A Single Large Corporate Sponsor (Hopefully this leads to a greater sense of community ownership.)
#strength031 - Haskell Is Multiplatform (Windows, Linux and Mac operating systems all work effectively with Haskell)
#strength032 - Haskell Has A REPL
#strength033 - Haskell Has A Team Focused On Increasing The Quality Of Base Library Documentation (https://gitlab.haskell.org/ghc/ghc/-/issues/17929)
#strength035 - Dedicated/Uniform Ecosystem(With languages like Kotlin, Scala, Elixir, Clojure etc. “benefiting” from the wider ecosystem also means being prepared to work in a second language/paradigm.)
#strength036 - "Equational Reasoning"
#strength037 - A Focus On Composition Over Inheritance (Type Classes)
#strength038 - Pattern Matching
#strength039 - List Comprehensions (thanks @ddavo)
#stength040 - There Are More Than 30 Books Available On Haskell
#strength041 - There Are A Bunch Of Free Resources For Learning Haskell
Collection Of Links To Resources For Learning Haskell
#strength042 - Hoogle (Search for functions by type signature)