@mark1russell7/collections 0.9.0 → 0.9.2

package/package.json

@@ -1,7 +1,7 @@
 {
   "$schema": "https://json.schemastore.org/package",
   "name": "@mark1russell7/collections",
-  "version": "0.9.0",
+  "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/async/channels.ts

@@ -27,6 +27,8 @@ import { asyncQueue, type AsyncQueue } from "./async-queue.js";
  *
  * The channels of Go are the model. This class gives send/receive operations
  * that can block until the other side is ready.
+ *
+ * @deprecated Import `Channel` from `@mark1russell7/service/channel`. The next MINOR version of collections removes it.
  */
 export class Channel<T> {
   private queue: AsyncQueue<T>;
@@ -140,6 +142,8 @@ export class Channel<T> {
 
 /**
  * SelectCase represents a case in a select statement.
+ *
+ * @deprecated Import `SelectCase` from `@mark1russell7/service/channel`. The next MINOR version of collections removes it.
  */
 export interface SelectCase<R> {
   channel: Channel<any>;
@@ -212,6 +216,8 @@ function firstOf(waits: readonly Wait[]): Promise<{ index: number; value: unknow
  *   ch2.case((v) => `ch2: ${v}`),
  *   timeout(1000).case(() => 'timeout')
  * )
+ *
+ * @deprecated Import `select` from `@mark1russell7/service/channel`. The next MINOR version of collections removes it.
  */
 export async function select<R>(...cases: SelectCase<R>[]): Promise<R> {
   const { index, value } = await firstOf(
@@ -229,6 +235,8 @@ export async function select<R>(...cases: SelectCase<R>[]): Promise<R> {
  *   dataChannel.case((v) => v),
  *   timeout(5000).case(() => 'timeout!')
  * )
+ *
+ * @deprecated Import `timeout` from `@mark1russell7/service/channel`. The next MINOR version of collections removes it.
  */
 export function timeout(ms: number): Channel<void> {
   const ch = new Channel<void>();
@@ -247,6 +255,8 @@ export function timeout(ms: number): Channel<void> {
  * for await (const t of tick) {
  *   console.log('Tick:', t)
  * }
+ *
+ * @deprecated Import `ticker` from `@mark1russell7/service/channel`. The next MINOR version of collections removes it.
  */
 export function ticker(ms: number): Channel<number> & { stop: () => void } {
   const ch = new Channel<number>(1);
@@ -273,6 +283,8 @@ export function ticker(ms: number): Channel<number> & { stop: () => void } {
  *
  * await input.send(5)
  * const result = await output.receive() // 10
+ *
+ * @deprecated Import `pipeline` from `@mark1russell7/service/channel`. The next MINOR version of collections removes it.
  */
 export function pipeline<T, U>(
   input: Channel<T>,
@@ -305,6 +317,8 @@ export function pipeline<T, U>(
  * const [out1, out2, out3] = fanOut(input, 3)
  *
  * // Each output gets a copy of every input value
+ *
+ * @deprecated Import `fanOut` from `@mark1russell7/service/channel`. The next MINOR version of collections removes it.
  */
 export function fanOut<T>(input: Channel<T>, count: number, bufferSize: number = 0): Channel<T>[] {
   const outputs = Array.from({ length: count }, () => new Channel<T>(bufferSize));
@@ -331,6 +345,8 @@ export function fanOut<T>(input: Channel<T>, count: number, bufferSize: number =
  * const merged = fanIn(ch1, ch2)
  *
  * // merged receives values from both ch1 and ch2
+ *
+ * @deprecated Import `fanIn` from `@mark1russell7/service/channel`. The next MINOR version of collections removes it.
  */
 export function fanIn<T>(...inputs: Channel<T>[]): Channel<T> {
   const output = new Channel<T>();
@@ -356,6 +372,8 @@ export function fanIn<T>(...inputs: Channel<T>[]): Channel<T> {
  * It takes one value at a time, from the inputs in turn. It keeps no receive on an input while
  * it waits for the reader of the output. Thus each value of each input reaches the output one
  * time, in the order of its input, or stays in its input.
+ *
+ * @deprecated Import `merge` from `@mark1russell7/service/channel`. The next MINOR version of collections removes it.
  */
 export function merge<T>(...inputs: Channel<T>[]): Channel<T> {
   const output = new Channel<T>();
@@ -389,6 +407,8 @@ export function merge<T>(...inputs: Channel<T>[]): Channel<T> {
 
 /**
  * Buffered channel with specified capacity.
+ *
+ * @deprecated Import `buffered` from `@mark1russell7/service/channel`. The next MINOR version of collections removes it.
  */
 export function buffered<T>(capacity: number): Channel<T> {
   return new Channel<T>(capacity);
@@ -397,6 +417,8 @@ export function buffered<T>(capacity: number): Channel<T> {
 /**
  * Unbuffered channel (rendezvous point).
  * Sends block until receiver is ready.
+ *
+ * @deprecated Import `unbuffered` from `@mark1russell7/service/channel`. The next MINOR version of collections removes it.
  */
 export function unbuffered<T>(): Channel<T> {
   return new Channel<T>(0);
@@ -408,6 +430,8 @@ export function unbuffered<T>(): Channel<T> {
  * @example
  * const ch = channel<number>()
  * const bufferedCh = channel<string>(10)
+ *
+ * @deprecated Import `channel` from `@mark1russell7/service/channel`. The next MINOR version of collections removes it.
  */
 export function channel<T>(bufferSize: number = 0): Channel<T> {
   return new Channel<T>(bufferSize);
@@ -424,6 +448,8 @@ export function channel<T>(bufferSize: number = 0): Channel<T> {
  * )
  *
  * // 4 workers concurrently process jobs from jobChannel
+ *
+ * @deprecated Import `workerPool` from `@mark1russell7/service/channel`. The next MINOR version of collections removes it.
  */
 export function workerPool<T, R>(
   jobs: Channel<T>,

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)) {