graph-typed 1.47.4 → 1.47.6

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

@@ -20,7 +20,7 @@ export declare class DoublyLinkedList<E = any> {
     /**
      * The constructor initializes the linked list with an empty head, tail, and length.
      */
-    constructor();
+    constructor(elements?: Iterable<E>);
     protected _head: DoublyLinkedListNode<E> | null;
     get head(): DoublyLinkedListNode<E> | null;
     protected _tail: DoublyLinkedListNode<E> | null;
@@ -249,6 +249,23 @@ export declare class DoublyLinkedList<E = any> {
      * insertion fails.
      */
     insertBefore(existingValueOrNode: E | DoublyLinkedListNode<E>, newValue: E): boolean;
+    /**
+     * Time Complexity: O(n), where n is the number of elements in the linked list.
+     * Space Complexity: O(1)
+     */
+    /**
+     * Time Complexity: O(n), where n is the number of elements in the linked list.
+     * Space Complexity: O(1)
+     *
+     * 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
+     * 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 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.
+     */
+    insertAfter(existingValueOrNode: E | DoublyLinkedListNode<E>, newValue: E): boolean;
     /**
      * Time Complexity: O(n), where n is the number of elements in the linked list.
      * Space Complexity: O(1)
@@ -279,18 +296,6 @@ export declare class DoublyLinkedList<E = any> {
      * 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;
-    /**
-     * Time Complexity: O(n), where n is the number of elements in the linked list.
-     * Space Complexity: O(n)
-     */
-    /**
-     * Time Complexity: O(n), where n is the number of elements in the linked list.
-     * Space Complexity: O(n)
-     *
-     * The `toArray` function converts a linked list into an array.
-     * @returns The `toArray()` method is returning an array of type `E[]`.
-     */
-    toArray(): E[];
     /**
      * The function checks if a variable has a length greater than zero and returns a boolean value.
      * @returns A boolean value is being returned.
@@ -346,6 +351,17 @@ export declare class DoublyLinkedList<E = any> {
      * the callback function. If no value satisfies the condition, it returns `null`.
      */
     findBackward(callback: (value: E) => boolean): E | null;
+    /**
+     * Time Complexity: O(n), where n is the number of elements in the linked list.
+     * Space Complexity: O(1)
+     */
+    /**
+     * Time Complexity: O(n), where n is the number of elements in the linked list.
+     * Space Complexity: O(1)
+     *
+     * The `reverse` function reverses the order of the elements in a doubly linked list.
+     */
+    reverse(): void;
     /**
      * Time Complexity: O(n), where n is the number of elements in the linked list.
      * Space Complexity: O(n)
@@ -354,21 +370,26 @@ export declare class DoublyLinkedList<E = any> {
      * Time Complexity: O(n), where n is the number of elements in the linked list.
      * Space Complexity: O(n)
      *
-     * The `toArrayBackward` function converts a doubly linked list into an array in reverse order.
-     * @returns The `toArrayBackward()` function returns an array of type `E[]`.
+     * The `toArray` function converts a linked list into an array.
+     * @returns The `toArray()` method is returning an array of type `E[]`.
      */
-    toArrayBackward(): E[];
+    toArray(): E[];
     /**
      * Time Complexity: O(n), where n is the number of elements in the linked list.
-     * Space Complexity: O(1)
+     * Space Complexity: O(n)
      */
     /**
      * Time Complexity: O(n), where n is the number of elements in the linked list.
-     * Space Complexity: O(1)
+     * Space Complexity: O(n)
      *
-     * The `reverse` function reverses the order of the elements in a doubly linked list.
+     * The `toReversedArray` function converts a doubly linked list into an array in reverse order.
+     * @returns The `toReversedArray()` function returns an array of type `E[]`.
      */
-    reverse(): void;
+    toReversedArray(): E[];
+    /**
+     * The function returns an iterator that iterates over the values of a linked list.
+     */
+    [Symbol.iterator](): Generator<E, void, unknown>;
     /**
      * Time Complexity: O(n), where n is the number of elements in the linked list.
      * Space Complexity: O(1)
@@ -382,7 +403,7 @@ export declare class DoublyLinkedList<E = any> {
      * 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: (value: E, index: number) => void): void;
+    forEach(callback: (value: E, index: number, list: DoublyLinkedList<E>) => void): void;
     /**
      * Time Complexity: O(n), where n is the number of elements in the linked list.
      * Space Complexity: O(n)
@@ -391,14 +412,13 @@ export declare class DoublyLinkedList<E = any> {
      * Time Complexity: O(n), where n is the number of elements in the linked list.
      * Space Complexity: O(n)
      *
-     * The `map` function takes a callback function and applies it to each element in the DoublyLinkedList, returning a new
-     * DoublyLinkedList 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 DoublyLinkedList) and returns a value of type U (the type of values that will be stored in the mapped
-     * DoublyLinkedList).
-     * @returns The `map` function is returning a new instance of `DoublyLinkedList<U>` that contains the mapped values.
+     * The `filter` function iterates through a DoublyLinkedList and returns a new DoublyLinkedList 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 DoublyLinkedList class.
      */
-    map<U>(callback: (value: E) => U): DoublyLinkedList<U>;
+    filter(callback: (value: E, index: number, list: DoublyLinkedList<E>) => boolean): DoublyLinkedList<E>;
     /**
      * Time Complexity: O(n), where n is the number of elements in the linked list.
      * Space Complexity: O(n)
@@ -407,13 +427,14 @@ export declare class DoublyLinkedList<E = any> {
      * Time Complexity: O(n), where n is the number of elements in the linked list.
      * Space Complexity: O(n)
      *
-     * The `filter` function iterates through a DoublyLinkedList and returns a new DoublyLinkedList 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 DoublyLinkedList class.
+     * The `map` function takes a callback function and applies it to each element in the DoublyLinkedList, returning a new
+     * DoublyLinkedList 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 DoublyLinkedList) and returns a value of type T (the type of values that will be stored in the mapped
+     * DoublyLinkedList).
+     * @returns The `map` function is returning a new instance of `DoublyLinkedList<T>` that contains the mapped values.
      */
-    filter(callback: (value: E) => boolean): DoublyLinkedList<E>;
+    map<T>(callback: (value: E, index: number, list: DoublyLinkedList<E>) => T): DoublyLinkedList<T>;
     /**
      * Time Complexity: O(n), where n is the number of elements in the linked list.
      * Space Complexity: O(n)
@@ -426,31 +447,11 @@ export declare class DoublyLinkedList<E = any> {
      * single value.
      * @param callback - The `callback` parameter is a function that takes two arguments: `accumulator` and `value`. 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
+     * @param {T} 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, value: E) => U, initialValue: U): U;
-    /**
-     * Time Complexity: O(n), where n is the number of elements in the linked list.
-     * Space Complexity: O(1)
-     */
-    /**
-     * Time Complexity: O(n), where n is the number of elements in the linked list.
-     * Space Complexity: O(1)
-     *
-     * 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
-     * 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 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.
-     */
-    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>;
+    reduce<T>(callback: (accumulator: T, value: E, index: number, list: DoublyLinkedList<E>) => T, initialValue: T): T;
+    print(): void;
 }

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

@@ -25,10 +25,15 @@ class DoublyLinkedList {
     /**
      * The constructor initializes the linked list with an empty head, tail, and length.
      */
-    constructor() {
+    constructor(elements) {
         this._head = null;
         this._tail = null;
         this._length = 0;
+        if (elements) {
+            for (const el of elements) {
+                this.push(el);
+            }
+        }
     }
     get head() {
         return this._head;
@@ -403,6 +408,46 @@ class DoublyLinkedList {
         }
         return false;
     }
+    /**
+     * Time Complexity: O(n), where n is the number of elements in the linked list.
+     * Space Complexity: O(1)
+     */
+    /**
+     * Time Complexity: O(n), where n is the number of elements in the linked list.
+     * Space Complexity: O(1)
+     *
+     * 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
+     * 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 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.
+     */
+    insertAfter(existingValueOrNode, newValue) {
+        let existingNode;
+        if (existingValueOrNode instanceof DoublyLinkedListNode) {
+            existingNode = existingValueOrNode;
+        }
+        else {
+            existingNode = this.getNode(existingValueOrNode);
+        }
+        if (existingNode) {
+            const newNode = new DoublyLinkedListNode(newValue);
+            newNode.next = existingNode.next;
+            if (existingNode.next) {
+                existingNode.next.prev = newNode;
+            }
+            newNode.prev = existingNode;
+            existingNode.next = newNode;
+            if (existingNode === this.tail) {
+                this._tail = newNode;
+            }
+            this._length++;
+            return true;
+        }
+        return false;
+    }
     /**
      * Time Complexity: O(n), where n is the number of elements in the linked list.
      * Space Complexity: O(1)
@@ -472,26 +517,6 @@ class DoublyLinkedList {
         }
         return false;
     }
-    /**
-     * Time Complexity: O(n), where n is the number of elements in the linked list.
-     * Space Complexity: O(n)
-     */
-    /**
-     * Time Complexity: O(n), where n is the number of elements in the linked list.
-     * Space Complexity: O(n)
-     *
-     * The `toArray` function converts a linked list into an array.
-     * @returns The `toArray()` method is returning an array of type `E[]`.
-     */
-    toArray() {
-        const array = [];
-        let current = this.head;
-        while (current) {
-            array.push(current.value);
-            current = current.next;
-        }
-        return array;
-    }
     /**
      * The function checks if a variable has a length greater than zero and returns a boolean value.
      * @returns A boolean value is being returned.
@@ -582,6 +607,25 @@ class DoublyLinkedList {
         }
         return null;
     }
+    /**
+     * Time Complexity: O(n), where n is the number of elements in the linked list.
+     * Space Complexity: O(1)
+     */
+    /**
+     * Time Complexity: O(n), where n is the number of elements in the linked list.
+     * Space Complexity: O(1)
+     *
+     * The `reverse` function reverses the order of the elements in a doubly linked list.
+     */
+    reverse() {
+        let current = this.head;
+        [this._head, this._tail] = [this.tail, this.head];
+        while (current) {
+            const next = current.next;
+            [current.prev, current.next] = [current.next, current.prev];
+            current = next;
+        }
+    }
     /**
      * Time Complexity: O(n), where n is the number of elements in the linked list.
      * Space Complexity: O(n)
@@ -590,35 +634,46 @@ class DoublyLinkedList {
      * Time Complexity: O(n), where n is the number of elements in the linked list.
      * Space Complexity: O(n)
      *
-     * The `toArrayBackward` function converts a doubly linked list into an array in reverse order.
-     * @returns The `toArrayBackward()` function returns an array of type `E[]`.
+     * The `toArray` function converts a linked list into an array.
+     * @returns The `toArray()` method is returning an array of type `E[]`.
      */
-    toArrayBackward() {
+    toArray() {
         const array = [];
-        let current = this.tail;
+        let current = this.head;
         while (current) {
             array.push(current.value);
-            current = current.prev;
+            current = current.next;
         }
         return array;
     }
     /**
      * Time Complexity: O(n), where n is the number of elements in the linked list.
-     * Space Complexity: O(1)
+     * Space Complexity: O(n)
      */
     /**
      * Time Complexity: O(n), where n is the number of elements in the linked list.
-     * Space Complexity: O(1)
+     * Space Complexity: O(n)
      *
-     * The `reverse` function reverses the order of the elements in a doubly linked list.
+     * The `toReversedArray` function converts a doubly linked list into an array in reverse order.
+     * @returns The `toReversedArray()` function returns an array of type `E[]`.
      */
-    reverse() {
+    toReversedArray() {
+        const array = [];
+        let current = this.tail;
+        while (current) {
+            array.push(current.value);
+            current = current.prev;
+        }
+        return array;
+    }
+    /**
+     * The function returns an iterator that iterates over the values of a linked list.
+     */
+    *[Symbol.iterator]() {
         let current = this.head;
-        [this._head, this._tail] = [this.tail, this.head];
         while (current) {
-            const next = current.next;
-            [current.prev, current.next] = [current.next, current.prev];
-            current = next;
+            yield current.value;
+            current = current.next;
         }
     }
     /**
@@ -635,11 +690,9 @@ class DoublyLinkedList {
      * current node in the linked list.
      */
     forEach(callback) {
-        let current = this.head;
         let index = 0;
-        while (current) {
-            callback(current.value, index);
-            current = current.next;
+        for (const el of this) {
+            callback(el, index, this);
             index++;
         }
     }
@@ -651,21 +704,22 @@ class DoublyLinkedList {
      * Time Complexity: O(n), where n is the number of elements in the linked list.
      * Space Complexity: O(n)
      *
-     * The `map` function takes a callback function and applies it to each element in the DoublyLinkedList, returning a new
-     * DoublyLinkedList 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 DoublyLinkedList) and returns a value of type U (the type of values that will be stored in the mapped
-     * DoublyLinkedList).
-     * @returns The `map` function is returning a new instance of `DoublyLinkedList<U>` that contains the mapped values.
+     * The `filter` function iterates through a DoublyLinkedList and returns a new DoublyLinkedList 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 DoublyLinkedList class.
      */
-    map(callback) {
-        const mappedList = new DoublyLinkedList();
-        let current = this.head;
-        while (current) {
-            mappedList.push(callback(current.value));
-            current = current.next;
+    filter(callback) {
+        const filteredList = new DoublyLinkedList();
+        let index = 0;
+        for (const current of this) {
+            if (callback(current, index, this)) {
+                filteredList.push(current);
+            }
+            index++;
         }
-        return mappedList;
+        return filteredList;
     }
     /**
      * Time Complexity: O(n), where n is the number of elements in the linked list.
@@ -675,22 +729,21 @@ class DoublyLinkedList {
      * Time Complexity: O(n), where n is the number of elements in the linked list.
      * Space Complexity: O(n)
      *
-     * The `filter` function iterates through a DoublyLinkedList and returns a new DoublyLinkedList 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 DoublyLinkedList class.
+     * The `map` function takes a callback function and applies it to each element in the DoublyLinkedList, returning a new
+     * DoublyLinkedList 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 DoublyLinkedList) and returns a value of type T (the type of values that will be stored in the mapped
+     * DoublyLinkedList).
+     * @returns The `map` function is returning a new instance of `DoublyLinkedList<T>` that contains the mapped values.
      */
-    filter(callback) {
-        const filteredList = new DoublyLinkedList();
-        let current = this.head;
-        while (current) {
-            if (callback(current.value)) {
-                filteredList.push(current.value);
-            }
-            current = current.next;
+    map(callback) {
+        const mappedList = new DoublyLinkedList();
+        let index = 0;
+        for (const current of this) {
+            mappedList.push(callback(current, index, this));
+            index++;
         }
-        return filteredList;
+        return mappedList;
     }
     /**
      * Time Complexity: O(n), where n is the number of elements in the linked list.
@@ -704,69 +757,22 @@ class DoublyLinkedList {
      * single value.
      * @param callback - The `callback` parameter is a function that takes two arguments: `accumulator` and `value`. 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
+     * @param {T} 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.value);
-            current = current.next;
+        let index = 0;
+        for (const current of this) {
+            accumulator = callback(accumulator, current, index, this);
+            index++;
         }
         return accumulator;
     }
-    /**
-     * Time Complexity: O(n), where n is the number of elements in the linked list.
-     * Space Complexity: O(1)
-     */
-    /**
-     * Time Complexity: O(n), where n is the number of elements in the linked list.
-     * Space Complexity: O(1)
-     *
-     * 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
-     * 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 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.
-     */
-    insertAfter(existingValueOrNode, newValue) {
-        let existingNode;
-        if (existingValueOrNode instanceof DoublyLinkedListNode) {
-            existingNode = existingValueOrNode;
-        }
-        else {
-            existingNode = this.getNode(existingValueOrNode);
-        }
-        if (existingNode) {
-            const newNode = new DoublyLinkedListNode(newValue);
-            newNode.next = existingNode.next;
-            if (existingNode.next) {
-                existingNode.next.prev = newNode;
-            }
-            newNode.prev = existingNode;
-            existingNode.next = newNode;
-            if (existingNode === this.tail) {
-                this._tail = newNode;
-            }
-            this._length++;
-            return true;
-        }
-        return false;
-    }
-    /**
-     * The function returns an iterator that iterates over the values of a linked list.
-     */
-    *[Symbol.iterator]() {
-        let current = this.head;
-        while (current) {
-            yield current.value;
-            current = current.next;
-        }
+    print() {
+        console.log([...this]);
     }
 }
 exports.DoublyLinkedList = DoublyLinkedList;

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

@@ -19,7 +19,7 @@ export declare class SinglyLinkedList<E = any> {
     /**
      * The constructor initializes the linked list with an empty head, tail, and length.
      */
-    constructor();
+    constructor(elements?: Iterable<E>);
     protected _head: SinglyLinkedListNode<E> | null;
     get head(): SinglyLinkedListNode<E> | null;
     protected _tail: SinglyLinkedListNode<E> | null;
@@ -345,42 +345,30 @@ export declare class SinglyLinkedList<E = any> {
      */
     countOccurrences(value: E): number;
     /**
-     * Time Complexity: O(n) - Linear time, where n is the length of the list, as it needs to reverse the pointers of each node.
-     * Space Complexity: O(1) - Constant space.
+     * The function returns an iterator that iterates over the values of a linked list.
+     */
+    [Symbol.iterator](): Generator<E, void, unknown>;
+    /**
+     * Time Complexity: O(n), where n is the number of elements in the linked list.
+     * Space Complexity: O(1)
      */
     /**
-     * Time Complexity: O(n) - Linear time, where n is the length of the list, as it needs to reverse the pointers of each node.
-     * Space Complexity: O(1) - Constant space.
+     * Time Complexity: O(n), where n is the number of elements in the linked list.
+     * Space Complexity: O(1)
      *
      * 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: value and index. The value 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: (value: E, index: number) => void): void;
-    /**
-     * Time Complexity: O(n) - Linear time, where n is the length of the list, as they need to traverse the entire list to apply the callback or reduce the list.
-     * Space Complexity: O(n) - Linear space, as they create new nodes or arrays.
-     */
-    /**
-     * Time Complexity: O(n) - Linear time, where n is the length of the list, as they need to traverse the entire list to apply the callback or reduce the list.
-     * Space Complexity: O(n) - Linear space, as they create new nodes or arrays.
-     *
-     * 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: (value: E) => U): SinglyLinkedList<U>;
+    forEach(callback: (value: E, index: number, list: SinglyLinkedList<E>) => void): void;
     /**
-     * Time Complexity: O(n) - Linear time, where n is the length of the list, as they need to traverse the entire list to apply the callback or reduce the list.
-     * Space Complexity: O(n) - Linear space, as they create new nodes or arrays.
+     * Time Complexity: O(n), where n is the number of elements in the linked list.
+     * Space Complexity: O(n)
      */
     /**
-     * Time Complexity: O(n) - Linear time, where n is the length of the list, as they need to traverse the entire list to apply the callback or reduce the list.
-     * Space Complexity: O(n) - Linear space, as they create new nodes or arrays.
+     * Time Complexity: O(n), where n is the number of elements in the linked list.
+     * Space Complexity: O(n)
      *
      * The `filter` function iterates through a SinglyLinkedList and returns a new SinglyLinkedList containing only the
      * elements that satisfy the given callback function.
@@ -388,27 +376,40 @@ export declare class SinglyLinkedList<E = any> {
      * 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: (value: E) => boolean): SinglyLinkedList<E>;
+    filter(callback: (value: E, index: number, list: SinglyLinkedList<E>) => boolean): SinglyLinkedList<E>;
     /**
-     * Time Complexity: O(n) - Linear time, where n is the length of the list, as they need to traverse the entire list to apply the callback or reduce the list.
-     * Space Complexity: O(n) - Linear space, as they create new nodes or arrays.
+     * Time Complexity: O(n), where n is the number of elements in the linked list.
+     * Space Complexity: O(n)
      */
     /**
-     * Time Complexity: O(n) - Linear time, where n is the length of the list, as they need to traverse the entire list to apply the callback or reduce the list.
-     * Space Complexity: O(n) - Linear space, as they create new nodes or arrays.
+     * Time Complexity: O(n), where n is the number of elements in the linked list.
+     * Space Complexity: O(n)
+     *
+     * 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 T (the type of values that will be stored in the mapped
+     * SinglyLinkedList).
+     * @returns The `map` function is returning a new instance of `SinglyLinkedList<T>` that contains the mapped values.
+     */
+    map<T>(callback: (value: E, index: number, list: SinglyLinkedList<E>) => T): SinglyLinkedList<T>;
+    /**
+     * Time Complexity: O(n), where n is the number of elements in the linked list.
+     * Space Complexity: O(n)
+     */
+    /**
+     * Time Complexity: O(n), where n is the number of elements in the linked list.
+     * Space Complexity: O(n)
      *
      * 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 `value`. 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
+     * @param {T} 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, value: 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>;
+    reduce<T>(callback: (accumulator: T, value: E, index: number, list: SinglyLinkedList<E>) => T, initialValue: T): T;
+    print(): void;
 }