In this example it is, but a nice thing about using map, reduce etc is that you can chain them together, ex:

  let out = ["a", "b", "c", 1, 2, 3]
  	// Turn letters to upper case
  	.map(i => {
  		return typeof i === "string"
  			? i.toUpperCase()
  			: i;
  	})
  	// Add one to numbers
  	.map(i => {
  		return typeof i === "number"
  			? i + 1
  			: i;
  	})
  	// split letters and numbers up
  	.reduce((all, i) => { 
  		typeof i === "string"
  			? all.letters.push(i)
  			: all.numbers.push(i);
  		return all;
  	}, { "letters": [], "numbers": [] });
  // => { letters: ["A", "B", "C"], numbers: [2, 3, 4] }

The problem with this is that it generates two intermediate arrays in the maps, then effectively drops them in the reduce. This may be inefficient.

I wish that JavaScript's map/filter/reduce functions returned lazy iterators, like in Rust, so that code like this doesn't produce intermediate arrays. Does anyone know of a library that provides this?

Those intermediate iterations could be dropped by composing the map functions together (same with the reduce), if that really was a performance bottleneck.

With lazy iterators, there is the possibility of better composition of maps/filters/reduces. That's why I'm a fan of the lazy iterators approach -- otherwise the abstraction breaks too easily and it ends up looking like a for-loop anyway.

Or... you can do all of that in a 4-line loop, without any of the harm to readability or additional code-bloat that's especially important for websites.

That's the thing about functional programming. I personally don't remember the last time I had the need to write a foreach loop. Foreach loops even kind of feel _dirty_ to me.

All I really need now is Array.map, Array.reduce, Array.filter, Array.sort, Object.keys, Object.values.

Reduce is very powerful, you just have to get to know it.

Edit: this is how I'd use reduce in this case — https://news.ycombinator.com/item?id=14919636 — talk about line numbers

> isn't this almost the same as just doing a foreach loop

yes they are both ways of iterating over the array

> I don't understand why doing this

there's more than one way to skin a cat

foreach implies mutation. reduce is a way to aggregate a collection into single result in an immutable way.