stack-typed 1.48.1 → 1.48.3

package/src/data-structures/binary-tree/tree-multimap.ts

@@ -5,26 +5,21 @@
  * @copyright Copyright (c) 2022 Tyler Zeng <zrwusa@gmail.com>
  * @license MIT License
  */
-import type {
-  BSTNodeKeyOrNode,
-  BTNKey,
-  BTNodeExemplar,
-  TreeMultimapNodeNested,
-  TreeMultimapOptions
-} from '../../types';
+import type { BSTNodeKeyOrNode, BTNodeExemplar, TreeMultimapNodeNested, TreeMultimapOptions } from '../../types';
 import { BiTreeDeleteResult, BTNCallback, FamilyPosition, IterationType, TreeMultimapNested } from '../../types';
 import { IBinaryTree } from '../../interfaces';
 import { AVLTree, AVLTreeNode } from './avl-tree';
 
 export class TreeMultimapNode<
+  K = any,
   V = any,
-  N extends TreeMultimapNode<V, N> = TreeMultimapNodeNested<V>
-> extends AVLTreeNode<V, N> {
+  N extends TreeMultimapNode<K, V, N> = TreeMultimapNodeNested<K, V>
+> extends AVLTreeNode<K, V, N> {
   count: number;
 
   /**
    * The constructor function initializes a BinaryTreeNode object with a key, value, and count.
-   * @param {BTNKey} key - The `key` parameter is of type `BTNKey` and represents the unique identifier
+   * @param {K} key - The `key` parameter is of type `K` and represents the unique identifier
    * of the binary tree node.
    * @param {V} [value] - The `value` parameter is an optional parameter of type `V`. It represents the value of the binary
    * tree node. If no value is provided, it will be `undefined`.
@@ -32,7 +27,7 @@ export class TreeMultimapNode<
    * occurs in a binary tree node. It has a default value of 1, which means that if no value is provided for the `count`
    * parameter when creating a new instance of the `BinaryTreeNode` class.
    */
-  constructor(key: BTNKey, value?: V, count = 1) {
+  constructor(key: K, value?: V, count = 1) {
     super(key, value);
     this.count = count;
   }
@@ -41,12 +36,12 @@ export class TreeMultimapNode<
 /**
  * The only distinction between a TreeMultimap and a AVLTree lies in the ability of the former to store duplicate nodes through the utilization of counters.
  */
-export class TreeMultimap<V = any, N extends TreeMultimapNode<V, N> = TreeMultimapNode<V, TreeMultimapNodeNested<V>>,
-  TREE extends TreeMultimap<V, N, TREE> = TreeMultimap<V, N, TreeMultimapNested<V, N>>>
-  extends AVLTree<V, N, TREE>
-  implements IBinaryTree<V, N, TREE> {
+export class TreeMultimap<K = any, V = any, N extends TreeMultimapNode<K, V, N> = TreeMultimapNode<K, V, TreeMultimapNodeNested<K, V>>,
+  TREE extends TreeMultimap<K, V, N, TREE> = TreeMultimap<K, V, N, TreeMultimapNested<K, V, N>>>
+  extends AVLTree<K, V, N, TREE>
+  implements IBinaryTree<K, V, N, TREE> {
 
-  constructor(elements?: Iterable<BTNodeExemplar<V, N>>, options?: Partial<TreeMultimapOptions>) {
+  constructor(elements?: Iterable<BTNodeExemplar<K, V, N>>, options?: Partial<TreeMultimapOptions<K>>) {
     super([], options);
     if (elements) this.addMany(elements);
   }
@@ -62,43 +57,43 @@ export class TreeMultimap<V = any, N extends TreeMultimapNode<V, N> = TreeMultim
 
   /**
    * The function creates a new BSTNode with the given key, value, and count.
-   * @param {BTNKey} key - The key parameter is the unique identifier for the binary tree node. It is used to
+   * @param {K} key - The key parameter is the unique identifier for the binary tree node. It is used to
    * distinguish one node from another in the tree.
    * @param {N} value - The `value` parameter represents the value that will be stored in the binary search tree node.
    * @param {number} [count] - The "count" parameter is an optional parameter of type number. It represents the number of
    * occurrences of the value in the binary search tree node. If not provided, the count will default to 1.
    * @returns A new instance of the BSTNode class with the specified key, value, and count (if provided).
    */
-  override createNode(key: BTNKey, value?: V, count?: number): N {
+  override createNode(key: K, value?: V, count?: number): N {
     return new TreeMultimapNode(key, value, count) as N;
   }
 
-  override createTree(options?: TreeMultimapOptions): TREE {
-    return new TreeMultimap<V, N, TREE>([], {
+  override createTree(options?: TreeMultimapOptions<K>): TREE {
+    return new TreeMultimap<K, V, N, TREE>([], {
       iterationType: this.iterationType,
-      comparator: this.comparator, ...options
+      variant: this.variant, ...options
     }) as TREE;
   }
 
   /**
    * The function checks if an exemplar is an instance of the TreeMultimapNode class.
-   * @param exemplar - The `exemplar` parameter is of type `BTNodeExemplar<V, N>`.
+   * @param exemplar - The `exemplar` parameter is of type `BTNodeExemplar<K, V, N>`.
    * @returns a boolean value indicating whether the exemplar is an instance of the TreeMultimapNode
    * class.
    */
-  override isNode(exemplar: BTNodeExemplar<V, N>): exemplar is N {
+  override isNode(exemplar: BTNodeExemplar<K, V, N>): exemplar is N {
     return exemplar instanceof TreeMultimapNode;
   }
 
   /**
    * The function `exemplarToNode` converts an exemplar object into a node object.
-   * @param exemplar - The `exemplar` parameter is of type `BTNodeExemplar<V, N>`, where `V` represents
+   * @param exemplar - The `exemplar` parameter is of type `BTNodeExemplar<K, V, N>`, where `V` represents
    * the value type and `N` represents the node type.
    * @param [count=1] - The `count` parameter is an optional parameter that specifies the number of
    * times the node should be created. If not provided, it defaults to 1.
    * @returns a value of type `N` (the generic type parameter) or `undefined`.
    */
-  override exemplarToNode(exemplar: BTNodeExemplar<V, N>, count = 1): N | undefined {
+  override exemplarToNode(exemplar: BTNodeExemplar<K, V, N>, count = 1): N | undefined {
     let node: N | undefined;
     if (exemplar === undefined || exemplar === null) {
       return;
@@ -111,7 +106,7 @@ export class TreeMultimap<V = any, N extends TreeMultimapNode<V, N> = TreeMultim
       } else {
         node = this.createNode(key, value, count);
       }
-    } else if (this.isNodeKey(exemplar)) {
+    } else if (this.isNotNodeInstance(exemplar)) {
       node = this.createNode(exemplar, undefined, count);
     } else {
       return;
@@ -136,7 +131,7 @@ export class TreeMultimap<V = any, N extends TreeMultimapNode<V, N> = TreeMultim
    * is 1.
    * @returns either a node (`N`) or `undefined`.
    */
-  override add(keyOrNodeOrEntry: BTNodeExemplar<V, N>, count = 1): N | undefined {
+  override add(keyOrNodeOrEntry: BTNodeExemplar<K, V, N>, count = 1): N | undefined {
     const newNode = this.exemplarToNode(keyOrNodeOrEntry, count);
     if (newNode === undefined) return;
 
@@ -163,7 +158,7 @@ export class TreeMultimap<V = any, N extends TreeMultimapNode<V, N> = TreeMultim
    * either keys, nodes, or entries.
    * @returns The method is returning an array of type `N | undefined`.
    */
-  override addMany(keysOrNodesOrEntries: Iterable<BTNodeExemplar<V, N>>): (N | undefined)[] {
+  override addMany(keysOrNodesOrEntries: Iterable<BTNodeExemplar<K, V, N>>): (N | undefined)[] {
     return super.addMany(keysOrNodesOrEntries);
   }
 
@@ -345,13 +340,13 @@ export class TreeMultimap<V = any, N extends TreeMultimapNode<V, N> = TreeMultim
    * @param {N | undefined} newNode - The `newNode` parameter represents the node that needs to be
    * added to the binary tree. It can be of type `N` (which represents a node in the binary tree) or
    * `undefined` if there is no node to add.
-   * @param {BTNKey | N | undefined} parent - The `parent` parameter represents the parent node to
+   * @param {K | N | undefined} parent - The `parent` parameter represents the parent node to
    * which the new node will be added as a child. It can be either a node object (`N`) or a key value
-   * (`BTNKey`).
+   * (`K`).
    * @returns The method `_addTo` returns either the `parent.left` or `parent.right` node that was
    * added, or `undefined` if no node was added.
    */
-  protected override _addTo(newNode: N | undefined, parent: BSTNodeKeyOrNode<N>): N | undefined {
+  protected override _addTo(newNode: N | undefined, parent: BSTNodeKeyOrNode<K, N>): N | undefined {
     parent = this.ensureNode(parent);
     if (parent) {
       if (parent.left === undefined) {
@@ -379,14 +374,14 @@ export class TreeMultimap<V = any, N extends TreeMultimapNode<V, N> = TreeMultim
 
   /**
    * The `_swapProperties` function swaps the key, value, count, and height properties between two nodes.
-   * @param {BTNKey | N | undefined} srcNode - The `srcNode` parameter represents the source node from
-   * which the values will be swapped. It can be of type `BTNKey`, `N`, or `undefined`.
-   * @param {BTNKey | N | undefined} destNode - The `destNode` parameter represents the destination
+   * @param {K | N | undefined} srcNode - The `srcNode` parameter represents the source node from
+   * which the values will be swapped. It can be of type `K`, `N`, or `undefined`.
+   * @param {K | N | undefined} destNode - The `destNode` parameter represents the destination
    * node where the values from the source node will be swapped to.
    * @returns either the `destNode` object if both `srcNode` and `destNode` are defined, or `undefined`
    * if either `srcNode` or `destNode` is undefined.
    */
-  protected override _swapProperties(srcNode: BSTNodeKeyOrNode<N>, destNode: BSTNodeKeyOrNode<N>): N | undefined {
+  protected override _swapProperties(srcNode: BSTNodeKeyOrNode<K, N>, destNode: BSTNodeKeyOrNode<K, N>): N | undefined {
     srcNode = this.ensureNode(srcNode);
     destNode = this.ensureNode(destNode);
     if (srcNode && destNode) {

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

@@ -8,8 +8,10 @@
 import { uuidV4 } from '../../utils';
 import { PriorityQueue } from '../priority-queue';
 import type { DijkstraResult, VertexKey } from '../../types';
+import { PairCallback } from "../../types";
 import { IGraph } from '../../interfaces';
 import { Queue } from '../queue';
+import { IterablePairBase } from "../base";
 
 export abstract class AbstractVertex<V = any> {
   key: VertexKey;
@@ -64,7 +66,11 @@ export abstract class AbstractGraph<
   E = any,
   VO extends AbstractVertex<V> = AbstractVertex<V>,
   EO extends AbstractEdge<E> = AbstractEdge<E>
-> implements IGraph<V, E, VO, EO> {
+> extends IterablePairBase<VertexKey, V | undefined> implements IGraph<V, E, VO, EO> {
+  constructor() {
+    super();
+  }
+
   protected _vertices: Map<VertexKey, VO> = new Map<VertexKey, VO>();
 
   get vertices(): Map<VertexKey, VO> {
@@ -1159,50 +1165,71 @@ export abstract class AbstractGraph<
     return this.tarjan(false, true, false, false).bridges;
   }
 
-  * [Symbol.iterator](): Iterator<[VertexKey, V | undefined]> {
-    for (const vertex of this._vertices.values()) {
-      yield [vertex.key, vertex.value];
-    }
-  }
-
-  forEach(callback: (entry: [VertexKey, V | undefined], index: number, map: Map<VertexKey, VO>) => void): void {
-    let index = 0;
-    for (const vertex of this) {
-      callback(vertex, index, this._vertices);
-      index++;
-    }
-  }
+  /**
+   * Time Complexity: O(n)
+   * Space Complexity: O(n)
+   */
 
-  filter(predicate: (entry: [VertexKey, V | undefined], index: number, map: Map<VertexKey, VO>) => boolean): [VertexKey, V | undefined][] {
+  /**
+   * Time Complexity: O(n)
+   * Space Complexity: O(n)
+   *
+   * The `filter` function iterates over key-value pairs in a data structure and returns an array of
+   * pairs that satisfy a given predicate.
+   * @param predicate - The `predicate` parameter is a callback function that takes four arguments:
+   * `value`, `key`, `index`, and `this`. It is used to determine whether an element should be included
+   * in the filtered array. The callback function should return `true` if the element should be
+   * included, and `
+   * @param {any} [thisArg] - The `thisArg` parameter is an optional argument that allows you to
+   * specify the value of `this` within the `predicate` function. It is used when you want to bind a
+   * specific object as the context for the `predicate` function. If `thisArg` is provided, it will be
+   * @returns The `filter` method returns an array of key-value pairs `[VertexKey, V | undefined][]`
+   * that satisfy the given predicate function.
+   */
+  filter(predicate: PairCallback<VertexKey, V | undefined, boolean>, thisArg?: any): [VertexKey, V | undefined][] {
     const filtered: [VertexKey, V | undefined][] = [];
     let index = 0;
-    for (const entry of this) {
-      if (predicate(entry, index, this._vertices)) {
-        filtered.push(entry);
+    for (const [key, value] of this) {
+      if (predicate.call(thisArg, value, key, index, this)) {
+        filtered.push([key, value]);
       }
       index++;
     }
     return filtered;
   }
 
-  map<T>(callback: (entry: [VertexKey, V | undefined], index: number, map: Map<VertexKey, VO>) => T): T[] {
+  /**
+   * Time Complexity: O(n)
+   * Space Complexity: O(n)
+   */
+
+  /**
+   * Time Complexity: O(n)
+   * Space Complexity: O(n)
+   *
+   * The `map` function iterates over the elements of a collection and applies a callback function to
+   * each element, returning an array of the results.
+   * @param callback - The callback parameter is a function that will be called for each element in the
+   * map. It takes four arguments:
+   * @param {any} [thisArg] - The `thisArg` parameter is an optional argument that allows you to
+   * specify the value of `this` within the callback function. If `thisArg` is provided, it will be
+   * used as the `this` value when calling the callback function. If `thisArg` is not provided, `
+   * @returns The `map` function is returning an array of type `T[]`.
+   */
+  map<T>(callback: PairCallback<VertexKey, V | undefined, T>, thisArg?: any): T[] {
     const mapped: T[] = [];
     let index = 0;
-    for (const entry of this) {
-      mapped.push(callback(entry, index, this._vertices));
+    for (const [key, value] of this) {
+      mapped.push(callback.call(thisArg, value, key, index, this));
       index++;
     }
     return mapped;
   }
 
-  reduce<T>(callback: (accumulator: T, entry: [VertexKey, V | undefined], index: number, map: Map<VertexKey, VO>) => T, initialValue: T): T {
-    let accumulator: T = initialValue;
-    let index = 0;
-    for (const entry of this) {
-      accumulator = callback(accumulator, entry, index, this._vertices);
-      index++;
+  protected* _getIterator(): IterableIterator<[VertexKey, V | undefined]> {
+    for (const vertex of this._vertices.values()) {
+      yield [vertex.key, vertex.value];
     }
-    return accumulator;
   }
 
   protected abstract _addEdgeOnly(edge: EO): boolean;

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

@@ -7,9 +7,10 @@
  */
 
 import { isWeakKey, rangeCheck } from '../../utils';
-import { HashMapLinkedNode, HashMapOptions, HashMapStoreItem } from '../../types';
+import { HashMapLinkedNode, HashMapOptions, HashMapStoreItem, PairCallback } from '../../types';
+import { IterablePairBase } from "../base";
 
-export class HashMap<K = any, V = any> {
+export class HashMap<K = any, V = any> extends IterablePairBase<K, V> {
   protected _store: { [key: string]: HashMapStoreItem<K, V> } = {};
   protected _objMap: Map<object, V> = new Map();
 
@@ -24,6 +25,7 @@ export class HashMap<K = any, V = any> {
   constructor(elements: Iterable<[K, V]> = [], options?: {
     hashFn: (key: K) => string
   }) {
+    super();
     if (options) {
       const { hashFn } = options;
       if (hashFn) {
@@ -145,102 +147,14 @@ export class HashMap<K = any, V = any> {
   }
 
   /**
-   * The function returns an iterator that yields key-value pairs from both an object store and an
-   * object map.
-   */
-  * [Symbol.iterator](): IterableIterator<[K, V]> {
-    for (const node of Object.values(this._store)) {
-      yield [node.key, node.value] as [K, V];
-    }
-    for (const node of this._objMap) {
-      yield node as [K, V];
-    }
-  }
-
-  /**
-   * The function returns an iterator that yields key-value pairs from the object.
-   */
-  * entries(): IterableIterator<[K, V]> {
-    for (const item of this) {
-      yield item;
-    }
-  }
-
-  /**
-   * The function `keys()` returns an iterator that yields all the keys of the object.
-   */
-  * keys(): IterableIterator<K> {
-    for (const [key] of this) {
-      yield key;
-    }
-  }
-
-  * values(): IterableIterator<V> {
-    for (const [, value] of this) {
-      yield value;
-    }
-  }
-
-  /**
-   * The `every` function checks if every element in a HashMap satisfies a given predicate function.
-   * @param predicate - The predicate parameter is a function that takes four arguments: value, key,
-   * index, and map. It is used to test each element in the map against a condition. If the predicate
-   * function returns false for any element, the every() method will return false. If the predicate
-   * function returns true for all
-   * @param {any} [thisArg] - The `thisArg` parameter is an optional argument that specifies the value
-   * to be used as `this` when executing the `predicate` function. If `thisArg` is provided, it will be
-   * passed as the `this` value to the `predicate` function. If `thisArg` is
-   * @returns The method is returning a boolean value. It returns true if the predicate function
-   * returns true for every element in the map, and false otherwise.
+   * Time Complexity: O(n)
+   * Space Complexity: O(n)
    */
-  every(predicate: (value: V, key: K, index: number, map: HashMap<K, V>) => boolean, thisArg?: any): boolean {
-    let index = 0;
-    for (const [key, value] of this) {
-      if (!predicate.call(thisArg, value, key, index++, this)) {
-        return false;
-      }
-    }
-    return true;
-  }
-
-  /**
-   * The "some" function checks if at least one element in a HashMap satisfies a given predicate.
-   * @param predicate - The `predicate` parameter is a function that takes four arguments: `value`,
-   * `key`, `index`, and `map`. It is used to determine whether a specific condition is met for a given
-   * key-value pair in the `HashMap`.
-   * @param {any} [thisArg] - The `thisArg` parameter is an optional argument that specifies the value
-   * to be used as `this` when executing the `predicate` function. If `thisArg` is provided, it will be
-   * passed as the `this` value to the `predicate` function. If `thisArg` is
-   * @returns a boolean value. It returns true if the predicate function returns true for any element
-   * in the map, and false otherwise.
-   */
-  some(predicate: (value: V, key: K, index: number, map: HashMap<K, V>) => boolean, thisArg?: any): boolean {
-    let index = 0;
-    for (const [key, value] of this) {
-      if (predicate.call(thisArg, value, key, index++, this)) {
-        return true;
-      }
-    }
-    return false;
-  }
-
-  /**
-   * The `forEach` function iterates over the elements of a HashMap and applies a callback function to
-   * each element.
-   * @param callbackfn - A function that will be called for each key-value pair in the HashMap. It
-   * takes four parameters:
-   * @param {any} [thisArg] - The `thisArg` parameter is an optional argument that specifies the value
-   * to be used as `this` when executing the `callbackfn` function. If `thisArg` is provided, it will
-   * be passed as the `this` value inside the `callbackfn` function. If `thisArg
-   */
-  forEach(callbackfn: (value: V, key: K, index: number, map: HashMap<K, V>) => void, thisArg?: any): void {
-    let index = 0;
-    for (const [key, value] of this) {
-      callbackfn.call(thisArg, value, key, index++, this);
-    }
-  }
 
   /**
+   * Time Complexity: O(n)
+   * Space Complexity: O(n)
+   *
    * The `map` function in TypeScript creates a new HashMap by applying a callback function to each
    * key-value pair in the original HashMap.
    * @param callbackfn - The callback function that will be called for each key-value pair in the
@@ -251,7 +165,7 @@ export class HashMap<K = any, V = any> {
    * @returns The `map` method is returning a new `HashMap` object with the transformed values based on
    * the provided callback function.
    */
-  map<U>(callbackfn: (value: V, key: K, index: number, map: HashMap<K, V>) => U, thisArg?: any): HashMap<K, U> {
+  map<U>(callbackfn: PairCallback<K, V, U>, thisArg?: any): HashMap<K, U> {
     const resultMap = new HashMap<K, U>();
     let index = 0;
     for (const [key, value] of this) {
@@ -261,6 +175,14 @@ export class HashMap<K = any, V = any> {
   }
 
   /**
+   * Time Complexity: O(n)
+   * Space Complexity: O(n)
+   */
+
+  /**
+   * Time Complexity: O(n)
+   * Space Complexity: O(n)
+   *
    * The `filter` function creates a new HashMap containing key-value pairs from the original HashMap
    * that satisfy a given predicate function.
    * @param predicate - The predicate parameter is a function that takes four arguments: value, key,
@@ -273,7 +195,7 @@ export class HashMap<K = any, V = any> {
    * @returns The `filter` method is returning a new `HashMap` object that contains the key-value pairs
    * from the original `HashMap` that pass the provided `predicate` function.
    */
-  filter(predicate: (value: V, key: K, index: number, map: HashMap<K, V>) => boolean, thisArg?: any): HashMap<K, V> {
+  filter(predicate: PairCallback<K, V, boolean>, thisArg?: any): HashMap<K, V> {
     const filteredMap = new HashMap<K, V>();
     let index = 0;
     for (const [key, value] of this) {
@@ -284,28 +206,21 @@ export class HashMap<K = any, V = any> {
     return filteredMap;
   }
 
+  print(): void {
+    console.log([...this.entries()]);
+  }
+
   /**
-   * The `reduce` function iterates over the elements of a HashMap and applies a callback function to
-   * each element, accumulating a single value.
-   * @param callbackfn - The callback function that will be called for each element in the HashMap. It
-   * takes five parameters:
-   * @param {U} initialValue - The initialValue parameter is the initial value of the accumulator. It
-   * is the value that will be used as the first argument of the callback function when reducing the
-   * elements of the map.
-   * @returns The `reduce` method is returning the final value of the accumulator after iterating over
-   * all the elements in the `HashMap`.
+   * The function returns an iterator that yields key-value pairs from both an object store and an
+   * object map.
    */
-  reduce<U>(callbackfn: (accumulator: U, currentValue: V, currentKey: K, index: number, map: HashMap<K, V>) => U, initialValue: U): U {
-    let accumulator = initialValue;
-    let index = 0;
-    for (const [key, value] of this) {
-      accumulator = callbackfn(accumulator, value, key, index++, this);
+  protected* _getIterator(): IterableIterator<[K, V]> {
+    for (const node of Object.values(this._store)) {
+      yield [node.key, node.value] as [K, V];
+    }
+    for (const node of this._objMap) {
+      yield node as [K, V];
     }
-    return accumulator;
-  }
-
-  print(): void{
-    console.log([...this.entries()]);
   }
 
   protected _hashFn: (key: K) => string = (key: K) => String(key);
@@ -333,7 +248,7 @@ export class HashMap<K = any, V = any> {
   }
 }
 
-export class LinkedHashMap<K = any, V = any> {
+export class LinkedHashMap<K = any, V = any> extends IterablePairBase<K, V> {
 
   protected _noObjMap: Record<string, HashMapLinkedNode<K, V | undefined>> = {};
   protected _objMap = new WeakMap<object, HashMapLinkedNode<K, V | undefined>>();
@@ -349,6 +264,7 @@ export class LinkedHashMap<K = any, V = any> {
     hashFn: (key: K) => String(key),
     objHashFn: (key: K) => (<object>key)
   }) {
+    super();
     this._sentinel = <HashMapLinkedNode<K, V>>{};
     this._sentinel.prev = this._sentinel.next = this._head = this._tail = this._sentinel;
 
@@ -492,18 +408,6 @@ export class LinkedHashMap<K = any, V = any> {
     }
   }
 
-  keys(): K[] {
-    const keys: K[] = [];
-    for (const [key] of this) keys.push(key);
-    return keys;
-  }
-
-  values(): V[] {
-    const values: V[] = [];
-    for (const [, value] of this) values.push(value);
-    return values;
-  }
-
   /**
    * Time Complexity: O(1)
    * Space Complexity: O(1)
@@ -644,36 +548,30 @@ export class LinkedHashMap<K = any, V = any> {
   }
 
   /**
-   * Time Complexity: O(n), where n is the number of elements in the LinkedHashMap.
-   * Space Complexity: O(1)
-   *
-   * The `forEach` function iterates over each element in a LinkedHashMap and executes a callback function on
-   * each element.
-   * @param callback - The callback parameter is a function that will be called for each element in the
-   * LinkedHashMap. It takes three arguments:
+   * Time Complexity: O(n)
+   * Space Complexity: O(n)
    */
-  forEach(callback: (element: [K, V], index: number, hashMap: LinkedHashMap<K, V>) => void) {
-    let index = 0;
-    let node = this._head;
-    while (node !== this._sentinel) {
-      callback(<[K, V]>[node.key, node.value], index++, this);
-      node = node.next;
-    }
-  }
 
   /**
-   * The `filter` function takes a predicate function and returns a new LinkedHashMap containing only the
-   * key-value pairs that satisfy the predicate.
-   * @param predicate - The `predicate` parameter is a function that takes two arguments: `element` and
-   * `map`.
-   * @returns a new LinkedHashMap object that contains the key-value pairs from the original LinkedHashMap that
-   * satisfy the given predicate function.
-   */
-  filter(predicate: (element: [K, V], index: number, map: LinkedHashMap<K, V>) => boolean): LinkedHashMap<K, V> {
+   * Time Complexity: O(n)
+   * Space Complexity: O(n)
+   *
+   * The `filter` function creates a new `LinkedHashMap` containing key-value pairs from the original
+   * map that satisfy a given predicate function.
+   * @param predicate - The `predicate` parameter is a callback function that takes four arguments:
+   * `value`, `key`, `index`, and `this`. It should return a boolean value indicating whether the
+   * current element should be included in the filtered map or not.
+   * @param {any} [thisArg] - The `thisArg` parameter is an optional argument that allows you to
+   * specify the value of `this` within the `predicate` function. It is used when you want to bind a
+   * specific object as the context for the `predicate` function. If `thisArg` is not provided, `this
+   * @returns a new `LinkedHashMap` object that contains the key-value pairs from the original
+   * `LinkedHashMap` object that satisfy the given predicate function.
+   */
+  filter(predicate: PairCallback<K, V, boolean>, thisArg?: any): LinkedHashMap<K, V> {
     const filteredMap = new LinkedHashMap<K, V>();
     let index = 0;
     for (const [key, value] of this) {
-      if (predicate([key, value], index, this)) {
+      if (predicate.call(thisArg, value, key, index, this)) {
         filteredMap.set(key, value);
       }
       index++;
@@ -682,43 +580,40 @@ export class LinkedHashMap<K = any, V = any> {
   }
 
   /**
-   * The `map` function takes a callback function and returns a new LinkedHashMap with the values transformed
-   * by the callback.
-   * @param callback - The `callback` parameter is a function that takes two arguments: `element` and
-   * `map`.
-   * @returns a new LinkedHashMap object with the values mapped according to the provided callback function.
+   * Time Complexity: O(n)
+   * Space Complexity: O(n)
    */
-  map<NV>(callback: (element: [K, V], index: number, map: LinkedHashMap<K, V>) => NV): LinkedHashMap<K, NV> {
+
+  /**
+   * Time Complexity: O(n)
+   * Space Complexity: O(n)
+   *
+   * The `map` function in TypeScript creates a new `LinkedHashMap` by applying a callback function to
+   * each key-value pair in the original map.
+   * @param callback - The callback parameter is a function that will be called for each key-value pair
+   * in the map. It takes four arguments: the value of the current key-value pair, the key of the
+   * current key-value pair, the index of the current key-value pair, and the map itself. The callback
+   * function should
+   * @param {any} [thisArg] - The `thisArg` parameter is an optional argument that allows you to
+   * specify the value of `this` within the callback function. If provided, the callback function will
+   * be called with `thisArg` as its `this` value. If not provided, `this` will refer to the current
+   * map
+   * @returns a new `LinkedHashMap` object with the values mapped according to the provided callback
+   * function.
+   */
+  map<NV>(callback: PairCallback<K, V, NV>, thisArg?: any): LinkedHashMap<K, NV> {
     const mappedMap = new LinkedHashMap<K, NV>();
     let index = 0;
     for (const [key, value] of this) {
-      const newValue = callback([key, value], index, this);
+      const newValue = callback.call(thisArg, value, key, index, this);
       mappedMap.set(key, newValue);
       index++;
     }
     return mappedMap;
   }
 
-  /**
-   * The `reduce` function iterates over the elements of a LinkedHashMap and applies a callback function to
-   * each element, accumulating a single value.
-   * @param callback - The callback parameter is a function that takes three arguments: accumulator,
-   * element, and map. It is called for each element in the LinkedHashMap and is used to accumulate a single
-   * result.
-   * @param {A} initialValue - The `initialValue` parameter is the initial value of the accumulator. It
-   * is the value that will be passed as the first argument to the `callback` function when reducing
-   * the elements of the map.
-   * @returns The `reduce` function is returning the final value of the accumulator after iterating
-   * over all the elements in the LinkedHashMap and applying the callback function to each element.
-   */
-  reduce<A>(callback: (accumulator: A, element: [K, V], index: number, map: LinkedHashMap<K, V>) => A, initialValue: A): A {
-    let accumulator = initialValue;
-    let index = 0;
-    for (const entry of this) {
-      accumulator = callback(accumulator, entry, index, this);
-      index++;
-    }
-    return accumulator;
+  print() {
+    console.log([...this]);
   }
 
   /**
@@ -727,7 +622,7 @@ export class LinkedHashMap<K = any, V = any> {
    *
    * The above function is an iterator that yields key-value pairs from a linked list.
    */
-  * [Symbol.iterator]() {
+  protected* _getIterator() {
     let node = this._head;
     while (node !== this._sentinel) {
       yield <[K, V]>[node.key, node.value];
@@ -735,10 +630,6 @@ export class LinkedHashMap<K = any, V = any> {
     }
   }
 
-  print() {
-    console.log([...this]);
-  }
-
   /**
    * Time Complexity: O(1)
    * Space Complexity: O(1)