@mark1russell7/collections 0.7.0 → 0.7.2

package/build/layers.d.ts

@@ -24,7 +24,9 @@ type InnerOf<L> = L extends ((next: infer I) => any) ? I : never;
 type OuterOf<L> = L extends ((next: any) => infer O) ? O : never;
 /**
  * This type checks each neighbor pair of a list of layers. The result of the inner neighbor must
- * fit the input of the outer neighbor. At the first bad pair, the compiler marks that argument.
+ * fit the input of the outer neighbor. A bad pair makes the compiler refuse the call. The compiler
+ * marks the first argument, not the bad pair. Its message shows the type that the first bad pair
+ * needs. At the place of the inner neighbor, it needs a layer that gives the input of the outer one.
  *
  * The type is tail recursive, so the compiler accepts a chain of 100 layers.
  */

package/build/layers.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"layers.d.ts","names":[],"sources":["../src/core/layers.ts"],"mappings":";;;;;;;;;;;;;;;;;;;KAoBY,MAAM,aAAa,QAAQ,UAAU,MAAM,UAAU;;KAGrD,QAAQ,KAAK,YAAW,YAAY,aAAY;;KAGhD,QAAQ,KAAK,YAAW,oBAAoB,KAAI;;;;;;;KAQhD,MAAM,8BAA8B,iDAC9C,0BAA0B,SAAS,YAAY,MAC1C,QAAQ,aAAa,QAAQ,MAC5B,gBAAgB,MAAM,iBAAiB,MAAM,mBAChC,MAAM,GAAG,WAAW,QAAQ,QAAQ,kBACtC,SAAS;;;;;;KAOhB,SAAS,gCACnB,yBACK,GAAG,MAAM,MAAM,IAChB,0BAA0B,uBACxB,wCAAwC,SACrC,MAAM,QAAQ,UAAU,QAAQ,iBAEnC,0BAA0B,QACvB,MAAM,QAAQ,OAAO,QAAQ;;KAI5B,OAAO,8BAA8B,iBAC/C,0BAA0B,gBAAgB,QAAQ,OAAO,MAAM,MAAM,QAAQ,UAAU;;;;;KAM7E,QAAQ,gCAClB,wCAAwC,SACnC,MAAM,QAAQ,UAAU,OAAO,KAAK,QAAQ,QAC7C,SAAS;;;;;;;;;;;;;iBAcC,cAAc,mBAAmB,YAAY,QAAQ,IAAI,MAAM,KAAK,SAAS"}
+{"version":3,"file":"layers.d.ts","names":[],"sources":["../src/core/layers.ts"],"mappings":";;;;;;;;;;;;;;;;;;;KAoBY,MAAM,aAAa,QAAQ,UAAU,MAAM,UAAU;;KAGrD,QAAQ,KAAK,YAAW,YAAY,aAAY;;KAGhD,QAAQ,KAAK,YAAW,oBAAoB,KAAI;;;;;;;;;KAUhD,MAAM,8BAA8B,iDAC9C,0BAA0B,SAAS,YAAY,MAC1C,QAAQ,aAAa,QAAQ,MAC5B,gBAAgB,MAAM,iBAAiB,MAAM,mBAChC,MAAM,GAAG,WAAW,QAAQ,QAAQ,kBACtC,SAAS;;;;;;KAOhB,SAAS,gCACnB,yBACK,GAAG,MAAM,MAAM,IAChB,0BAA0B,uBACxB,wCAAwC,SACrC,MAAM,QAAQ,UAAU,QAAQ,iBAEnC,0BAA0B,QACvB,MAAM,QAAQ,OAAO,QAAQ;;KAI5B,OAAO,8BAA8B,iBAC/C,0BAA0B,gBAAgB,QAAQ,OAAO,MAAM,MAAM,QAAQ,UAAU;;;;;KAM7E,QAAQ,gCAClB,wCAAwC,SACnC,MAAM,QAAQ,UAAU,OAAO,KAAK,QAAQ,QAC7C,SAAS;;;;;;;;;;;;;iBAcC,cAAc,mBAAmB,YAAY,QAAQ,IAAI,MAAM,KAAK,SAAS"}

package/package.json

