Currently, if we need to do reduce or forEach on iterable or iterator, would we just have to polyfill it? - ecmascript-6

Question

First of all, does it'd make sense to have some array methods such as reduce or forEach also for iterables and iterators? Is it true that to use them and not wanting to blow up an array of a huge size, we just have to polyfill them for now?

Answer 1

Edit
What you propose is being worked on. There is a proposal at stage 2 of the TC39 process for adding a whole bunch of helper methods to the iterator prototype (so they'd be usable by collections) and the proposal includes the two you mention .forEach() and .reduce() along with a dozen others.
I don't yet fully understand how this is supposed to work because the spec talks about iterator helpers, but then shows using .reduce() on an actual Set instance directly, just like you would use it on an array. So, maybe the helpers are used by each class to implement their own method of that name. Since you typically want to reduce a collection, not reduce an iterator, that would make some sense. The iterator is just a tool used in the reduction of the collection, not the collection itself.
They redefine the .reduce() callback to only pass the accumulator and value (no index, no object). FYI, I discovered this by looking at the very end of https://node.green/. So, it is being worked on and since there is a proposed standard, you could polyfill it and you can find sample implementations for tons of proposed new iterator methods here.
Here's a polyfill for the proposed Set.prototype.reduce() and Map.prototype.reduce():
(function() {
if (!Set.prototype.reduce) {
Object.defineProperty(Set.prototype, "reduce", {value: reduce});
}
if (!Map.prototype.reduce) {
Object.defineProperty(Map.prototype, "reduce", {value: reduce});
}
function reduce(fn, initialValue) {
if (typeof fn !== "function") {
throw new TypeError("2nd argument to reduce must be function");
}
let noInitial = arguments.length < 2;
let accumulator = initialValue;
for (let [key, value] of this.entries()) {
// if no initial value, get it from the first value
if (noInitial) {
accumulator = value;
noInitial = false;
} else {
accumulator = fn(accumulator, key, value);
}
}
// if there was nothing to iterate and initialValue was not passed
// spec says this should be a TypeError
if (noInitial) {
throw new TypeError("iterable was empty and initalValue not passed")
}
return accumulator;
}
})();
// demo code
let s = new Set([1,2,3,4,5,6]);
let sum = s.reduce((total, val) => {
return total += val;
}, 0);
console.log(`Set Total = ${sum}`);
let m = new Map([['one',1],['two',2],['three',3],['four',4]]);
let sum2 = m.reduce((total, key, val) => {
return total += val;
}, 0);
console.log(`Map Total = ${sum2}`);
I have not quite figured out how a .reduce() method on a base Iterator class automatically makes it so that set.reduce() or map.reduce() will "just work". I'm not sure it does. I'm thinking that each class still has to wire up it's own .reduce() method, but it can use the helper implementation on the Iterator object to do so. Perhaps that's why they are called "helpers". They're just common functions that can be used to wire up your own top level method.
They can probably still be accessed on an iterator directly, but that doesn't seem how you would typically use them.
Original answer...
You do not really need forEach() because you can just use for/of on any iterable. So, if you really wanted forEach(), you would have to implement it yourself. I wouldn't call it a polyfill because there is no standard you're trying to fill-in for. As such, it would be better to make it a stand-alone function, not pollute the prototype in a non-standard way.
There are certainly some arguments for having a reduce() like function that works with an iterable if you're just trying to iterate and collect some single value from the iteration. Again, since there is no standard implementation for all iterables, you'd have to implement your own function that works with any iterable.
One problem with implementing reduce() for any arbitrary iterable is that Array.prototype.reduce() passes an index to the callback. This somewhat assumes that there is access by that index like an array has. But, some collections that have are an iterable do not have access by index. You could still create an index during the iteration and pass it to the callback as just a counter, but it could not necessarily be used the way the index is used when doing someArray.reduce().
Here's an implementation of reduce() that works on any iterable. For reference here's the spec for Array.prototype.reduce() which works off indexed access, not off an iterable which is why it can't be used directly on any iterable, but can be used on any Array-like object.
let s = new Set([1,2,3,4,5,6]);
function reduce(iterable, fn, initialValue) {
if (typeof fn !== "function") {
throw new TypeError("2nd argument to reduce must be function");
}
let initialValuePresent = arguments.length >= 3;
let accumulator = initialValue;
let cntr= 0;
for (let item of iterable) {
// if no initial value, get it from the first value
if (cntr === 0 && !initialValuePresent) {
accumulator = item;
} else {
accumulator = fn(accumulator, item, cntr, iterable);
}
++cntr;
}
// if there was nothing to iterate and initialValue was not passed
// spec says this should be a TypeError
if (cntr === 0 && !initialValuePresent) {
throw new TypeError("iterable was empty and initalValue not passed")
}
return accumulator;
}
let sum = reduce(s, (total, item, cntr, obj) => {
return total += item;
}, 0);
console.log(`Total = ${sum}`);