Ask HN: Why do functional programmers hate loops (for, while, etc.)?

But that can't be tail call optimized, so you should write something like

    sum(n, acc=0) = n == 0 ? acc : sum(n-1, acc+1)

To me that negates much of the 'declarative' character of a functional style. I don't feel it's really clearer than the imperative for-loop

    acc = 0
    for i = 1 to n
        acc += 1

Looping was more natural to me, but learning Elixir (I've been using Learn Functional Programming with Elixir) made it so much easier to grasp and more natural. It's a fun language to use to boot.

I think it has a lot more to do with readability. Certain conventions are easier to read. This is especially important as we realize that code is easier to read if we don't have to delve into the context.

For example, (I've spent a lot of time in C#,) let's say you have a collection of Foo objects, but you need to convert them to Bar objects. There's two general patterns in C# to do this:

  var bars = new List();
  foreach (var foo in foos)
  {
     bars.Add(foo.ConvertToBar());
  }

Versus:

   var bars = foos.Select(foo => foo.ConvertToBar());

Which one is more readable? If you're a newcomer to the language, or you generally haven't worked with "Select" before, the foreach approach might make more sense.

But, as you get used to "Select" and understand what it does, you'll probably come to the conclusion that foos.Select is easier to read, especially if you're looking at code that someone else wrote, where you might not have all of its context in your head.

Some other responses in this thread explain the difference by saying that "loops are saying how you want something done, functional is saying what you want done." This also is helpful when reading code where you don't have all the context in your head. (IE, code someone else wrote, or code you haven't worked with in a long time.)

To provide an example, you could have an array, int[] in C#:

  var sum = 0;
  foreach (var i in values)
  {
      sum = sum + 1;
  }

Or:

  var sum = values.Sum();

Both are valid C#. But, the functional approach is much easier to read, because you don't need to understand as much context when comparing the loop approach to using the Sum() method.

If you're a novice to C#, a novice programmer in general, or you're merely unfamiliar with Linq, the loop approach might seem easier. It's "not wrong..." But, remember, you're saying "how" instead of "what."

A codebase that constantly says "how" instead of "what" ultimately is harder to work with, because it takes longer for everyone to understand each others' code.

Let me offer the one thing that functional programmers and imperative programmers can agree on hating: the Common Lisp LOOP macro.

(Which I actually use all the time, if only to save a dependency.)

nobody hates anything. we don't hate while/for/etc loops.

We should just be careful when using them just like any other nested structure (if/else/while-do/switch/select/etc.)

Like if I see ``` for ... { for ... { if ... { } else { } // code here ... } ... } ```

That is objectively bad code and not readable.

Nobody hates anything. Most of us just dont like how people misuse them to write bad code because their managers pressure them.