Collections Deep Equal
util.isDeepStrictEqual()) instead of reference equality
const object = name: "Leandro" age: 29 ;const deepEqualObject = name: "Leandro" age: 29 ;;;assert;const map = ;map;;;const set = ;set;;;
One the one hand, this is good, because
deepEqualObject really aren’t the same object. We may, for example, modify
deepEqualObject would no longer be deep equal to it:
objectage = 30;assert;;;
Collections Deep Equal provides
;const object = name: "Leandro" age: 29 ;const deepEqualObject = name: "Leandro" age: 29 ;const mapDeepEqual = ;mapDeepEqual;;;const setDeepEqual = ;setDeepEqual;;;
$ npm install collections-deep-equal
The package comes with type definitions for TypeScript.
Collections Deep Equal hasn’t been benchmarked, but it probably is orders of magnitude slower than the native collections, because for every access it iterates over all keys and calls
deepEqual() on them. It’s a straightforward, if naive, implementation.
If you mutate objects, then the collections using them change as well:
const object = name: "Leandro" age: 29 ;const deepEqualObject = name: "Leandro" age: 29 ;const mapDeepEqual = ;mapDeepEqual;objectage = 30;;deepEqualObjectage = 30;;
People Discussing the Issue
Other Libraries That Implementation Alternative Collections
The advantages of Collections Deep Equal over these libraries are:
You don’t have to buy into completely new data structures like Immutable.js’s Records. These other data structures may have different APIs and therefore a bit of a learning curve; they may be more difficult to inspect in debuggers; they may not work well with other libraries, forcing you to convert back and forth; and they may annoying to use in TypeScript.
The notion of equality is determined by the data structures, not by the elements. In most of these libraries, elements are forced to implement
hash(), which makes sense in a object-oriented style, but not in a functional style.
Immutability is possible and encouraged, but not enforced. For better and for worse.
Collections Deep Equal is so simple that you could maintain it yourself if it’s abandoned, like some of the packages above seem to have been. But don’t worry, Collections Deep Equal is being used in my dissertation, so it’ll stick around.
Other Approaches to Immutability
These libraries don’t provide new data structures. They’re just facilitating the use of immutable data structures, which may pave the way to a new notion of equality.
Very Similar But Incomplete Approaches
These libraries are very similar to Collections Deep Equal in spirit, but their implementations are either incomplete, or they lack type definitions, and so forth.