markusjohnsson
commented
4 years ago As promised, here is a script which demonstrates that similar code for different libraries behaves the same, and only iterator-helpers differ:
require('core-js/proposals/iterator-helpers');
const items = [
{ type: "animal", subtype: "dog", name: "Rufus" },
{ type: "animal", subtype: "cat", name: "Whiskers" },
{ type: "automobile", subtype: "car", name: "Volvo" },
{ type: "automobile", subtype: "car", name: "Saab" },
];
(function () {
console.log("=== Array ===");
const animals = items.filter(i => i.type == "animal");
const dogs = animals.filter(a => a.subtype == "dog");
const cats = animals.filter(a => a.subtype == "cat");
for (let d of dogs)
console.log(d.name);
for (let d of cats)
console.log(d.name);
})();
(function () {
console.log("=== immutable js ===");
const { List } = require('immutable');
const animals = List(items).filter(i => i.type == "animal");
const dogs = animals.filter(a => a.subtype == "dog");
const cats = animals.filter(a => a.subtype == "cat");
for (let d of dogs)
console.log(d.name);
for (let d of cats)
console.log(d.name);
})();
(function () {
console.log("=== underscore ===");
const _ = require('underscore');
const animals = _.chain(items).filter(i => i.type == "animal");
const dogs = animals.filter(a => a.subtype == "dog");
const cats = animals.filter(a => a.subtype == "cat");
for (let d of dogs.value())
console.log(d.name);
for (let d of cats.value())
console.log(d.name);
})();
(function () {
console.log("=== lodash ===");
const _ = require('lodash');
const animals = _.chain(items).filter(i => i.type == "animal");
const dogs = animals.filter(a => a.subtype == "dog");
const cats = animals.filter(a => a.subtype == "cat");
for (let d of dogs.value())
console.log(d.name);
for (let d of cats.value())
console.log(d.name);
})();
(function () {
console.log("=== linq ===");
const Enumerable = require('linq');
const animals = Enumerable.from(items).where(i => i.type == "animal");
const dogs = animals.where(a => a.subtype == "dog");
const cats = animals.where(a => a.subtype == "cat");
for (let d of dogs)
console.log(d.name);
for (let d of cats)
console.log(d.name);
})();
(function () {
console.log("=== ix ===");
const { from } = require('ix/iterable');
const { filter } = require('ix/iterable/operators');
const animals = from(items).pipe(filter(i => i.type == "animal"));
const dogs = animals.pipe(filter(a => a.subtype == "dog"));
const cats = animals.pipe(filter(a => a.subtype == "cat"));
for (let d of dogs)
console.log(d.name);
for (let d of cats)
console.log(d.name);
})();
(function () {
console.log("=== iterator-helpers ===");
const animals = Iterator.from(items).filter(i => i.type == "animal");
const dogs = animals.filter(a => a.subtype == "dog");
const cats = animals.filter(a => a.subtype == "cat");
for (let d of dogs)
console.log(d.name);
for (let d of cats)
console.log(d.name);
})();
Output:
=== Array ===
Rufus
Whiskers
=== immutable js ===
Rufus
Whiskers
=== underscore ===
Rufus
Whiskers
=== lodash ===
Rufus
Whiskers
=== linq ===
Rufus
Whiskers
=== ix ===
Rufus
Whiskers
=== iterator-helpers ===
Rufus
devsnek
senocular
ljharb
peter-leonov
I have used a lot of different tools to achieve this functionality and I was very happy to see this proposal to include such functionality by default.
However, I am worried that porting projects to use this functionality will cause a lot of bugs, since there is a fundamental difference from how other libraries behave.
The main issue I see is with simple code like this:
It will behave differently whether
itemsis an Array or an Iterator. If Array, then both loops will log results; we would have successfully created one sequence of dogs and one of cats. However, if Iterator, then only dogs will get listed, because the animals Iterator will be consumed during the iteration of dogs and no cats will be listed.Moreover, it is not only Array semantics that this diverges from. The semantics of Array are the same as those for a number of popular js libraries:
I will post a demonstrative script for those libraries as a follow up.
Workarounds
Some workarounds without external libraries exist:
toArray()on intermediate sequences (animalsabove). Cons: not lazy, causing allocations that should not be needed.I think this is a much needed feature for JavaScript, however I am worried that the current spec will cause bugs and headaches and prevent a proper solution further on.