yield*
function*
a?.b?.c
function f(x = 3) {
x ??= 3
...
a!.b
Type<T>
type A = B extends C ? D : E
...
#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.
It was such a great time and place for a young person interested in learning about Haskell.
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
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 ...
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.
* $ 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
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.