Haskell

Every issue, all time, most people first

1. Syntax is weird and hard for beginners to learnUnreviewed

   48 people since 2009, in 15 different years · 3 this year

   20082026
   • Writing dependent types in Haskell requires awful tricks and has a worse user experience2026-07-30
   • Haskell is too hard for the commenter to use or understand2026-06-02
   • Haskell's developer tooling is poor, slowing the commenter down2026-04-10
   Something wrong here?

2. Type mismatch error messages are hard to understand for beginnersUnreviewed

   17 people since 2010, in 10 different years · 1 this year

   20082026
   • Type errors without annotations don't reveal which of two types is wrong, causing confusing messages2025-11-30
   • Long, detailed, subtle error messages suggest the compiler over-infers intent2024-12-03
   • Compiler errors are poor, first error stops the rest of compile, overwhelming for juniors2024-09-12
   Something wrong here?

3. Too many operators to remember and search forUnreviewed

   15 people since 2010, in 9 different years · none this year

   20082026
   • Terse syntax and custom operators make code hard for beginners to read2024-09-12
   • Cryptic ASCII operator soup and multiple similar operators are hard to read and remember2022-12-06
   • Too many operators, hard to remember and search for them2020-12-18
   Something wrong here?

4. Can't understand monads despite multiple explanationsUnreviewed

   14 people since 2012, in 11 different years · 1 this year

   20082026
   • Monads and type classes are hard to understand and unclear where defined2025-11-07
   • Hard for beginners to understand because of monads, laziness, and indentation rules2024-12-23
   • Hard to learn monads and IO; needs full library knowledge to get anything done2024-05-14
   Something wrong here?

5. Reasoning about performance is hard because of lazy evaluationUnreviewed

   12 people since 2011, in 9 different years · none this year

   20082026
   • Can't predict runtime performance of code, it's either very fast or very slow2024-08-05
   • Lazy evaluation makes memory usage confusing and hard to predict2022-08-12
   • Even the simplest code is nearly impossible to debug, and laziness causes easy-to-make mistakes2022-06-08
   Something wrong here?

6. Tool setup is hard, with install commands cited as the exampleUnreviewed

   12 people since 2010, in 9 different years · none this year

   20082026
   • Installing Haskell cross-machine was painful, especially on macOS in 20192023-07-03
   • Editor tooling was buggy and needed configuration, making Haskell hard to use2022-08-12
   • Haskell GUI libraries are very difficult to install on Windows2019-12-09
   Something wrong here?

7. Operator precedence is hard to map, forcing trial-and-error with dollar signsUnreviewed

   7 people since 2012, in 6 different years · none this year

   20082026
   • Operator precedence is too complicated to mentally map, forcing trial-and-error with dollar signs2020-09-08
   • The $ operator's function application direction is confusing to read2019-10-17
   • Operator direction for composition is counterintuitive, so readers expect the opposite symbol2018-08-21
   Something wrong here?

8. Indentation rules are hard to learn and hard to search forUnreviewed

   4 people since 2008, in 4 different years · none this year

   20082026
   • Indentation-as-syntax rules are confusing and took a long time to learn2024-12-03
   • Indentation rules are hard to learn and hard to search for2020-08-29
   • Indentation is wrong about 20% of the time, making tab-cycling tedious2014-01-23
   Something wrong here?

9. do-notation is hard to read, requiring mental desugaringUnreviewed

   4 people since 2013, in 4 different years · none this year

   20082026
   • Do-notation is confusing to read, requiring mental desugaring and fighting indentation rules2025-01-19
   • Do-notation and >>= are confusing; people fail several times before understanding them2017-07-26
   • Whitespace function application and operator precedence confuse newcomers2015-09-29
   Something wrong here?

10. Documentation uses type theory terms that are hard to followUnreviewed

    3 people since 2012, in 3 different years · none this year

    20082026
    • Documentation uses type theory terminology that practitioners find impossible to follow2021-05-06
    • Hard to find which types implement a typeclass; docs and hoogle don't list them2017-09-13
    • Confusing generic type names make beginners struggle to grasp concepts2012-10-31
    Something wrong here?

11. Error messages point to the wrong place, hard to act onUnreviewed

    3 people since 2016, in 3 different years · none this year

    20082026
    • Error messages are opaque, so newcomers can't get from error to fix2025-01-19
    • Error messages are hard to understand and the dev environment is hard to figure out2020-10-06
    • Error messages point to the wrong place and are confusing to act on2016-06-06
    Something wrong here?

12. Most libraries are hard to use and don't compose wellUnreviewed

    3 people since 2016, in 3 different years · none this year

    20082026
    • Popular libraries have fundamental flaws and ease of use is neglected2024-01-30
    • Most libraries are hard to use and don't compose well2018-02-01
    • Symbol-heavy library APIs and right-to-left composition are hard to read and learn2016-12-26
    Something wrong here?

13. Point-free style and overloaded operators make code unreadableUnreviewed

    3 people since 2011, in 3 different years · none this year

    20082026
    • Terse, convoluted syntax and point-free style are hard to understand and follow2021-06-26
    • Code written with point-free style and overloaded operators becomes unreadable and is dismissed by the community2018-05-20
    • Point-free code is easily abused, becoming unreadable and hiding what it does2011-10-03
    Something wrong here?

14. Libraries need many confusing language extensions to get workingUnreviewed

    3 people since 2022, in 3 different years · none this year

    20082026
    • Language features hide everything behind arcane extensions, making usable code hard to get2024-05-31
    • Libraries require many confusing language extensions, making projects hard to get working2023-10-08
    • Must constantly hack around the language with extensions to do needed things2022-12-02
    Something wrong here?

15. Code lacks visual structure cues, so it is hard to readUnreviewed

    3 people since 2011, in 3 different years · 1 this year

    20082026
    • Code is hard to read because its structure is hard to guess2026-04-29
    • Code looks like a stream of whitespace with no visual cues for structure, so it is hard to read2025-01-31
    • Hard to visually parse code made of whitespace-separated identifiers2011-11-04
    Something wrong here?

This list counts all time; the period switch above only changes the ranking. Each issue is a group of similar complaints raised by at least 3 people in 3 different months and threads. Each line under an issue is Claude Haiku's summary of one of its latest comments, not a quote; follow it to read the comment on Hacker News.