data-structure-typed 0.9.16 → 1.12.10

package/src/data-structures/graph/undirected-graph.ts

@@ -1,3 +1,7 @@
+/**
+ * @copyright 2030 Tyler Zeng <zrwusa@gmail.com>
+ * @license MIT
+ */
 import {arrayRemove} from '../../utils';
 import {AbstractEdge, AbstractGraph, AbstractVertex} from './abstract-graph';
 import type {VertexId} from '../types';
@@ -32,6 +36,14 @@ export class UndirectedGraph<V extends UndirectedVertex, E extends UndirectedEdg
         super();
     }
 
+    /**
+     * The function `getEdge` returns the first edge that connects two vertices, or null if no such edge exists.
+     * @param {V | null | VertexId} v1 - The parameter `v1` represents either a vertex object (`V`) or a vertex ID
+     * (`VertexId`). It can also be `null`.
+     * @param {V | null | VertexId} v2 - The parameter `v2` represents a vertex or vertex ID. It can be of type `V` (vertex
+     * object), `null`, or `VertexId` (vertex ID).
+     * @returns an edge (E) or null.
+     */
     getEdge(v1: V | null | VertexId, v2: V | null | VertexId): E | null {
         let edges: E[] | undefined = [];
 
@@ -47,6 +59,11 @@ export class UndirectedGraph<V extends UndirectedVertex, E extends UndirectedEdg
         return edges ? edges[0] || null : null;
     }
 
