I don't think it's because I'm used to Algol-based languages (C, Python, etc.). Every Haskell code I've seen is plagued with a plethora of operators which aim to make the code concise but it's not obvious what they do just by looking at them: https://academy.fpblock.com/haskell/tutorial/operators/
Isn't that pretty close to what something being intuitive means? Ie. something being intuitive means that it's easily understood or learned without requiring prior knowledge or instruction.
If I didn't know programming and picked at random some Java program, I wouldn't understand much either. If I didn't take a single math course and I tried to read a math formula, I wouldn't understand the operators or anything either.
The standard should be: how much can you understand once you learn the basics and do a couple of tutorials?
Haskell has some up-front incidental complexity, but it's a difference of degree not kind from popular starting languages. It's easy to underestimate how much you had to learn about Algol-style languages that you've just internalized so well that you don't even realize. I've taught some complete programming beginners (high or middle schoolers) Java and Python and, especially one-on-one, I've seen how they get confused by things I did not even remember required explanation!
For example, in Python, people put : in the wrong place and don't understand how = works. "Basic" syntax like : and = are far more complex than we realize, we've just learned the basics so well that it's second nature. It's similar to how native English speakers don't even realize we have rules for adjective order ("big red ball" vs "red big ball"), while language learners run into it like a brick wall.
#haskell on freenode in the 2000s was a really fun place. I could not for the life of me convince anyone else to use the language.
the perl6 guys ended up inventing the new perl (now renamed raku)
https://rakujourney.wordpress.com/2024/10/12/raku-burritos/
the first perl6 parser (pugs) was written in Haskell btw
yield*
function*
a?.b?.c
function f(x = 3) {
x ??= 3
...
a!.b
Type<T>
type A = B extends C ? D : E
...
It was such a great time and place for a young person interested in learning about Haskell.
Once you understand what the combinators do in a particular context the code often reads very easily, and what it does is very intuitive and natural.
Best example I can think of is applicative parsers, where there are scattered <*> and <$> operators around, but if you just ignore them the parser just looks like a very intuitive description of what the expressions you want to parse look like.
In Haskell, the lack of parentheses for function calls plus currying means that to read a function call, you need to already know how many arguments the function takes, which I feel adds a new level of difficulty over languages where you can often guess what a function does based on its name, without looking it up.
As a result, often Haskell reads more like math, where without knowing each symbol’s definition, you’re lost.
I’ve seen cryptic JavaScript too, but less often.
While I agree with the general sentiment of what you are saying, note that the syntax has nothing to do with it, it is purely about Haskell using currying excessively. The syntactic translation between Haskell and JS is straight-forward and 1-1:
f x y z -> f(x)(y)(z)
f x (y,z) w -> f(x)(y,z)(w)
Yeah but the JavaScript operators are almost all universally understood. There are some exceptions and mistakes, like `===` which shouldn't exist, and `.?` which is new but fairly standard. But most of the operators are just standard maths stuff, normal array/field accesses, etc.
Haskell has normal operators plus a bunch of weird operators that you need to learn. Even if the raw number of operators is only 2x, the number of operators that you have to learn is probably 10x.
Especially when you consider that Javascript operators are fixed so you have to learn them once, whereas Haskell operators are user-defined and Haskell programmers love defining them.
however, there are certain sub languages (slangs) where the use of punctuation chars as operators is very helpful, of course regex is the most compelling where the code is parsing one char at a time
my regex url {
^ # Start of line
[<http> s? '://'] # Match http or https
['www.' ]? # Optional www.
[<[\w\-]>+ '.' ]+ # One or more domain segments
<[a..z]> ** 2..6 # TLD, 2 to 6 lowercase letters
[ '/' <[\w\-./?%&=]>* ]? # Optional path/query
$ # End of line
}
it was inevitable that a simpler language - Python - would take the big slice of scripters who wanted something easier to learn and to read
I'm sad that perl no longer has a credible niche for script level coders who want to learn a more powerful and more expressive language than Python ...
* $ is "function application" - f $ x = f x, but lets you elide nested parens: f $ g $ h x = f (g (h x))
* & is "reverse function application" x & f = f x. This reads nicely in pipelines as "and"
* <$> is "fmap" what is like a lifted application over a structure: f <$> [1, 2, 3] = [f 1, f 2, f 3]
* <&> is "reverse fmap", which is nice when you have a big lambda
* Anything in <_> brackets is generally a "lifted" version of some operator
* And so on