[iLemming]

> JS is more readable, without a doubt

In what sense?

Haskell's: strSum = sum . map read . words

in JS would be: const strSum = str => str.split(' ').map(Number).reduce((a, b) => a + b, 0);

for a person who's not already a JS programmer, the first one would be more readable (without a doubt), it literally reads like plain English: "sum of mapped read of words".

Haskell's version is more "mathematical" and straightforward. Each function has one clear purpose. The composition operator clearly shows data transformation flow. No hidden behavior or type coercion surprises.

Whereas JS version requires knowledge of:

- How Number works as a function vs constructor

- Implicit type coercion rules

- Method chaining syntax

- reduce()'s callback syntax and initial value

- How split() handles edge cases

So while the JS code might look familiar, it actually requires more background knowledge and consideration of implementation details to fully understand its behavior. Javascript is far more complex language than most programmers realize. btw, I myself don't write Haskell, but deal with Javascript almost daily and I just can't agree that JS is "more readable" than many other PLs. With Typescript it gets even more "eye-hurting".

[brabel]

> in JS would be: const strSum = str => str.split(' ').map(Number).reduce((a, b) => a + b, 0);

It's funny to me that you quote the FP-like version of that in JS.

The more traditional version would be more like this:

    function strSum(str) {
        let words = str.split(' ');
        let sum = 0;
        for (word of words) {
            sum += new Number(word);
        }
        return sum;
    }

I do sincerely think this is more readable, no matter your background. It splits the steps more clearly. Doesn't require you to keep almost anything in your head as you read. It looks stupid, which is great! Anyone no matter how stupid can read this as long as they've had any programming experience, in any language. I would bet someone who only ever learned Haskell would understand this without ever seeing a procedural language before.

[iLemming]

I don't even know where to start, your biases here are so explicit.

- The assumption that "verbose = readable" and "explicit loops = clearer"? Seriously?

- The suggestion that "looking stupid" is somehow a virtue in code? "Simple" I can still buy, but "stupid"... really?

- You're using new Number() - which is actually wrong - it creates a Number object, not a primitive;

- You `sum +=` is doing not a single op but multiple things implicitly: addition, assignment, potential type coercion, mutation of state;

- for loops are another layer of complexity - iterator protocol implementation, mutable loop counter management, scoping issues, potential off-by-one errors, break/continue possibilities, possible loop var shadowing, etc. Even though for..of is Javascript's attempt at a more FP-style iteration pattern and is safer than the indexed loop.

You clearly underestimate how natural functional concepts can be - composition is a fundamental concept we use daily (like "wash then dry" vs "first get a towel, then turn on water, then...").

Your "simple" imperative version actually requires understanding more concepts and implicit behaviors than the functional version! The irony is that while you're trying to argue for simplicity, you're choosing an approach with more hidden complexity.

Again, I'm not huge fan of Haskell, yet, the Haskell version has:

- No hidden operations

- No mutation

- Clear, single-purpose functions

- Explicit data flow

You have just demonstrated several key benefits of functional programming and why anyone who writes code should try learning languages like Haskell, Clojure, Elixir, etc., even though practical benefits may not be obvious at first.