+    /**
+     * The function adds an edge to a graph by connecting two vertices.
+     * @param {E} edge - The `edge` parameter is an object of type `E`, which represents an edge in a graph.
+     * @returns a boolean value.
+     */
     addEdge(edge: E): boolean {
         for (const end of edge.vertices) {
             const endVertex = this.getVertex(end);
@@ -63,6 +80,13 @@ export class UndirectedGraph<V extends UndirectedVertex, E extends UndirectedEdg
         return true;
     }
 
+    /**
+     * The function removes an edge between two vertices in a graph and returns the removed edge, or null if either of the
+     * vertices does not exist.
+     * @param {V | VertexId} v1 - The parameter `v1` represents either a vertex object (`V`) or a vertex ID (`VertexId`).
+     * @param {V | VertexId} v2 - V | VertexId: The second vertex or vertex ID of the edge to be removed.
+     * @returns the removed edge (E) if it exists, or null if either of the vertices (v1 or v2) does not exist.
+     */
     removeEdgeBetween(v1: V | VertexId, v2: V | VertexId): E | null {
 
         const vertex1: V | null = this.getVertex(v1);
@@ -84,11 +108,22 @@ export class UndirectedGraph<V extends UndirectedVertex, E extends UndirectedEdg
         return removed;
     }
 
-
+    /**
+     * The removeEdge function removes an edge between two vertices in a graph.
+     * @param {E} edge - The parameter "edge" is of type E, which represents an edge in a graph.
+     * @returns The method is returning either the removed edge (of type E) or null if the edge was not found.
+     */
     removeEdge(edge: E): E | null {
         return this.removeEdgeBetween(edge.vertices[0], edge.vertices[1]);
     }
 
+    /**
+     * The function `degreeOf` returns the degree of a vertex in a graph, which is the number of edges connected to that
+     * vertex.
+     * @param {VertexId | V} vertexOrId - The parameter `vertexOrId` can be either a `VertexId` or a `V`.
+     * @returns The function `degreeOf` returns the degree of a vertex in a graph. The degree of a vertex is the number of
+     * edges that are incident to that vertex.
+     */
     degreeOf(vertexOrId: VertexId | V): number {
         const vertex = this.getVertex(vertexOrId);
         if (vertex) {
@@ -98,6 +133,13 @@ export class UndirectedGraph<V extends UndirectedVertex, E extends UndirectedEdg
         }
     }
 
+    /**
+     * The function "edgesOf" returns an array of edges connected to a given vertex.
+     * @param {VertexId | V} vertexOrId - The parameter `vertexOrId` can be either a `VertexId` or a `V`.
+     * @returns an array of edges connected to the specified vertex. If the vertex exists in the graph, the function
+     * returns the array of edges connected to that vertex. If the vertex does not exist in the graph, the function returns
+     * an empty array.
+     */
     edgesOf(vertexOrId: VertexId | V): E[] {
         const vertex = this.getVertex(vertexOrId);
         if (vertex) {
@@ -107,6 +149,10 @@ export class UndirectedGraph<V extends UndirectedVertex, E extends UndirectedEdg
         }
     }
 
+    /**
+     * The function "edgeSet" returns an array of unique edges from a set of edges.
+     * @returns The method `edgeSet()` returns an array of type `E[]`.
+     */
     edgeSet(): E[] {
         const edgeSet: Set<E> = new Set();
         this._edges.forEach(edges => {
@@ -117,6 +163,12 @@ export class UndirectedGraph<V extends UndirectedVertex, E extends UndirectedEdg
         return [...edgeSet];
     }
 
+    /**
+     * The function "getEdgesOf" returns an array of edges connected to a given vertex or vertex ID.
+     * @param {V | VertexId} vertexOrId - The parameter `vertexOrId` can accept either a vertex object (`V`) or a vertex ID
+     * (`VertexId`).
+     * @returns an array of edges (E[]) that are connected to the specified vertex or vertex ID.
+     */
     getEdgesOf(vertexOrId: V | VertexId): E[] {
         const vertex = this.getVertex(vertexOrId);
         if (!vertex) {
@@ -125,6 +177,12 @@ export class UndirectedGraph<V extends UndirectedVertex, E extends UndirectedEdg
         return this._edges.get(vertex) || [];
     }
 
+    /**
+     * The function "getNeighbors" returns an array of neighboring vertices of a given vertex.
+     * @param {V | VertexId} vertexOrId - The parameter `vertexOrId` can be either a vertex object (`V`) or a vertex ID
+     * (`VertexId`).
+     * @returns an array of vertices (V[]).
+     */
     getNeighbors(vertexOrId: V | VertexId): V[] {
         const neighbors: V[] = [];
         const vertex = this.getVertex(vertexOrId);
@@ -140,6 +198,14 @@ export class UndirectedGraph<V extends UndirectedVertex, E extends UndirectedEdg
         return neighbors;
     }
 
+    /**
+     * The function "getEndsOfEdge" returns the vertices at the ends of a given edge, or null if the edge does not exist in
+     * the graph.
+     * @param {E} edge - The parameter "edge" is of type E, which represents an edge in a graph.
+     * @returns The function `getEndsOfEdge` returns an array containing two vertices `[V, V]` if the edge exists in the
+     * graph and both vertices are found. If the edge does not exist or one or both vertices are not found, it returns
+     * `null`.
+     */
     getEndsOfEdge(edge: E): [V, V] | null {
         if (!this.containsEdge(edge.vertices[0], edge.vertices[1])) {
             return null;

package/src/data-structures/hash/coordinate-map.ts

@@ -1,3 +1,7 @@
+/**
+ * @copyright 2030 Tyler Zeng <zrwusa@gmail.com>
+ * @license MIT
+ */
 export class CoordinateMap<V> extends Map<any, V> {
     private readonly _joint: string = '_';
 
@@ -6,18 +10,46 @@ export class CoordinateMap<V> extends Map<any, V> {
         if (joint !== undefined) this._joint = joint;
     }
 
+    /**
+     * The "has" function overrides the base class's "has" function and checks if a key exists in the map by joining the
+     * key array with a specified delimiter.
+     * @param {number[]} key - The parameter "key" is an array of numbers.
+     * @returns The `has` method is being overridden to return the result of calling the `has` method of the superclass
+     * (`super.has`) with the `key` array joined together using the `_joint` property.
+     */
     override has(key: number[]) {
         return super.has(key.join(this._joint));
     }
 
+    /**
+     * The function overrides the set method of a Map object to convert the key from an array to a string using a specified
+     * delimiter before calling the original set method.
+     * @param {number[]} key - The key parameter is an array of numbers.
+     * @param {V} value - The value parameter is the value that you want to associate with the specified key.
+     * @returns The `set` method is returning the result of calling the `set` method of the superclass
+     * (`super.set(key.join(this._joint), value)`).
+     */
     override set(key: number[], value: V) {
         return super.set(key.join(this._joint), value);
     }
 
+    /**
+     * The function overrides the get method to join the key array with a specified joint and then calls the super get
+     * method.
+     * @param {number[]} key - An array of numbers
+     * @returns The code is returning the value associated with the specified key in the map.
+     */
     override get(key: number[]) {
         return super.get(key.join(this._joint));
     }
 
+    /**
+     * The function overrides the delete method and joins the key array using a specified joint character before calling
+     * the super delete method.
+     * @param {number[]} key - An array of numbers that represents the key to be deleted.
+     * @returns The `delete` method is returning the result of calling the `delete` method on the superclass, with the
+     * `key` array joined together using the `_joint` property.
+     */
     override delete(key: number[]) {
         return super.delete(key.join(this._joint));
     }

package/src/data-structures/hash/coordinate-set.ts

@@ -1,3 +1,7 @@
+/**
+ * @copyright 2030 Tyler Zeng <zrwusa@gmail.com>
+ * @license MIT
+ */
 export class CoordinateSet extends Set {
     private readonly _joint: string = '_';
 
@@ -6,14 +10,35 @@ export class CoordinateSet extends Set {
         if (joint !== undefined) this._joint = joint;
     }
 
+    /**
+     * The "has" function overrides the "has" method of the superclass and checks if a value exists in an array after
+     * joining its elements with a specified separator.
+     * @param {number[]} value - The parameter "value" is an array of numbers.
+     * @returns The overridden `has` method is returning the result of calling the `has` method of the superclass, passing
+     * in the joined value as an argument.
+     */
     override has(value: number[]) {
         return super.has(value.join(this._joint));
     }
 
+    /**
+     * The "add" function overrides the parent class's "add" function by joining the elements of the input array with a
+     * specified delimiter before calling the parent class's "add" function.
+     * @param {number[]} value - An array of numbers
+     * @returns The overridden `add` method is returning the result of calling the `add` method of the superclass
+     * (`super.add`) with the joined string representation of the `value` array (`value.join(this._joint)`).
+     */
     override add(value: number[]) {
         return super.add(value.join(this._joint));
     }
 
+    /**
+     * The function overrides the delete method and deletes an element from a Set by joining the elements of the input
+     * array with a specified joint and then calling the delete method of the parent class.
+     * @param {number[]} value - An array of numbers
+     * @returns The `delete` method is returning the result of calling the `delete` method of the superclass, with the
+     * `value` array joined together using the `_joint` property.
+     */
     override delete(value: number[]) {
         return super.delete(value.join(this._joint));
     }

package/src/data-structures/heap/heap.ts

@@ -1,21 +1,18 @@
-import {PriorityQueue} from '../priority-queue';
-import type {HeapItem, HeapOptions} from '../types';
-
 /**
- * @copyright 2021 Tyler Zeng <zrwusa@gmail.com>
+ * @copyright 2030 Tyler Zeng <zrwusa@gmail.com>
  * @license MIT
- *
- * @abstract
- * @class Heap
  */
+import {PriorityQueue} from '../priority-queue';
+import type {HeapItem, HeapOptions} from '../types';
+
 export abstract class Heap<T> {
     protected abstract _pq: PriorityQueue<HeapItem<T>>;
     protected _priorityCb: (element: T) => number;
 
     /**
-     * Creates a priority queue
-     * @public
-     * @params {object} [options]
+     * The function is a constructor for a class that initializes a priority callback function based on the
+     * options provided.
+     * @param [options] - An optional object that contains configuration options for the Heap.
      */
     protected constructor(options?: HeapOptions<T>) {
         if (options) {
@@ -30,44 +27,45 @@ export abstract class Heap<T> {
     }
 
     /**
-     * @public
-     * @returns {number}
+     * The function returns the size of a priority queue.
+     * @returns The size of the priority queue.
      */
     get size(): number {
         return this._pq.size;
     }
 
     /**
-     * @public
-     * @returns {boolean}
+     * The function checks if a priority queue is empty.
+     * @returns {boolean} A boolean value indicating whether the size of the priority queue is less than 1.
      */
     isEmpty(): boolean {
         return this._pq.size < 1;
     }
 
     /**
-     * Returns an element with highest priority in the queue
-     * @public
-     * @returns {object}
+     * The `peek` function returns the top item in the priority queue without removing it.
+     * @returns The `peek()` method is returning either a `HeapItem<T>` object or `null`.Returns an element with the highest priority in the queue
      */
     peek(): HeapItem<T> | null {
         return this._pq.peek();
     }
 
     /**
-     * Returns an element with lowest priority in the queue
-     * @public
-     * @returns {object}
+     * The `peekLast` function returns the last item in the heap.
+     * @returns The method `peekLast()` returns either a `HeapItem<T>` object or `null`.Returns an element with the lowest priority in the queue
      */
     peekLast(): HeapItem<T> | null {
         return this._pq.leaf();
     }
 
     /**
-     * Adds an element to the queue
-     * @public
-     * @param {any} element
-     * @param priority
+     * The `offer` function adds an element to a priority queue with an optional priority value.
+     * @param {T} element - The `element` parameter represents the value that you want to add to the heap. It can be of any
+     * type.
+     * @param {number} [priority] - The `priority` parameter is an optional number that represents the priority of the
+     * element being offered to the heap. If the `element` parameter is a number, then the `priority` parameter is set to
+     * the value of `element`. If the `element` parameter is not a number, then the
+     * @returns The `offer` method returns the instance of the `Heap` class.
      * @throws {Error} if priority is not a valid number
      */
     offer(element: T, priority?: number): Heap<T> {
@@ -96,9 +94,8 @@ export abstract class Heap<T> {
     }
 
     /**
-     * Removes and returns an element with highest priority in the queue
-     * @public
-     * @returns {object}
+     * The `poll` function returns the top item from a priority queue or null if the queue is empty.Removes and returns an element with the highest priority in the queue
+     * @returns either a HeapItem<T> object or null.
      */
     poll(): HeapItem<T> | null {
         const top = this._pq.poll();
@@ -109,17 +106,15 @@ export abstract class Heap<T> {
     }
 
     /**
-     * Returns a sorted list of elements
-     * @public
-     * @returns {array}
+     * The `toArray` function returns an array of `HeapItem<T>` objects.
+     * @returns An array of HeapItem<T> objects.Returns a sorted list of elements
      */
     toArray(): HeapItem<T>[] {
         return this._pq.toArray();
     }
 
     /**
-     * Clears the queue
-     * @public
+     * The clear function clears the priority queue.
      */
     clear(): void {
         this._pq.clear();

package/src/data-structures/heap/max-heap.ts

@@ -1,5 +1,5 @@
 /**
- * @copyright 2020 Tyler Zeng <zrwusa@gmail.com>
+ * @copyright 2030 Tyler Zeng <zrwusa@gmail.com>
  * @license MIT
  */
 
@@ -14,6 +14,11 @@ import type {HeapItem, HeapOptions} from '../types';
 export class MaxHeap<T> extends Heap<T> {
     protected _pq: PriorityQueue<HeapItem<T>>;
 
+    /**
+     * The constructor initializes a PriorityQueue with a custom comparator function.
+     * @param [options] - The `options` parameter is an optional object that can be passed to the constructor. It is of
+     * type `HeapOptions<T>`, which is a generic type that represents the options for the heap.
+     */
     constructor(options?: HeapOptions<T>) {
         super(options);
         this._pq = new PriorityQueue<HeapItem<T>>({

package/src/data-structures/heap/min-heap.ts

@@ -1,5 +1,5 @@
 /**
- * @copyright 2020 Tyler Zeng <zrwusa@gmail.com>
+ * @copyright 2030 Tyler Zeng <zrwusa@gmail.com>
  * @license MIT
  */
 
@@ -14,6 +14,12 @@ import type {HeapItem, HeapOptions} from '../types';
 export class MinHeap<T> extends Heap<T> {
     protected _pq: PriorityQueue<HeapItem<T>>;
 
+    /**
+     * The constructor initializes a PriorityQueue with a comparator function that compares the priority of two HeapItem
+     * objects.
+     * @param [options] - The `options` parameter is an optional object that can be passed to the constructor. It is of
+     * type `HeapOptions<T>`, which is a generic type that represents the options for the heap.
+     */
     constructor(options?: HeapOptions<T>) {
         super(options);
         this._pq = new PriorityQueue<HeapItem<T>>({

package/src/data-structures/index.ts

@@ -8,5 +8,4 @@ export * from './heap';
 export * from './priority-queue';
 export * from './matrix';
 export * from './trie';
-export * from './types';
 

package/src/data-structures/linked-list/doubly-linked-list.ts

@@ -1,3 +1,7 @@
+/**
+ * @copyright 2030 Tyler Zeng <zrwusa@gmail.com>
+ * @license MIT
+ */
 import type {DoublyLinkedListGetBy} from '../types';
 
 export class DoublyLinkedListNode<T> {
@@ -25,8 +29,10 @@ export class DoublyLinkedList<T> {
     }
 
     /**
-     * Adds a node at the beginning of the linked list
-     * @param val Value to be stored at the beginning of the linked list
+     * The function adds a new node with a given value to the beginning of a doubly linked list.
+     * @param {T} val - The `val` parameter represents the value of the element that you want to add to the beginning of
+     * the doubly linked list.
+     * @returns A boolean value is being returned.
      */
     offerFirst(val: T): boolean {
         const newNode = new DoublyLinkedListNode(val);
@@ -43,8 +49,10 @@ export class DoublyLinkedList<T> {
     }
 
     /**
-     * Adds a node to the end of the linked list
-     * @param val Value to be stored in the Doubly linked list node
+     * The function adds a new node with a given value to the end of a doubly linked list.
+     * @param {T} val - The `val` parameter represents the value of the element that you want to add to the end of the
+     * doubly linked list.
+     * @returns a boolean value, which is always true.
      */
     offerLast(val: T): boolean {
         const newNode = new DoublyLinkedListNode(val);
@@ -63,6 +71,14 @@ export class DoublyLinkedList<T> {
     peekFirst(): T | null;
     peekFirst(by: 'val'): T | null;
     peekFirst(by: 'node'): DoublyLinkedListNode<T> | null;
+    /**
+     * The `peekFirst` function returns the first node or value in a doubly linked list, depending on the specified
+     * parameter.
+     * @param {DoublyLinkedListGetBy} [by] - The "by" parameter is an optional parameter of type DoublyLinkedListGetBy. It
+     * is used to specify whether to return the first node, the value of the first node, or the first node itself.
+     * @returns The method `peekFirst` returns either the first node of the doubly linked list (`DoublyLinkedListNode<T>`),
+     * the value of the first node (`T`), or `null` depending on the value of the `by` parameter.
+     */
     peekFirst(by?: DoublyLinkedListGetBy): T | DoublyLinkedListNode<T> | null {
         switch (by) {
             case 'node':
@@ -77,6 +93,13 @@ export class DoublyLinkedList<T> {
     peekLast(): T | null;
     peekLast(by: 'val'): T | null;
     peekLast(by: 'node'): DoublyLinkedListNode<T> | null;
+    /**
+     * The `peekLast` function returns the last node or value in a doubly linked list.
+     * @param {DoublyLinkedListGetBy} [by=val] - The "by" parameter is an optional parameter of type DoublyLinkedListGetBy.
+     * It specifies whether to return the last node, the value of the last node, or both. The default value is 'val', which
+     * means that if no value is provided for the "by" parameter, the method
+     * @returns The method `peekLast` returns the last node, value, or null based on the specified `by` parameter.
+     */
     peekLast(by: DoublyLinkedListGetBy = 'val'): T | DoublyLinkedListNode<T> | null {
         switch (by) {
             case 'node':
@@ -92,7 +115,14 @@ export class DoublyLinkedList<T> {
     pollFirst(by: 'val'): T | null;
     pollFirst(by: 'node'): DoublyLinkedListNode<T> | null;
     /**
-     * Removes a node form the beginning of the linked list and will return the node val
+     * The function `pollFirst` removes and returns the first element of a doubly linked list, either as a node or its
+     * value, depending on the specified parameter.
+     * @param {DoublyLinkedListGetBy} [by=val] - The "by" parameter is an optional parameter of type DoublyLinkedListGetBy.
+     * It specifies the criteria by which the first element should be retrieved from the doubly linked list. The default
+     * value is 'val', which means the first element will be retrieved by its value. Other possible values for "by
+     * @returns The method `pollFirst` returns either the value of the first node in the doubly linked list, the first node
+     * itself, or null if the list is empty. The specific return type depends on the value of the `by` parameter. If `by`
+     * is set to 'node', the method returns the first node. If `by` is set to 'val', the method returns the value
      */
     pollFirst(by: DoublyLinkedListGetBy = 'val'): T | DoublyLinkedListNode<T> | null {
         if (this._size === 0) return null;
@@ -120,7 +150,14 @@ export class DoublyLinkedList<T> {
     pollLast(by: 'val'): T | null;
     pollLast(by: 'node'): DoublyLinkedListNode<T> | null;
     /**
-     * Removes a node at the end of the linked list and will return the node value
+     * The function `pollLast` removes and returns the last element in a doubly linked list, either as a node or its value,
+     * depending on the specified parameter.
+     * @param {DoublyLinkedListGetBy} [by=val] - The parameter "by" is of type DoublyLinkedListGetBy, which is an enum that
+     * can have two possible values: 'node' or 'val'. It determines the type of value that will be returned by the pollLast
+     * method. If 'node' is specified, the method will return the
+     * @returns The method `pollLast` returns either a `DoublyLinkedListNode<T>`, the value of the node (`T`), or `null`.
+     * The specific type that is returned depends on the value of the `by` parameter. If `by` is set to `'node'`, then a
+     * `DoublyLinkedListNode<T>` is returned. If `by` is set to `'
      */
     pollLast(by: DoublyLinkedListGetBy = 'val'): DoublyLinkedListNode<T> | T | null {
         if (this._size === 0) return null;
@@ -226,8 +263,12 @@ export class DoublyLinkedList<T> {
     }
 
     /**
-     * Removes a node at the specified index and returns its value.
-     * @param index Index at which the node has to be removed.
+     * The `remove` function removes an element at a specified index from a data structure, updating the links between
+     * nodes accordingly.
+     * @param {number} index - The index parameter represents the position of the element to be removed in the data
+     * structure. It is of type number.
+     * @returns The `remove` method returns the value of the removed element (`T`) if the removal is successful, or `null`
+     * if the index is out of bounds.
      */
     remove(index: number): T | null {
         if (index < 0 || index > this._size - 1) return null;

package/src/data-structures/linked-list/singly-linked-list.ts

@@ -1,4 +1,7 @@
-import type {TMapFunction, TTestFunction} from '../types';
+/**
+ * @copyright 2030 Tyler Zeng <zrwusa@gmail.com>
+ * @license MIT
+ */
 
 /**
  * The class which represents one link or node in a linked list
@@ -173,7 +176,11 @@ export class SinglyLinkedList<NodeData = any> {
      * ```
      * @param f A function to be applied to the val of each node
      */
-    public findNodeIndex(f: TTestFunction<NodeData>): ({
+    public findNodeIndex(f: (
+        data: NodeData,
+        index: number,
+        list: SinglyLinkedList<NodeData>,
+    ) => boolean): ({
         node: SinglyLinkedListNode<NodeData>,
         index: number,
     }) | undefined {
@@ -201,7 +208,11 @@ export class SinglyLinkedList<NodeData = any> {
      * ```
      * @param f Function to test val against
      */
-    public findNode(f: TTestFunction<NodeData>): SinglyLinkedListNode<NodeData> | undefined {
+    public findNode(f: (
+        data: NodeData,
+        index: number,
+        list: SinglyLinkedList<NodeData>,
+    ) => boolean): SinglyLinkedListNode<NodeData> | undefined {
         const nodeIndex = this.findNodeIndex(f);
         return nodeIndex !== undefined ? nodeIndex.node : undefined;
     }
@@ -214,7 +225,11 @@ export class SinglyLinkedList<NodeData = any> {
      * ```
      * @param f Function to test val against
      */
-    public find(f: TTestFunction<NodeData>): NodeData | undefined {
+    public find(f: (
+        data: NodeData,
+        index: number,
+        list: SinglyLinkedList<NodeData>,
+    ) => boolean): NodeData | undefined {
         const nodeIndex = this.findNodeIndex(f);
         return nodeIndex !== undefined ? nodeIndex.node.val : undefined;
     }
@@ -227,7 +242,11 @@ export class SinglyLinkedList<NodeData = any> {
      * ```
      * @param f Function to test val against
      */
-    public findIndex(f: TTestFunction<NodeData>): number {
+    public findIndex(f: (
+        data: NodeData,
+        index: number,
+        list: SinglyLinkedList<NodeData>,
+    ) => boolean): number {
         const nodeIndex = this.findNodeIndex(f);
         return nodeIndex !== undefined ? nodeIndex.index : -1;
     }
@@ -601,7 +620,11 @@ export class SinglyLinkedList<NodeData = any> {
      * @param f Function to execute for each element, taking up to three arguments.
      * @param reverse Indicates if the list should be walked in reverse order, default is false
      */
-    public forEach(f: TMapFunction<NodeData>, reverse = false): void {
+    public forEach(f: (
+        data: any,
+        index: number,
+        list: SinglyLinkedList<NodeData>,
+    ) => any, reverse = false): void {
         let currentIndex = reverse ? this.length - 1 : 0;
         let currentNode = reverse ? this.tail : this.head;
         const modifier = reverse ? -1 : 1;
@@ -623,7 +646,11 @@ export class SinglyLinkedList<NodeData = any> {
      * @param reverse Indicates if the list should be mapped in reverse order, default is false
      */
     // eslint-disable-next-line @typescript-eslint/ban-types
-    public map(f: TMapFunction<NodeData>, reverse = false): SinglyLinkedList<NodeData | {}> {
+    public map(f: (
+        data: any,
+        index: number,
+        list: SinglyLinkedList<NodeData>,
+    ) => any, reverse = false): SinglyLinkedList<NodeData | {}> {
         const list = new SinglyLinkedList();
         this.forEach((val, index) => list.append(f(val, index, this)), reverse);
         return list;
@@ -639,7 +666,11 @@ export class SinglyLinkedList<NodeData = any> {
      * @param reverse Indicates if the list should be filtered in reverse order, default is false
      */
     // eslint-disable-next-line @typescript-eslint/ban-types
-    public filter(f: TTestFunction<NodeData>, reverse = false): SinglyLinkedList<NodeData | {}> {
+    public filter(f: (
+        data: NodeData,
+        index: number,
+        list: SinglyLinkedList<NodeData>,
+    ) => boolean, reverse = false): SinglyLinkedList<NodeData | {}> {
         const list = new SinglyLinkedList();
         this.forEach((val, index) => {
             if (f(val, index, this)) {

package/src/data-structures/matrix/matrix.ts

@@ -1,12 +1,23 @@
+/**
+ * @copyright 2030 Tyler Zeng <zrwusa@gmail.com>
+ * @license MIT
+ */
 // todo need to be improved
 export class MatrixNTI2D<T = number> {
     private readonly _matrix: Array<Array<T>>;
 
+    /**
+     * The constructor creates a matrix with the specified number of rows and columns, and initializes all elements to a
+     * given initial value or 0 if not provided.
+     * @param options - An object containing the following properties:
+     */
     constructor(options: { row: number, col: number, initialVal?: T }) {
         const {row, col, initialVal} = options;
         this._matrix = new Array(row).fill(undefined).map(() => new Array(col).fill(initialVal || 0));
     }
 
+    /* The `toArray` method returns the matrix as a two-dimensional array. It converts the internal representation of the
+    matrix, which is an array of arrays, into a format that is more commonly used in JavaScript. */
     toArray(): Array<Array<T>> {
         return this._matrix;
     }