@@ -1,7 +1,7 @@
 {
   "$schema": "https://json.schemastore.org/package",
   "name": "@mark1russell7/collections",
-  "version": "0.7.0",
+  "version": "0.7.2",
   "description": "Collections with no dependencies: lists, maps, queues, a summary tree, channels, lazy operations and dependency graphs.",
   "keywords": [
     "collections",
@@ -71,6 +71,7 @@
     "@mark1russell7/rigor-bench": "^0.2.5",
     "@mark1russell7/rigor-generators": "^0.1.5",
     "@mark1russell7/rigor-statistics": "^0.1.8",
+    "@mark1russell7/rigor-testkit": "^0.1.0",
     "@types/node": "^26.6.5",
     "esbuild": "^0.28.2",
     "fast-check": "^4.10.2",

package/src/behaviors/readonly.ts

@@ -84,6 +84,30 @@ const MUTATING_METHODS = new Set([
   "compute",
   "merge",
   "putAll",
+
+  // Queue changes that give undefined on an empty queue (C27: a readonly view removed an element)
+  "pollOrUndefined",
+
+  // 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",
+  "trimToSize",
+  "grow",
+  "resize",
+  "removeAtOffset",
+  "unlinkNode",
+  "heapify",
+  "bubbleUp",
+  "bubbleDown",
+  "addToEnd",
+  "moveToEnd",
+  "removeFromBucket",
+  "removeFromList",
+  "deleteNode",
+  "fixAfterInsertion",
+  "fixAfterDeletion",
+  "rotateLeft",
+  "rotateRight",
 ]);
 
 /** Methods that return a view of the collection: the view is readonly too. */

package/src/core/layers.ts

@@ -28,7 +28,9 @@ export type OuterOf<L> = L extends (next: any) => infer O ? O : never;
 
 /**
  * This type checks each neighbor pair of a list of layers. The result of the inner neighbor must
- * fit the input of the outer neighbor. At the first bad pair, the compiler marks that argument.
+ * fit the input of the outer neighbor. A bad pair makes the compiler refuse the call. The compiler
+ * marks the first argument, not the bad pair. Its message shows the type that the first bad pair
+ * needs. At the place of the inner neighbor, it needs a layer that gives the input of the outer one.
  *
  * The type is tail recursive, so the compiler accepts a chain of 100 layers.
  */

package/src/dag/executor.ts

@@ -71,9 +71,11 @@ function notify<T>(name: string, listener: ((arg: T) => void) | undefined, arg:
  * With `skipDependents` (the default), a node whose dependency failed or was skipped does not start. Its result has
  * `skipped: true` and an error that names those dependencies. A dependency outside the DAG does not count.
  *
- * `failFast` operates at level granularity. When a node in a level fails, each
- * node already in flight in that level continues to completion. No later level
- * starts. (There is no mid-level cancellation.)
+ * `failFast` operates on levels. When a node of a level fails, each node of that level continues to its end.
+ * This includes the nodes that did not start before the failure, when `concurrency` is less than the
+ * size of the level. No later level starts. The run does not cancel a node.
+ *
+ * A node that did not start (`skipped: true`) calls neither `onNodeStart` nor `onNodeComplete`.
  */
 export async function executeDAG<TNode extends DAGNode>(
   dag: DependencyDAG<TNode>,

package/src/dag/types.ts

@@ -39,7 +39,10 @@ export interface DependencyDAG<TNode extends DAGNode = DAGNode> {
 export interface DAGExecutionOptions<TNode extends DAGNode = DAGNode> {
   /** Max parallel operations per level (default: 4) */
   concurrency?: number;
-  /** When this value is true, the run stops on the first error. The default is true. */
+  /**
+   * When this value is true, no level starts after a level with a failure. The default is true.
+   * Each node of the level with the failure runs, also a node that did not start before the failure.
+   */
   failFast?: boolean;
   /**
    * When this value is true, a node whose dependency failed or was skipped does not start. Its result has `skipped: true`.

package/src/fx/iter.ts

@@ -7,9 +7,9 @@
  * @example
  * const result = pipe(
  *   [1, 2, 3, 4, 5],
- *   map(x => x * 2),
- *   filter(x => x > 5),
- *   take(2),
+ *   (it) => map(it, x => x * 2),
+ *   (it) => filter(it, x => x > 5),
+ *   (it) => take(it, 2),
  *   toArray
  * ) // [6, 8]
  */
@@ -76,13 +76,14 @@ export function* flatten<T>(iterable: Iterable<Iterable<T>>): Generator<T> {
 // ============================================================================
 
 /**
- * This function takes the first n elements.
+ * This function takes the first n elements. It reads no element after the n-th one, and it reads nothing when n is 0.
  */
 export function* take<T>(iterable: Iterable<T>, n: number): Generator<T> {
+  if (n <= 0) return;
   let count = 0;
   for (const value of iterable) {
-    if (count++ >= n) break;
     yield value;
+    if (++count >= n) return;
   }
 }
 

package/src/interfaces/list.ts

@@ -43,10 +43,9 @@ export interface ReadonlyList<T> extends ReadonlyCollection<T> {
   lastIndexOf(element: T, fromIndex?: number): number;
 
   /**
-   * This method gives a view of the portion of this list between fromIndex (inclusive)
-   * and toIndex (exclusive).
+   * This method gives a new list with the elements from fromIndex (inclusive) to toIndex (exclusive).
    *
-   * Changes to the sublist are reflected in the original list.
+   * The new list is a copy, not a view. A change to one list does not change the other list.
    *
    * @param fromIndex Start index (inclusive)
    * @param toIndex End index (exclusive)
@@ -135,7 +134,8 @@ export interface List<T> extends ReadonlyList<T>, Collection<T> {
   reverse(): void;
 
   /**
-   * This method gives a mutable sublist view.
+   * This method gives a new mutable list with the elements from fromIndex (inclusive) to toIndex (exclusive).
+   * The new list is a copy, not a view.
    *
    * @param fromIndex Start index (inclusive)
    * @param toIndex End index (exclusive)