@mark1russell7/collections 0.9.1 → 0.9.3

package/build/summary-tree/index.d.ts

@@ -0,0 +1,2 @@
+import { C as split, D as toArray, E as summaryOf, S as splice, T as summary, _ as remove, a as SummarySpec, b as size, c as at, d as insert, f as isEmpty, g as prepend, h as of, i as SummarySearch, l as concat, m as locate, n as SummaryMonoid, o as SummaryTreeRecord, p as leaves, r as SummaryNode, s as append, t as SummaryLocation, u as height, v as search, w as splitAt, x as slice, y as set } from "../functions.js";
+export { SummaryLocation, SummaryMonoid, SummaryNode, SummarySearch, SummarySpec, SummaryTreeRecord, append, at, concat, height, insert, isEmpty, leaves, locate, of, prepend, remove, search, set, size, slice, splice, split, splitAt, summary, summaryOf, toArray };

package/build/summary-tree/index.js

@@ -0,0 +1 @@
+export { t as append, n as at, r as concat, i as height, a as insert, o as isEmpty, s as leaves, c as locate, l as of, u as prepend, d as remove, f as search, p as set, m as size, h as slice, g as splice, _ as split, v as splitAt, y as summary, b as summaryOf, x as toArray } from "../functions.js";

package/package.json

@@ -1,7 +1,7 @@
 {
   "$schema": "https://json.schemastore.org/package",
   "name": "@mark1russell7/collections",
-  "version": "0.9.1",
+  "version": "0.9.3",
   "description": "Collections with no dependencies: lists, maps, queues, a summary tree, channels, lazy operations and dependency graphs.",
   "keywords": [
     "collections",
@@ -47,6 +47,10 @@
       "types": "./build/core/layers.d.ts",
       "default": "./build/core/layers.js"
     },
+    "./summary-tree": {
+      "types": "./build/summary-tree/index.d.ts",
+      "default": "./build/summary-tree/index.js"
+    },
     "./testing": {
       "types": "./build/testing/index.d.ts",
       "default": "./build/testing/index.js"

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;
   }
 
   /**