data-structure-typed 1.39.1 → 1.39.3

package/dist/mjs/data-structures/linked-list/doubly-linked-list.d.ts

@@ -60,11 +60,11 @@ export declare class DoublyLinkedList<E = any> {
      */
     pop(): E | undefined;
     /**
-     * The `pollLast()` function removes and returns the value of the last node in a doubly linked list.
+     * The `popLast()` function removes and returns the value of the last node in a doubly linked list.
      * @returns The method is returning the value of the removed node (removedNode.val) if the list is not empty. If the
      * list is empty, it returns null.
      */
-    pollLast(): E | undefined;
+    popLast(): E | undefined;
     /**
      * The `shift()` function removes and returns the value of the first node in a doubly linked list.
      * @returns The method `shift()` returns the value of the node that is removed from the beginning of the doubly linked
@@ -72,11 +72,11 @@ export declare class DoublyLinkedList<E = any> {
      */
     shift(): E | undefined;
     /**
-     * The `pollFirst()` function removes and returns the value of the first node in a doubly linked list.
+     * The `popFirst()` function removes and returns the value of the first node in a doubly linked list.
      * @returns The method `shift()` returns the value of the node that is removed from the beginning of the doubly linked
      * list.
      */
-    pollFirst(): E | undefined;
+    popFirst(): E | undefined;
     /**
      * The unshift function adds a new node with the given value to the beginning of a doubly linked list.
      * @param {E} val - The `val` parameter represents the value of the new node that will be added to the beginning of the
@@ -90,15 +90,15 @@ export declare class DoublyLinkedList<E = any> {
      */
     addFirst(val: E): void;
     /**
-     * The `peekFirst` function returns the first node in a doubly linked list, or null if the list is empty.
-     * @returns The method `peekFirst()` returns the first node of the doubly linked list, or `null` if the list is empty.
+     * The `getFirst` function returns the first node in a doubly linked list, or null if the list is empty.
+     * @returns The method `getFirst()` returns the first node of the doubly linked list, or `null` if the list is empty.
      */
-    peekFirst(): E | undefined;
+    getFirst(): E | undefined;
     /**
-     * The `peekLast` function returns the last node in a doubly linked list, or null if the list is empty.
-     * @returns The method `peekLast()` returns the last node of the doubly linked list, or `null` if the list is empty.
+     * The `getLast` function returns the last node in a doubly linked list, or null if the list is empty.
+     * @returns The method `getLast()` returns the last node of the doubly linked list, or `null` if the list is empty.
      */
-    peekLast(): E | undefined;
+    getLast(): E | undefined;
     /**
      * The `getAt` function returns the value at a specified index in a linked list, or null if the index is out of bounds.
      * @param {number} index - The index parameter is a number that represents the position of the element we want to
@@ -123,7 +123,7 @@ export declare class DoublyLinkedList<E = any> {
      * @returns The function `findNodeByValue` returns a `DoublyLinkedListNode<E>` if a node with the specified value `val`
      * is found in the linked list. If no such node is found, it returns `null`.
      */
-    findNode(val: E | null): DoublyLinkedListNode<E> | null;
+    getNode(val: E | null): DoublyLinkedListNode<E> | null;
     /**
      * The `insert` function inserts a value at a specified index in a doubly linked list.
      * @param {number} index - The index parameter represents the position at which the new value should be inserted in the
@@ -134,6 +134,17 @@ export declare class DoublyLinkedList<E = any> {
      * if the index is out of bounds.
      */
     insertAt(index: number, val: E): boolean;
+    /**
+     * The `insertBefore` function inserts a new value before an existing value or node in a doubly linked list.
+     * @param {E | DoublyLinkedListNode<E>} existingValueOrNode - The existing value or node in the doubly linked list
+     * before which the new value will be inserted. It can be either the value of the existing node or the existing node
+     * itself.
+     * @param {E} newValue - The `newValue` parameter represents the value that you want to insert into the doubly linked
+     * list.
+     * @returns The method returns a boolean value. It returns `true` if the insertion is successful, and `false` if the
+     * insertion fails.
+     */
+    insertBefore(existingValueOrNode: E | DoublyLinkedListNode<E>, newValue: E): boolean;
     /**
      * The `deleteAt` function removes an element at a specified index from a linked list and returns the removed element.
      * @param {number} index - The index parameter represents the position of the element that needs to be deleted in the
@@ -142,8 +153,14 @@ export declare class DoublyLinkedList<E = any> {
      * bounds.
      */
     deleteAt(index: number): E | undefined;
-    delete(valOrNode: E): boolean;
-    delete(valOrNode: DoublyLinkedListNode<E>): boolean;
+    /**
+     * The `delete` function removes a node from a doubly linked list based on either the node itself or its value.
+     * @param {E | DoublyLinkedListNode<E>} valOrNode - The `valOrNode` parameter can accept either a value of type `E` or
+     * a `DoublyLinkedListNode<E>` object.
+     * @returns The `delete` method returns a boolean value. It returns `true` if the value or node was successfully
+     * deleted from the doubly linked list, and `false` if the value or node was not found in the list.
+     */
+    delete(valOrNode: E | DoublyLinkedListNode<E> | null): boolean;
     /**
      * The `toArray` function converts a linked list into an array.
      * @returns The `toArray()` method is returning an array of type `E[]`.
@@ -175,19 +192,19 @@ export declare class DoublyLinkedList<E = any> {
      */
     indexOf(val: E): number;
     /**
-     * The `findLast` function iterates through a linked list from the last node to the first node and returns the last
+     * The `findBackward` function iterates through a linked list from the last node to the first node and returns the last
      * value that satisfies the given callback function, or null if no value satisfies the callback.
      * @param callback - A function that takes a value of type E as its parameter and returns a boolean value. This
      * function is used to determine whether a given value satisfies a certain condition.
-     * @returns The method `findLast` returns the last value in the linked list that satisfies the condition specified by
+     * @returns The method `findBackward` returns the last value in the linked list that satisfies the condition specified by
      * the callback function. If no value satisfies the condition, it returns `null`.
      */
-    findLast(callback: (val: E) => boolean): E | null;
+    findBackward(callback: (val: E) => boolean): E | null;
     /**
-     * The `toArrayReverse` function converts a doubly linked list into an array in reverse order.
-     * @returns The `toArrayReverse()` function returns an array of type `E[]`.
+     * The `toArrayBackward` function converts a doubly linked list into an array in reverse order.
+     * @returns The `toArrayBackward()` function returns an array of type `E[]`.
      */
-    toArrayReverse(): E[];
+    toArrayBackward(): E[];
     /**
      * The `reverse` function reverses the order of the elements in a doubly linked list.
      */
@@ -227,17 +244,18 @@ export declare class DoublyLinkedList<E = any> {
      * elements in the linked list.
      */
     reduce<U>(callback: (accumulator: U, val: E) => U, initialValue: U): U;
-    insertAfter(existingValueOrNode: E, newValue: E): boolean;
-    insertAfter(existingValueOrNode: DoublyLinkedListNode<E>, newValue: E): boolean;
     /**
-     * The `insertBefore` function inserts a new value before an existing value or node in a doubly linked list.
+     * The `insertAfter` function inserts a new node with a given value after an existing node in a doubly linked list.
      * @param {E | DoublyLinkedListNode<E>} existingValueOrNode - The existing value or node in the doubly linked list
-     * before which the new value will be inserted. It can be either the value of the existing node or the existing node
+     * after which the new value will be inserted. It can be either the value of the existing node or the existing node
      * itself.
-     * @param {E} newValue - The `newValue` parameter represents the value that you want to insert into the doubly linked
-     * list.
-     * @returns The method returns a boolean value. It returns `true` if the insertion is successful, and `false` if the
-     * insertion fails.
+     * @param {E} newValue - The value that you want to insert into the doubly linked list.
+     * @returns The method returns a boolean value. It returns true if the insertion is successful, and false if the
+     * existing value or node is not found in the doubly linked list.
      */
-    insertBefore(existingValueOrNode: E | DoublyLinkedListNode<E>, newValue: E): boolean;
+    insertAfter(existingValueOrNode: E | DoublyLinkedListNode<E>, newValue: E): boolean;
+    /**
+     * The function returns an iterator that iterates over the values of a linked list.
+     */
+    [Symbol.iterator](): Generator<E, void, unknown>;
 }

package/dist/mjs/data-structures/linked-list/doubly-linked-list.js

@@ -130,11 +130,11 @@ class DoublyLinkedList {
         return removedNode.val;
     }
     /**
-     * The `pollLast()` function removes and returns the value of the last node in a doubly linked list.
+     * The `popLast()` function removes and returns the value of the last node in a doubly linked list.
      * @returns The method is returning the value of the removed node (removedNode.val) if the list is not empty. If the
      * list is empty, it returns null.
      */
-    pollLast() {
+    popLast() {
         return this.pop();
     }
     /**
@@ -158,11 +158,11 @@ class DoublyLinkedList {
         return removedNode.val;
     }
     /**
-     * The `pollFirst()` function removes and returns the value of the first node in a doubly linked list.
+     * The `popFirst()` function removes and returns the value of the first node in a doubly linked list.
      * @returns The method `shift()` returns the value of the node that is removed from the beginning of the doubly linked
      * list.
      */
-    pollFirst() {
+    popFirst() {
         return this.shift();
     }
     /**
@@ -192,17 +192,17 @@ class DoublyLinkedList {
         this.unshift(val);
     }
     /**
-     * The `peekFirst` function returns the first node in a doubly linked list, or null if the list is empty.
-     * @returns The method `peekFirst()` returns the first node of the doubly linked list, or `null` if the list is empty.
+     * The `getFirst` function returns the first node in a doubly linked list, or null if the list is empty.
+     * @returns The method `getFirst()` returns the first node of the doubly linked list, or `null` if the list is empty.
      */
-    peekFirst() {
+    getFirst() {
         return this.head?.val;
     }
     /**
-     * The `peekLast` function returns the last node in a doubly linked list, or null if the list is empty.
-     * @returns The method `peekLast()` returns the last node of the doubly linked list, or `null` if the list is empty.
+     * The `getLast` function returns the last node in a doubly linked list, or null if the list is empty.
+     * @returns The method `getLast()` returns the last node of the doubly linked list, or `null` if the list is empty.
      */
-    peekLast() {
+    getLast() {
         return this.tail?.val;
     }
     /**
@@ -245,7 +245,7 @@ class DoublyLinkedList {
      * @returns The function `findNodeByValue` returns a `DoublyLinkedListNode<E>` if a node with the specified value `val`
      * is found in the linked list. If no such node is found, it returns `null`.
      */
-    findNode(val) {
+    getNode(val) {
         let current = this.head;
         while (current) {
             if (current.val === val) {
@@ -285,6 +285,40 @@ class DoublyLinkedList {
         this._length++;
         return true;
     }
+    /**
+     * The `insertBefore` function inserts a new value before an existing value or node in a doubly linked list.
+     * @param {E | DoublyLinkedListNode<E>} existingValueOrNode - The existing value or node in the doubly linked list
+     * before which the new value will be inserted. It can be either the value of the existing node or the existing node
+     * itself.
+     * @param {E} newValue - The `newValue` parameter represents the value that you want to insert into the doubly linked
+     * list.
+     * @returns The method returns a boolean value. It returns `true` if the insertion is successful, and `false` if the
+     * insertion fails.
+     */
+    insertBefore(existingValueOrNode, newValue) {
+        let existingNode;
+        if (existingValueOrNode instanceof DoublyLinkedListNode) {
+            existingNode = existingValueOrNode;
+        }
+        else {
+            existingNode = this.getNode(existingValueOrNode);
+        }
+        if (existingNode) {
+            const newNode = new DoublyLinkedListNode(newValue);
+            newNode.prev = existingNode.prev;
+            if (existingNode.prev) {
+                existingNode.prev.next = newNode;
+            }
+            newNode.next = existingNode;
+            existingNode.prev = newNode;
+            if (existingNode === this.head) {
+                this.head = newNode;
+            }
+            this._length++;
+            return true;
+        }
+        return false;
+    }
     /**
      * The `deleteAt` function removes an element at a specified index from a linked list and returns the removed element.
      * @param {number} index - The index parameter represents the position of the element that needs to be deleted in the
@@ -320,7 +354,7 @@ class DoublyLinkedList {
             node = valOrNode;
         }
         else {
-            node = this.findNode(valOrNode);
+            node = this.getNode(valOrNode);
         }
         if (node) {
             if (node === this.head) {
@@ -405,14 +439,14 @@ class DoublyLinkedList {
         return -1;
     }
     /**
-     * The `findLast` function iterates through a linked list from the last node to the first node and returns the last
+     * The `findBackward` function iterates through a linked list from the last node to the first node and returns the last
      * value that satisfies the given callback function, or null if no value satisfies the callback.
      * @param callback - A function that takes a value of type E as its parameter and returns a boolean value. This
      * function is used to determine whether a given value satisfies a certain condition.
-     * @returns The method `findLast` returns the last value in the linked list that satisfies the condition specified by
+     * @returns The method `findBackward` returns the last value in the linked list that satisfies the condition specified by
      * the callback function. If no value satisfies the condition, it returns `null`.
      */
-    findLast(callback) {
+    findBackward(callback) {
         let current = this.tail;
         while (current) {
             if (callback(current.val)) {
@@ -423,10 +457,10 @@ class DoublyLinkedList {
         return null;
     }
     /**
-     * The `toArrayReverse` function converts a doubly linked list into an array in reverse order.
-     * @returns The `toArrayReverse()` function returns an array of type `E[]`.
+     * The `toArrayBackward` function converts a doubly linked list into an array in reverse order.
+     * @returns The `toArrayBackward()` function returns an array of type `E[]`.
      */
-    toArrayReverse() {
+    toArrayBackward() {
         const array = [];
         let current = this.tail;
         while (current) {
@@ -531,7 +565,7 @@ class DoublyLinkedList {
             existingNode = existingValueOrNode;
         }
         else {
-            existingNode = this.findNode(existingValueOrNode);
+            existingNode = this.getNode(existingValueOrNode);
         }
         if (existingNode) {
             const newNode = new DoublyLinkedListNode(newValue);
@@ -550,38 +584,14 @@ class DoublyLinkedList {
         return false;
     }
     /**
-     * The `insertBefore` function inserts a new value before an existing value or node in a doubly linked list.
-     * @param {E | DoublyLinkedListNode<E>} existingValueOrNode - The existing value or node in the doubly linked list
-     * before which the new value will be inserted. It can be either the value of the existing node or the existing node
-     * itself.
-     * @param {E} newValue - The `newValue` parameter represents the value that you want to insert into the doubly linked
-     * list.
-     * @returns The method returns a boolean value. It returns `true` if the insertion is successful, and `false` if the
-     * insertion fails.
+     * The function returns an iterator that iterates over the values of a linked list.
      */
-    insertBefore(existingValueOrNode, newValue) {
-        let existingNode;
-        if (existingValueOrNode instanceof DoublyLinkedListNode) {
-            existingNode = existingValueOrNode;
-        }
-        else {
-            existingNode = this.findNode(existingValueOrNode);
-        }
-        if (existingNode) {
-            const newNode = new DoublyLinkedListNode(newValue);
-            newNode.prev = existingNode.prev;
-            if (existingNode.prev) {
-                existingNode.prev.next = newNode;
-            }
-            newNode.next = existingNode;
-            existingNode.prev = newNode;
-            if (existingNode === this.head) {
-                this.head = newNode;
-            }
-            this._length++;
-            return true;
+    *[Symbol.iterator]() {
+        let current = this.head;
+        while (current) {
+            yield current.val;
+            current = current.next;
         }
-        return false;
     }
 }
 exports.DoublyLinkedList = DoublyLinkedList;

package/dist/mjs/data-structures/linked-list/singly-linked-list.d.ts

@@ -39,13 +39,18 @@ export declare class SinglyLinkedList<E = any> {
      * @returns The `fromArray` function returns a `SinglyLinkedList` object.
      */
     static fromArray<E>(data: E[]): SinglyLinkedList<E>;
-    getLength(): number;
     /**
-     * The `push` function adds a new node with the given data to the end of a singly linked list.
-     * @param {E} data - The "data" parameter represents the value that you want to add to the linked list. It can be of
+     * The `push` function adds a new node with the given val to the end of a singly linked list.
+     * @param {E} val - The "val" parameter represents the value that you want to add to the linked list. It can be of
      * any type (E) as specified in the generic type declaration of the class or function.
      */
-    push(data: E): void;
+    push(val: E): void;
+    /**
+     * The `push` function adds a new node with the given val to the end of a singly linked list.
+     * @param {E} val - The "val" parameter represents the value that you want to add to the linked list. It can be of
+     * any type (E) as specified in the generic type declaration of the class or function.
+     */
+    addLast(val: E): void;
     /**
      * The `pop()` function removes and returns the value of the last element in a linked list, updating the head and tail
      * pointers accordingly.
@@ -53,17 +58,35 @@ export declare class SinglyLinkedList<E = any> {
      * the linked list is empty, it returns `null`.
      */
     pop(): E | undefined;
+    /**
+     * The `popLast()` function removes and returns the value of the last element in a linked list, updating the head and tail
+     * pointers accordingly.
+     * @returns The method `pop()` returns the value of the node that is being removed from the end of the linked list. If
+     * the linked list is empty, it returns `null`.
+     */
+    popLast(): E | undefined;
     /**
      * The `shift()` function removes and returns the value of the first node in a linked list.
      * @returns The value of the node that is being removed from the beginning of the linked list.
      */
     shift(): E | undefined;
+    /**
+     * The `popFirst()` function removes and returns the value of the first node in a linked list.
+     * @returns The value of the node that is being removed from the beginning of the linked list.
+     */
+    popFirst(): E | undefined;
     /**
      * The unshift function adds a new node with the given value to the beginning of a singly linked list.
      * @param {E} val - The parameter "val" represents the value of the new node that will be added to the beginning of the
      * linked list.
      */
     unshift(val: E): void;
+    /**
+     * The addFirst function adds a new node with the given value to the beginning of a singly linked list.
+     * @param {E} val - The parameter "val" represents the value of the new node that will be added to the beginning of the
+     * linked list.
+     */
+    addFirst(val: E): void;
     /**
      * The function `getAt` returns the value at a specified index in a linked list, or null if the index is out of range.
      * @param {number} index - The index parameter is a number that represents the position of the element we want to
@@ -148,7 +171,7 @@ export declare class SinglyLinkedList<E = any> {
      * @returns a `SinglyLinkedListNode<E>` if a node with the specified value is found in the linked list. If no node with
      * the specified value is found, the function returns `null`.
      */
-    findNode(value: E): SinglyLinkedListNode<E> | null;
+    getNode(value: E): SinglyLinkedListNode<E> | null;
     /**
      * The `insertBefore` function inserts a new value before an existing value in a singly linked list.
      * @param {E | SinglyLinkedListNode<E>} existingValueOrNode - The existing value or node that you want to insert the
@@ -158,13 +181,58 @@ export declare class SinglyLinkedList<E = any> {
      * inserted before the existing value, and `false` otherwise.
      */
     insertBefore(existingValueOrNode: E | SinglyLinkedListNode<E>, newValue: E): boolean;
-    insertAfter(existingValueOrNode: E, newValue: E): boolean;
-    insertAfter(existingValueOrNode: SinglyLinkedListNode<E>, newValue: E): boolean;
+    /**
+     * The `insertAfter` function inserts a new node with a given value after an existing node in a singly linked list.
+     * @param {E | SinglyLinkedListNode<E>} existingValueOrNode - The existing value or node in the linked list after which
+     * the new value will be inserted. It can be either the value of the existing node or the existing node itself.
+     * @param {E} newValue - The value that you want to insert into the linked list after the existing value or node.
+     * @returns The method returns a boolean value. It returns true if the new value was successfully inserted after the
+     * existing value or node, and false if the existing value or node was not found in the linked list.
+     */
+    insertAfter(existingValueOrNode: E | SinglyLinkedListNode<E>, newValue: E): boolean;
     /**
      * The function counts the number of occurrences of a given value in a linked list.
      * @param {E} value - The value parameter is the value that you want to count the occurrences of in the linked list.
      * @returns The count of occurrences of the given value in the linked list.
      */
     countOccurrences(value: E): number;
+    /**
+     * The `forEach` function iterates over each element in a linked list and applies a callback function to each element.
+     * @param callback - The callback parameter is a function that takes two arguments: val and index. The val argument
+     * represents the value of the current node in the linked list, and the index argument represents the index of the
+     * current node in the linked list.
+     */
+    forEach(callback: (val: E, index: number) => void): void;
+    /**
+     * The `map` function takes a callback function and applies it to each element in the SinglyLinkedList, returning a new
+     * SinglyLinkedList with the transformed values.
+     * @param callback - The callback parameter is a function that takes a value of type E (the type of values stored in
+     * the original SinglyLinkedList) and returns a value of type U (the type of values that will be stored in the mapped
+     * SinglyLinkedList).
+     * @returns The `map` function is returning a new instance of `SinglyLinkedList<U>` that contains the mapped values.
+     */
+    map<U>(callback: (val: E) => U): SinglyLinkedList<U>;
+    /**
+     * The `filter` function iterates through a SinglyLinkedList and returns a new SinglyLinkedList containing only the
+     * elements that satisfy the given callback function.
+     * @param callback - The `callback` parameter is a function that takes a value of type `E` and returns a boolean value.
+     * It is used to determine whether a value should be included in the filtered list or not.
+     * @returns The filtered list, which is an instance of the SinglyLinkedList class.
+     */
+    filter(callback: (val: E) => boolean): SinglyLinkedList<E>;
+    /**
+     * The `reduce` function iterates over a linked list and applies a callback function to each element, accumulating a
+     * single value.
+     * @param callback - The `callback` parameter is a function that takes two arguments: `accumulator` and `val`. It is
+     * used to perform a specific operation on each element of the linked list.
+     * @param {U} initialValue - The `initialValue` parameter is the initial value of the accumulator. It is the starting
+     * point for the reduction operation.
+     * @returns The `reduce` method is returning the final value of the accumulator after iterating through all the
+     * elements in the linked list.
+     */
+    reduce<U>(callback: (accumulator: U, val: E) => U, initialValue: U): U;
+    /**
+     * The function returns an iterator that iterates over the values of a linked list.
+     */
     [Symbol.iterator](): Generator<E, void, unknown>;
 }

package/dist/mjs/data-structures/linked-list/singly-linked-list.js

@@ -74,16 +74,13 @@ class SinglyLinkedList {
         }
         return singlyLinkedList;
     }
-    getLength() {
-        return this._length;
-    }
     /**
-     * The `push` function adds a new node with the given data to the end of a singly linked list.
-     * @param {E} data - The "data" parameter represents the value that you want to add to the linked list. It can be of
+     * The `push` function adds a new node with the given val to the end of a singly linked list.
+     * @param {E} val - The "val" parameter represents the value that you want to add to the linked list. It can be of
      * any type (E) as specified in the generic type declaration of the class or function.
      */
-    push(data) {
-        const newNode = new SinglyLinkedListNode(data);
+    push(val) {
+        const newNode = new SinglyLinkedListNode(val);
         if (!this.head) {
             this.head = newNode;
             this.tail = newNode;
@@ -94,6 +91,14 @@ class SinglyLinkedList {
         }
         this._length++;
     }
+    /**
+     * The `push` function adds a new node with the given val to the end of a singly linked list.
+     * @param {E} val - The "val" parameter represents the value that you want to add to the linked list. It can be of
+     * any type (E) as specified in the generic type declaration of the class or function.
+     */
+    addLast(val) {
+        this.push(val);
+    }
     /**
      * The `pop()` function removes and returns the value of the last element in a linked list, updating the head and tail
      * pointers accordingly.
@@ -120,6 +125,15 @@ class SinglyLinkedList {
         this._length--;
         return val;
     }
+    /**
+     * The `popLast()` function removes and returns the value of the last element in a linked list, updating the head and tail
+     * pointers accordingly.
+     * @returns The method `pop()` returns the value of the node that is being removed from the end of the linked list. If
+     * the linked list is empty, it returns `null`.
+     */
+    popLast() {
+        return this.pop();
+    }
     /**
      * The `shift()` function removes and returns the value of the first node in a linked list.
      * @returns The value of the node that is being removed from the beginning of the linked list.
@@ -132,6 +146,13 @@ class SinglyLinkedList {
         this._length--;
         return removedNode.val;
     }
+    /**
+     * The `popFirst()` function removes and returns the value of the first node in a linked list.
+     * @returns The value of the node that is being removed from the beginning of the linked list.
+     */
+    popFirst() {
+        return this.shift();
+    }
     /**
      * The unshift function adds a new node with the given value to the beginning of a singly linked list.
      * @param {E} val - The parameter "val" represents the value of the new node that will be added to the beginning of the
@@ -149,6 +170,14 @@ class SinglyLinkedList {
         }
         this._length++;
     }
+    /**
+     * The addFirst function adds a new node with the given value to the beginning of a singly linked list.
+     * @param {E} val - The parameter "val" represents the value of the new node that will be added to the beginning of the
+     * linked list.
+     */
+    addFirst(val) {
+        this.unshift(val);
+    }
     /**
      * The function `getAt` returns the value at a specified index in a linked list, or null if the index is out of range.
      * @param {number} index - The index parameter is a number that represents the position of the element we want to
@@ -355,7 +384,7 @@ class SinglyLinkedList {
      * @returns a `SinglyLinkedListNode<E>` if a node with the specified value is found in the linked list. If no node with
      * the specified value is found, the function returns `null`.
      */
-    findNode(value) {
+    getNode(value) {
         let current = this.head;
         while (current) {
             if (current.val === value) {
@@ -414,7 +443,7 @@ class SinglyLinkedList {
             existingNode = existingValueOrNode;
         }
         else {
-            existingNode = this.findNode(existingValueOrNode);
+            existingNode = this.getNode(existingValueOrNode);
         }
         if (existingNode) {
             const newNode = new SinglyLinkedListNode(newValue);
@@ -444,6 +473,78 @@ class SinglyLinkedList {
         }
         return count;
     }
+    /**
+     * The `forEach` function iterates over each element in a linked list and applies a callback function to each element.
+     * @param callback - The callback parameter is a function that takes two arguments: val and index. The val argument
+     * represents the value of the current node in the linked list, and the index argument represents the index of the
+     * current node in the linked list.
+     */
+    forEach(callback) {
+        let current = this.head;
+        let index = 0;
+        while (current) {
+            callback(current.val, index);
+            current = current.next;
+            index++;
+        }
+    }
+    /**
+     * The `map` function takes a callback function and applies it to each element in the SinglyLinkedList, returning a new
+     * SinglyLinkedList with the transformed values.
+     * @param callback - The callback parameter is a function that takes a value of type E (the type of values stored in
+     * the original SinglyLinkedList) and returns a value of type U (the type of values that will be stored in the mapped
+     * SinglyLinkedList).
+     * @returns The `map` function is returning a new instance of `SinglyLinkedList<U>` that contains the mapped values.
+     */
+    map(callback) {
+        const mappedList = new SinglyLinkedList();
+        let current = this.head;
+        while (current) {
+            mappedList.push(callback(current.val));
+            current = current.next;
+        }
+        return mappedList;
+    }
+    /**
+     * The `filter` function iterates through a SinglyLinkedList and returns a new SinglyLinkedList containing only the
+     * elements that satisfy the given callback function.
+     * @param callback - The `callback` parameter is a function that takes a value of type `E` and returns a boolean value.
+     * It is used to determine whether a value should be included in the filtered list or not.
+     * @returns The filtered list, which is an instance of the SinglyLinkedList class.
+     */
+    filter(callback) {
+        const filteredList = new SinglyLinkedList();
+        let current = this.head;
+        while (current) {
+            if (callback(current.val)) {
+                filteredList.push(current.val);
+            }
+            current = current.next;
+        }
+        return filteredList;
+    }
+    /**
+     * The `reduce` function iterates over a linked list and applies a callback function to each element, accumulating a
+     * single value.
+     * @param callback - The `callback` parameter is a function that takes two arguments: `accumulator` and `val`. It is
+     * used to perform a specific operation on each element of the linked list.
+     * @param {U} initialValue - The `initialValue` parameter is the initial value of the accumulator. It is the starting
+     * point for the reduction operation.
+     * @returns The `reduce` method is returning the final value of the accumulator after iterating through all the
+     * elements in the linked list.
+     */
+    reduce(callback, initialValue) {
+        let accumulator = initialValue;
+        let current = this.head;
+        while (current) {
+            accumulator = callback(accumulator, current.val);
+            current = current.next;
+        }
+        return accumulator;
+    }
+    /**
+     * The function returns an iterator that iterates over the values of a linked list.
+     */
     *[Symbol.iterator]() {
         let current = this.head;
         while (current) {