@mark1russell7/collections 0.9.1 → 0.9.2

package/package.json

@@ -1,7 +1,7 @@
 {
   "$schema": "https://json.schemastore.org/package",
   "name": "@mark1russell7/collections",
-  "version": "0.9.1",
+  "version": "0.9.2",
   "description": "Collections with no dependencies: lists, maps, queues, a summary tree, channels, lazy operations and dependency graphs.",
   "keywords": [
     "collections",

package/src/behaviors/readonly.ts

@@ -88,6 +88,9 @@ const MUTATING_METHODS = new Set([
   // Queue changes that give undefined on an empty queue (C27: a readonly view removed an element)
   "pollOrUndefined",
 
+  // The removal by a test of LRUCache (C31: a readonly view of an LRU cache emptied it)
+  "deleteWhere",
+
   // The internal changes of the structures of this package. TypeScript marks them private, but a call at run
   // time reaches them. `readonly.test.ts` puts each method of each structure in the reads or in this list.
   "ensureCapacity",
@@ -108,6 +111,9 @@ const MUTATING_METHODS = new Set([
   "fixAfterDeletion",
   "rotateLeft",
   "rotateRight",
+  "moveToHead",
+  "removeNode",
+  "evictLRU",
 ]);
 
 /** Methods that return a view of the collection: the view is readonly too. */

package/src/impl/hash-set.ts

@@ -63,6 +63,7 @@ export interface HashSetOptions<T> {
 export class HashSet<T> implements Set<T> {
   private readonly _map: HashMap<T, symbol>;
   private readonly _eq: Eq<T>;
+  private readonly _hash: Hash<T>;
 
   constructor(options: HashSetOptions<T> = {}) {
     const {
@@ -73,6 +74,7 @@ export class HashSet<T> implements Set<T> {
     } = options;
 
     this._eq = eq;
+    this._hash = hash;
     this._map = new HashMap<T, symbol>({
       initialCapacity,
       loadFactor,
@@ -140,18 +142,11 @@ export class HashSet<T> implements Set<T> {
   }
 
   retainAll(other: Iterable<T>): boolean {
-    const toRetain = new globalThis.Set(other);
+    const toRetain = this.setOf(other);
     const toRemove: T[] = [];
 
     for (const element of this) {
-      let shouldRetain = false;
-      for (const retainElement of toRetain) {
-        if (this._eq(element, retainElement)) {
-          shouldRetain = true;
-          break;
-        }
-      }
-      if (!shouldRetain) {
+      if (!toRetain.contains(element)) {
         toRemove.push(element);
       }
     }
@@ -197,13 +192,12 @@ export class HashSet<T> implements Set<T> {
    * The new set contains only elements present in both sets.
    */
   intersection(other: Iterable<T>): HashSet<T> {
-    const result = new HashSet<T>({ eq: this._eq });
+    // The loop reads `other` one time, so a generator gives all of its elements
+    const others = this.setOf(other);
+    const result = this.empty();
     for (const element of this) {
-      for (const otherElement of other) {
-        if (this._eq(element, otherElement)) {
-          result.add(element);
-          break;
-        }
+      if (others.contains(element)) {
+        result.add(element);
       }
     }
     return result;
@@ -224,8 +218,10 @@ export class HashSet<T> implements Set<T> {
    * The new set contains elements in either set but not in both.
    */
   symmetricDifference(other: Iterable<T>): HashSet<T> {
-    const result = this.union(other);
-    const inter = this.intersection(other);
+    // The union and the intersection each read `other`, so read it one time first
+    const others = this.setOf(other);
+    const result = this.union(others);
+    const inter = this.intersection(others);
     result.removeAll(inter);
     return result;
   }
@@ -235,8 +231,7 @@ export class HashSet<T> implements Set<T> {
    * All elements in this set are also in the other set.
    */
   isSubsetOf(other: Iterable<T>): boolean {
-    const otherSet = new HashSet<T>({ eq: this._eq });
-    otherSet.addAll(other);
+    const otherSet = this.setOf(other);
 
     for (const element of this) {
       if (!otherSet.contains(element)) {
@@ -300,9 +295,22 @@ export class HashSet<T> implements Set<T> {
    * This method makes a shallow copy of this set.
    */
   clone(): HashSet<T> {
-    const clone = new HashSet<T>({ eq: this._eq });
-    clone.addAll(this);
-    return clone;
+    return this.setOf(this);
+  }
+
+  /**
+   * This method makes an empty set with the equality and the hash function of this set.
+   * Before, the inner sets kept only the equality, so they did not find an element with a custom hash.
+   */
+  private empty(): HashSet<T> {
+    return new HashSet<T>({ eq: this._eq, hash: this._hash });
+  }
+
+  /** This method makes a set of the elements, with the equality and the hash function of this set. */
+  private setOf(elements: Iterable<T>): HashSet<T> {
+    const set = this.empty();
+    set.addAll(elements);
+    return set;
   }
 
   /**

package/src/impl/tree-set.ts

@@ -160,10 +160,7 @@ export class TreeSet<T> implements NavigableSet<T> {
   }
 
   retainAll(elements: Iterable<T>): boolean {
-    const toRetain = new Set<T>();
-    for (const element of elements) {
-      toRetain.add(element);
-    }
+    const toRetain = this.setOf(elements);
 
     let modified = false;
     for (const element of Array.from(this)) {
@@ -201,10 +198,7 @@ export class TreeSet<T> implements NavigableSet<T> {
       eq: this._eq,
     });
 
-    const otherSet = new Set<T>();
-    for (const element of other) {
-      otherSet.add(element);
-    }
+    const otherSet = this.setOf(other);
 
     for (const element of this) {
       if (otherSet.has(element)) {
@@ -221,10 +215,7 @@ export class TreeSet<T> implements NavigableSet<T> {
       eq: this._eq,
     });
 
-    const otherSet = new Set<T>();
-    for (const element of other) {
-      otherSet.add(element);
-    }
+    const otherSet = this.setOf(other);
 
     for (const element of this) {
       if (!otherSet.has(element)) {
@@ -246,8 +237,8 @@ export class TreeSet<T> implements NavigableSet<T> {
       result.add(element);
     }
 
-    // Toggle elements from other set
-    for (const element of other) {
+    // Toggle each element of the other set one time, so a repeated element does not toggle back
+    for (const element of this.setOf(other)) {
       if (result.has(element)) {
         result.remove(element);
       } else {
@@ -259,10 +250,7 @@ export class TreeSet<T> implements NavigableSet<T> {
   }
 
   isSubsetOf(other: Iterable<T>): boolean {
-    const otherSet = new Set<T>();
-    for (const element of other) {
-      otherSet.add(element);
-    }
+    const otherSet = this.setOf(other);
 
     for (const element of this) {
       if (!otherSet.has(element)) {
@@ -272,6 +260,18 @@ export class TreeSet<T> implements NavigableSet<T> {
     return true;
   }
 
+  /**
+   * This method makes a set of the elements, with the comparator and the equality of this set.
+   * Before, the set operations used a native `Set`, which compares with `===` and ignores the comparator.
+   */
+  private setOf(elements: Iterable<T>): TreeSet<T> {
+    const set = new TreeSet<T>({ compare: this._compare, eq: this._eq });
+    for (const element of elements) {
+      set.add(element);
+    }
+    return set;
+  }
+
   isSupersetOf(other: Iterable<T>): boolean {
     for (const element of other) {
       if (!this.has(element)) {