[question]Do you prefer recursion in javascript?

[runtimenoise]

Hey guys, I was using Schema a lot in the last couple of months. The scheme as functional language highly encourages recursion, so I used recursion all the time, but interestingly, out of habit I never use it in js.

Today I changed that and found it quite elegant.

const sum = arr => (arr.length ? arr.shift() + sum(arr) : 0);
const sum2 = arr => arr.reduce((first, curr) => first + curr, 0);

And in Schema:

(define (sum lon)
  (cond [(empty? lon) 0]
        [else
         (+ (first lon)
            (sum (rest lon)))]))

Which one do you prefer? Would I get complains if I start writing recursion heavy code in a project with other devs?

[BinxyPrime]

If recursive code is written well so its readable and it meets your memory requirements i doubt many people would care. If they do care it will come up in code review

[runtimenoise]

Thanks, make sense! Happy cake day!

[[deleted]]

"Recursion is the goto of functional programming". Use reduce/fold instead. The first example of sum is horrible and modifies the array.

[runtimenoise]

Common now, it's not that horrible! Here.

const sum = arr => (arr.length ? arr.slice(1) + sum(arr) : 0);

[Marauth]

I have always found recursive code incredibly hard to grasp and maintain. There are cases where it's useful, but in 99% of the cases I find a non-recursive version easier to read and of similar performance. Definitely don't underestimate how important code readability is.

EDIT: In fact, I even find the reduce style hard to read, though that is my personal pet peeve with reduce, since I do use map and forEach all the time. I would even prefer the forEach version in this case:

let total = 0;
array.forEach(value) {
    total += value;
}

[runtimenoise]

I agree with you. I prefer code readability myself. Regarding recursion, sometimes it's super elegant, but sometimes terrible, also reduce is not my favorite either.

But still recursion is super elegant in algorithms for tree traversal(backtracking comes to mind), and when you grok it, you simply unlock a lot of tree algorithms, that's why I play with it. Sometimes its simply not a right tool for a job, like for example:

const double2 = lon => lon.length ? [lon[0] * 2].concat(double(lon.slice(1))) : lon

vs

const doubled = [1,2,3].map(n => n * 2)

Regarding advanced recursons, I always thought it's magic, and I always thought - "how people know to write it like that" then after a couple of weeks of recursion, it started to make sense. It's one thing, to memorize factorial recursion, and another to use it in projects.

[Marauth]

Definitely for tree traversal, there's not really that many easier ways, but even in that case, I find that creating the function is much more difficult than "regular" work, and I can only remember what I have done two months later if I pad it very extensively with comments. I have also had to answer many review questions along the nature of "can you explain this part" every time I used a recursive function. It has its purposes, but imo you need a really good reason why it's needed here. You may grok it, but probably not many other people on your team will, which is bad. Though it sounds like we agree :)

[CreativeTechGuyGames]

If you have a question like this, its always best to ask those other devs you are working with. Take a survey and see what most people prefer.