ts-data-forge 2.1.2 → 2.1.3

package/dist/json/json.mjs

@@ -71,7 +71,7 @@ var Json;
         }
         catch (error) {
             const errStr = unknownToString(error);
-            return Result.err(Result.isOk(errStr) ? errStr.value : 'Failed to parse JSON');
+            return Result.err(errStr);
         }
     };
     /**
@@ -120,7 +120,7 @@ var Json;
         }
         catch (error) {
             const errStr = unknownToString(error);
-            return Result.err(Result.isOk(errStr) ? errStr.value : 'Failed to stringify JSON');
+            return Result.err(errStr);
         }
     };
     /**
@@ -165,7 +165,7 @@ var Json;
         }
         catch (error) {
             const errStr = unknownToString(error);
-            return Result.err(Result.isOk(errStr) ? errStr.value : 'Failed to stringify JSON');
+            return Result.err(errStr);
         }
     };
     /**

package/dist/json/json.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"json.mjs","sources":["../../src/json/json.mts"],"sourcesContent":[null],"names":[],"mappings":"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"}
+{"version":3,"file":"json.mjs","sources":["../../src/json/json.mts"],"sourcesContent":[null],"names":[],"mappings":"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"}

package/dist/others/unknown-to-string.d.mts

@@ -1,4 +1,3 @@
-import { Result } from '../functional/index.mjs';
 /**
  * Converts an unknown value to its string representation in a type-safe manner.
  *
@@ -18,22 +17,22 @@ import { Result } from '../functional/index.mjs';
  * @param value - The unknown value to convert to string
  * @param options - Optional configuration for the conversion
  * @param options.prettyPrintObject - If true, objects are formatted with 2-space indentation
- * @returns A Result containing either the string representation or an Error for failures
+ * @returns The string representation of the value. For circular references or non-serializable objects, returns an error message string
  *
  * @example Basic type conversions
  * ```typescript
  * // Primitive types
- * unknownToString('hello');        // Ok('hello')
- * unknownToString(123);            // Ok('123')
- * unknownToString(true);           // Ok('true')
- * unknownToString(null);           // Ok('null')
- * unknownToString(undefined);      // Ok('undefined')
- * unknownToString(Symbol('test')); // Ok('Symbol(test)')
- * unknownToString(123n);           // Ok('123')
+ * unknownToString('hello');        // 'hello'
+ * unknownToString(123);            // '123'
+ * unknownToString(true);           // 'true'
+ * unknownToString(null);           // 'null'
+ * unknownToString(undefined);      // 'undefined'
+ * unknownToString(Symbol('test')); // 'Symbol(test)'
+ * unknownToString(123n);           // '123'
  *
  * // Function conversion
  * const fn = () => 'test';
- * unknownToString(fn); // Ok('() => 'test'')
+ * unknownToString(fn); // "() => 'test'"
  * ```
  *
  * @example Object stringification
@@ -41,24 +40,20 @@ import { Result } from '../functional/index.mjs';
  * // Simple object
  * const obj = { a: 1, b: 'hello', c: [1, 2, 3] };
  * const result = unknownToString(obj);
- * if (Result.isOk(result)) {
- *   console.log(result.value); // '{"a":1,"b":"hello","c":[1,2,3]}'
- * }
+ * console.log(result); // '{"a":1,"b":"hello","c":[1,2,3]}'
  *
  * // Pretty printing
  * const prettyResult = unknownToString(obj, { prettyPrintObject: true });
- * if (Result.isOk(prettyResult)) {
- *   console.log(prettyResult.value);
- *   // {
- *   //   "a": 1,
- *   //   "b": "hello",
- *   //   "c": [
- *   //     1,
- *   //     2,
- *   //     3
- *   //   ]
- *   // }
- * }
+ * console.log(prettyResult);
+ * // {
+ * //   "a": 1,
+ * //   "b": "hello",
+ * //   "c": [
+ * //     1,
+ * //     2,
+ * //     3
+ * //   ]
+ * // }
  * ```
  *
  * @example Error handling for circular references
@@ -68,19 +63,7 @@ import { Result } from '../functional/index.mjs';
  * circular.self = circular;
  *
  * const result = unknownToString(circular);
- * if (Result.isErr(result)) {
- *   console.log(result.value.message);
- *   // "Converting circular structure to JSON"
- * }
- *
- * // Handle with custom serialization
- * const safeStringify = (value: unknown): string => {
- *   const result = unknownToString(value);
- *   return Result.isOk(result)
- *     ? result.value
- *     : `[Error: ${result.value.message}]`;
- * };
- * ```
+ * console.log(result); // "Converting circular structure to JSON"
  *
  * @example Logging and debugging utilities
  * ```typescript
@@ -90,13 +73,9 @@ import { Result } from '../functional/index.mjs';
  *     const timestamp = new Date().toISOString();
  *     const dataStr = data !== undefined
  *       ? unknownToString(data, { prettyPrintObject: true })
- *       : Result.ok('');
+ *       : '';
  *
- *     if (Result.isOk(dataStr)) {
- *       console.log(`[${timestamp}] ${message}`, dataStr.value);
- *     } else {
- *       console.log(`[${timestamp}] ${message} [Unstringifiable data]`);
- *     }
+ *     console.log(`[${timestamp}] ${message}`, dataStr);
  *   }
  * }
  *
@@ -108,19 +87,11 @@ import { Result } from '../functional/index.mjs';
  * ```typescript
  * // Safe error response formatting
  * function formatErrorResponse(error: unknown): string {
- *   const result = unknownToString(error, { prettyPrintObject: true });
+ *   const errorStr = unknownToString(error, { prettyPrintObject: true });
  *
- *   if (Result.isOk(result)) {
- *     return JSON.stringify({
- *       success: false,
- *       error: result.value
- *     });
- *   }
- *
- *   // Fallback for unstringifiable errors
  *   return JSON.stringify({
  *     success: false,
- *     error: 'An unknown error occurred'
+ *     error: errorStr
  *   });
  * }
  *
@@ -136,45 +107,41 @@ import { Result } from '../functional/index.mjs';
  * ```typescript
  * // Date objects
  * unknownToString(new Date('2023-01-01'));
- * // Ok('"2023-01-01T00:00:00.000Z"') - JSON stringified
+ * // '"2023-01-01T00:00:00.000Z"' - JSON stringified
  *
  * // Regular expressions
  * unknownToString(/test/gi);
- * // Ok('{}') - RegExp has no enumerable properties
+ * // '{}' - RegExp has no enumerable properties
  *
  * // Arrays
  * unknownToString([1, 'two', { three: 3 }]);
- * // Ok('[1,"two",{"three":3}]')
+ * // '[1,"two",{"three":3}]'
  *
  * // Map and Set (converted to empty objects by JSON.stringify)
- * unknownToString(new Map([['a', 1]])); // Ok('{}')
- * unknownToString(new Set([1, 2, 3]));   // Ok('{}')
+ * unknownToString(new Map([['a', 1]])); // '{}'
+ * unknownToString(new Set([1, 2, 3]));   // '{}'
  * ```
  *
- * @example Integration with Result type
+ * @example Using with validation
  * ```typescript
- * import { Result, pipe } from '../functional';
- *
- * // Chain with other Result operations
- * function processUserInput(input: unknown): Result<string, Error> {
- *   return pipe(input)
- *     .map(val => unknownToString(val))
- *     .map(Result.flatten) // Flatten Result<Result<string, Error>, never>
- *     .map(str => Result.map(str, s => s.trim()))
- *     .map(Result.flatten)
- *     .map(str => Result.flatMap(str, s =>
- *       s.length > 0
- *         ? Result.ok(s)
- *         : Result.err(new Error('Empty string'))
- *     ))
- *     .value;
+ * // Simple validation helper
+ * function validateAndStringify(input: unknown): string {
+ *   const str = unknownToString(input);
+ *   const trimmed = str.trim();
+ *
+ *   if (trimmed.length === 0) {
+ *     throw new Error('Empty string');
+ *   }
+ *
+ *   return trimmed;
  * }
  * ```
  *
- * @see Result - For error handling pattern used by this function
+ * **Error Handling:**
+ * Circular references and non-serializable objects return descriptive error messages instead of throwing
  * @see JSON.stringify - Underlying serialization for objects
  */
 export declare const unknownToString: (value: unknown, options?: Partial<Readonly<{
     prettyPrintObject: boolean;
-}>>) => Result<string, Error>;
+}>>) => string;
 //# sourceMappingURL=unknown-to-string.d.mts.map

package/dist/others/unknown-to-string.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"unknown-to-string.d.mts","sourceRoot":"","sources":["../../src/others/unknown-to-string.mts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,MAAM,yBAAyB,CAAC;AAGjD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8KG;AACH,eAAO,MAAM,eAAe,GAC1B,OAAO,OAAO,EACd,UAAU,OAAO,CAAC,QAAQ,CAAC;IAAE,iBAAiB,EAAE,OAAO,CAAA;CAAE,CAAC,CAAC,KAC1D,MAAM,CAAC,MAAM,EAAE,KAAK,CAiCtB,CAAC"}
+{"version":3,"file":"unknown-to-string.d.mts","sourceRoot":"","sources":["../../src/others/unknown-to-string.mts"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8IG;AACH,eAAO,MAAM,eAAe,GAC1B,OAAO,OAAO,EACd,UAAU,OAAO,CAAC,QAAQ,CAAC;IAAE,iBAAiB,EAAE,OAAO,CAAA;CAAE,CAAC,CAAC,KAC1D,MA+BF,CAAC"}

package/dist/others/unknown-to-string.mjs

@@ -1,6 +1,4 @@
 import { isNonNullish } from '../guard/is-type.mjs';
-import '../functional/optional.mjs';
-import { Result } from '../functional/result.mjs';
 
 /**
  * Converts an unknown value to its string representation in a type-safe manner.
@@ -21,22 +19,22 @@ import { Result } from '../functional/result.mjs';
  * @param value - The unknown value to convert to string
  * @param options - Optional configuration for the conversion
  * @param options.prettyPrintObject - If true, objects are formatted with 2-space indentation
- * @returns A Result containing either the string representation or an Error for failures
+ * @returns The string representation of the value. For circular references or non-serializable objects, returns an error message string
  *
  * @example Basic type conversions
  * ```typescript
  * // Primitive types
- * unknownToString('hello');        // Ok('hello')
- * unknownToString(123);            // Ok('123')
- * unknownToString(true);           // Ok('true')
- * unknownToString(null);           // Ok('null')
- * unknownToString(undefined);      // Ok('undefined')
- * unknownToString(Symbol('test')); // Ok('Symbol(test)')
- * unknownToString(123n);           // Ok('123')
+ * unknownToString('hello');        // 'hello'
+ * unknownToString(123);            // '123'
+ * unknownToString(true);           // 'true'
+ * unknownToString(null);           // 'null'
+ * unknownToString(undefined);      // 'undefined'
+ * unknownToString(Symbol('test')); // 'Symbol(test)'
+ * unknownToString(123n);           // '123'
  *
  * // Function conversion
  * const fn = () => 'test';
- * unknownToString(fn); // Ok('() => 'test'')
+ * unknownToString(fn); // "() => 'test'"
  * ```
  *
  * @example Object stringification
@@ -44,24 +42,20 @@ import { Result } from '../functional/result.mjs';
  * // Simple object
  * const obj = { a: 1, b: 'hello', c: [1, 2, 3] };
  * const result = unknownToString(obj);
- * if (Result.isOk(result)) {
- *   console.log(result.value); // '{"a":1,"b":"hello","c":[1,2,3]}'
- * }
+ * console.log(result); // '{"a":1,"b":"hello","c":[1,2,3]}'
  *
  * // Pretty printing
  * const prettyResult = unknownToString(obj, { prettyPrintObject: true });
- * if (Result.isOk(prettyResult)) {
- *   console.log(prettyResult.value);
- *   // {
- *   //   "a": 1,
- *   //   "b": "hello",
- *   //   "c": [
- *   //     1,
- *   //     2,
- *   //     3
- *   //   ]
- *   // }
- * }
+ * console.log(prettyResult);
+ * // {
+ * //   "a": 1,
+ * //   "b": "hello",
+ * //   "c": [
+ * //     1,
+ * //     2,
+ * //     3
+ * //   ]
+ * // }
  * ```
  *
  * @example Error handling for circular references
@@ -71,19 +65,7 @@ import { Result } from '../functional/result.mjs';
  * circular.self = circular;
  *
  * const result = unknownToString(circular);
- * if (Result.isErr(result)) {
- *   console.log(result.value.message);
- *   // "Converting circular structure to JSON"
- * }
- *
- * // Handle with custom serialization
- * const safeStringify = (value: unknown): string => {
- *   const result = unknownToString(value);
- *   return Result.isOk(result)
- *     ? result.value
- *     : `[Error: ${result.value.message}]`;
- * };
- * ```
+ * console.log(result); // "Converting circular structure to JSON"
  *
  * @example Logging and debugging utilities
  * ```typescript
@@ -93,13 +75,9 @@ import { Result } from '../functional/result.mjs';
  *     const timestamp = new Date().toISOString();
  *     const dataStr = data !== undefined
  *       ? unknownToString(data, { prettyPrintObject: true })
- *       : Result.ok('');
+ *       : '';
  *
- *     if (Result.isOk(dataStr)) {
- *       console.log(`[${timestamp}] ${message}`, dataStr.value);
- *     } else {
- *       console.log(`[${timestamp}] ${message} [Unstringifiable data]`);
- *     }
+ *     console.log(`[${timestamp}] ${message}`, dataStr);
  *   }
  * }
  *
@@ -111,19 +89,11 @@ import { Result } from '../functional/result.mjs';
  * ```typescript
  * // Safe error response formatting
  * function formatErrorResponse(error: unknown): string {
- *   const result = unknownToString(error, { prettyPrintObject: true });
+ *   const errorStr = unknownToString(error, { prettyPrintObject: true });
  *
- *   if (Result.isOk(result)) {
- *     return JSON.stringify({
- *       success: false,
- *       error: result.value
- *     });
- *   }
- *
- *   // Fallback for unstringifiable errors
  *   return JSON.stringify({
  *     success: false,
- *     error: 'An unknown error occurred'
+ *     error: errorStr
  *   });
  * }
  *
@@ -139,71 +109,67 @@ import { Result } from '../functional/result.mjs';
  * ```typescript
  * // Date objects
  * unknownToString(new Date('2023-01-01'));
- * // Ok('"2023-01-01T00:00:00.000Z"') - JSON stringified
+ * // '"2023-01-01T00:00:00.000Z"' - JSON stringified
  *
  * // Regular expressions
  * unknownToString(/test/gi);
- * // Ok('{}') - RegExp has no enumerable properties
+ * // '{}' - RegExp has no enumerable properties
  *
  * // Arrays
  * unknownToString([1, 'two', { three: 3 }]);
- * // Ok('[1,"two",{"three":3}]')
+ * // '[1,"two",{"three":3}]'
  *
  * // Map and Set (converted to empty objects by JSON.stringify)
- * unknownToString(new Map([['a', 1]])); // Ok('{}')
- * unknownToString(new Set([1, 2, 3]));   // Ok('{}')
+ * unknownToString(new Map([['a', 1]])); // '{}'
+ * unknownToString(new Set([1, 2, 3]));   // '{}'
  * ```
  *
- * @example Integration with Result type
+ * @example Using with validation
  * ```typescript
- * import { Result, pipe } from '../functional';
- *
- * // Chain with other Result operations
- * function processUserInput(input: unknown): Result<string, Error> {
- *   return pipe(input)
- *     .map(val => unknownToString(val))
- *     .map(Result.flatten) // Flatten Result<Result<string, Error>, never>
- *     .map(str => Result.map(str, s => s.trim()))
- *     .map(Result.flatten)
- *     .map(str => Result.flatMap(str, s =>
- *       s.length > 0
- *         ? Result.ok(s)
- *         : Result.err(new Error('Empty string'))
- *     ))
- *     .value;
+ * // Simple validation helper
+ * function validateAndStringify(input: unknown): string {
+ *   const str = unknownToString(input);
+ *   const trimmed = str.trim();
+ *
+ *   if (trimmed.length === 0) {
+ *     throw new Error('Empty string');
+ *   }
+ *
+ *   return trimmed;
  * }
  * ```
  *
- * @see Result - For error handling pattern used by this function
+ * **Error Handling:**
+ * Circular references and non-serializable objects return descriptive error messages instead of throwing
  * @see JSON.stringify - Underlying serialization for objects
  */
 const unknownToString = (value, options) => {
     switch (typeof value) {
         case 'string':
-            return Result.ok(value);
+            return value;
         case 'number':
         case 'bigint':
         case 'boolean':
         case 'symbol':
         case 'function':
-            return Result.ok(value.toString());
+            return value.toString();
         case 'object':
             if (!isNonNullish(value)) {
-                return Result.ok('null');
+                return 'null';
             }
             try {
                 const stringified = options?.prettyPrintObject === true
                     ? JSON.stringify(value, undefined, 2)
                     : JSON.stringify(value);
-                return Result.ok(stringified);
+                return stringified;
             }
             catch (error) {
-                return Result.err(error instanceof Error
-                    ? error
-                    : new Error('Failed to stringify object'));
+                return error instanceof Error
+                    ? error.message
+                    : '[Circular or Non-serializable]';
             }
         case 'undefined':
-            return Result.ok('undefined');
+            return 'undefined';
     }
 };
 

package/dist/others/unknown-to-string.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"unknown-to-string.mjs","sources":["../../src/others/unknown-to-string.mts"],"sourcesContent":[null],"names":[],"mappings":";;;;AAGA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA8KG;MACU,eAAe,GAAG,CAC7B,KAAc,EACd,OAA2D,KAClC;IACzB,QAAQ,OAAO,KAAK;AAClB,QAAA,KAAK,QAAQ;AACX,YAAA,OAAO,MAAM,CAAC,EAAE,CAAC,KAAK,CAAC;AAEzB,QAAA,KAAK,QAAQ;AACb,QAAA,KAAK,QAAQ;AACb,QAAA,KAAK,SAAS;AACd,QAAA,KAAK,QAAQ;AACb,QAAA,KAAK,UAAU;YACb,OAAO,MAAM,CAAC,EAAE,CAAC,KAAK,CAAC,QAAQ,EAAE,CAAC;AAEpC,QAAA,KAAK,QAAQ;AACX,YAAA,IAAI,CAAC,YAAY,CAAC,KAAK,CAAC,EAAE;AACxB,gBAAA,OAAO,MAAM,CAAC,EAAE,CAAC,MAAM,CAAC;YAC1B;AACA,YAAA,IAAI;AACF,gBAAA,MAAM,WAAW,GACf,OAAO,EAAE,iBAAiB,KAAK;sBAC3B,IAAI,CAAC,SAAS,CAAC,KAAK,EAAE,SAAS,EAAE,CAAC;AACpC,sBAAE,IAAI,CAAC,SAAS,CAAC,KAAK,CAAC;AAC3B,gBAAA,OAAO,MAAM,CAAC,EAAE,CAAC,WAAW,CAAC;YAC/B;YAAE,OAAO,KAAK,EAAE;AACd,gBAAA,OAAO,MAAM,CAAC,GAAG,CACf,KAAK,YAAY;AACf,sBAAE;AACF,sBAAE,IAAI,KAAK,CAAC,4BAA4B,CAAC,CAC5C;YACH;AAEF,QAAA,KAAK,WAAW;AACd,YAAA,OAAO,MAAM,CAAC,EAAE,CAAC,WAAW,CAAC;;AAEnC;;;;"}
+{"version":3,"file":"unknown-to-string.mjs","sources":["../../src/others/unknown-to-string.mts"],"sourcesContent":[null],"names":[],"mappings":";;AAEA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA8IG;MACU,eAAe,GAAG,CAC7B,KAAc,EACd,OAA2D,KACjD;IACV,QAAQ,OAAO,KAAK;AAClB,QAAA,KAAK,QAAQ;AACX,YAAA,OAAO,KAAK;AAEd,QAAA,KAAK,QAAQ;AACb,QAAA,KAAK,QAAQ;AACb,QAAA,KAAK,SAAS;AACd,QAAA,KAAK,QAAQ;AACb,QAAA,KAAK,UAAU;AACb,YAAA,OAAO,KAAK,CAAC,QAAQ,EAAE;AAEzB,QAAA,KAAK,QAAQ;AACX,YAAA,IAAI,CAAC,YAAY,CAAC,KAAK,CAAC,EAAE;AACxB,gBAAA,OAAO,MAAM;YACf;AACA,YAAA,IAAI;AACF,gBAAA,MAAM,WAAW,GACf,OAAO,EAAE,iBAAiB,KAAK;sBAC3B,IAAI,CAAC,SAAS,CAAC,KAAK,EAAE,SAAS,EAAE,CAAC;AACpC,sBAAE,IAAI,CAAC,SAAS,CAAC,KAAK,CAAC;AAC3B,gBAAA,OAAO,WAAW;YACpB;YAAE,OAAO,KAAK,EAAE;gBACd,OAAO,KAAK,YAAY;sBACpB,KAAK,CAAC;sBACN,gCAAgC;YACtC;AAEF,QAAA,KAAK,WAAW;AACd,YAAA,OAAO,WAAW;;AAExB;;;;"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ts-data-forge",
-  "version": "2.1.2",
+  "version": "2.1.3",
   "private": false,
   "keywords": [
     "typescript",

package/src/array/array-utils.mts

@@ -3460,11 +3460,7 @@ export namespace Arr {
       return Result.ok(result);
     } catch (error) {
       return Result.err(
-        error instanceof Error
-          ? error
-          : pipe(unknownToString(error))
-              .map(Result.unwrapOkOr('Failed to join array'))
-              .map((e) => new Error(e)).value,
+        error instanceof Error ? error : new Error(unknownToString(error)),
       );
     }
   };

package/src/collections/imap.mts

@@ -1,4 +1,4 @@
-import { Optional, Result } from '../functional/index.mjs';
+import { Optional } from '../functional/index.mjs';
 import { asUint32 } from '../number/index.mjs';
 import { tp, unknownToString } from '../others/index.mjs';
 
@@ -487,9 +487,7 @@ class IMapClass<K extends MapSetKeyType, V>
     if (!this.has(key)) {
       if (this.#showNotFoundMessage) {
         const keyStr = unknownToString(key);
-        console.warn(
-          `IMap.delete: key not found: ${Result.isOk(keyStr) ? keyStr.value : '<error converting key to string>'}`,
-        );
+        console.warn(`IMap.delete: key not found: ${keyStr}`);
       }
       return this;
     }
@@ -518,9 +516,7 @@ class IMapClass<K extends MapSetKeyType, V>
     if (Optional.isNone(curr)) {
       if (this.#showNotFoundMessage) {
         const keyStr = unknownToString(key);
-        console.warn(
-          `IMap.update: key not found: ${Result.isOk(keyStr) ? keyStr.value : '<error converting key to string>'}`,
-        );
+        console.warn(`IMap.update: key not found: ${keyStr}`);
       }
       return this;
     }
@@ -560,9 +556,7 @@ class IMapClass<K extends MapSetKeyType, V>
           if (!mut_result.has(key) || curr === undefined) {
             if (this.#showNotFoundMessage) {
               const keyStr = unknownToString(key);
-              console.warn(
-                `IMap.withMutations: key not found: ${Result.isOk(keyStr) ? keyStr.value : '<error converting key to string>'}`,
-              );
+              console.warn(`IMap.withMutations: key not found: ${keyStr}`);
             }
             break;
           }

package/src/collections/iset.mts

@@ -1,4 +1,4 @@
-import { Result } from '../functional/index.mjs';
+// No imports from functional needed anymore
 import { asUint32 } from '../number/index.mjs';
 import { unknownToString } from '../others/index.mjs';
 
@@ -560,9 +560,7 @@ class ISetClass<K extends MapSetKeyType> implements ISet<K>, Iterable<K> {
     if (!this.has(key)) {
       if (this.#showNotFoundMessage) {
         const keyStr = unknownToString(key);
-        console.warn(
-          `ISet.delete: key not found: ${Result.isOk(keyStr) ? keyStr.value : '<error converting key to string>'}`,
-        );
+        console.warn(`ISet.delete: key not found: ${keyStr}`);
       }
       return this;
     }

package/src/functional/optional.mts

@@ -1,5 +1,4 @@
 import { isRecord } from '../guard/index.mjs';
-import { pipe } from './pipe.mjs';
 
 /** @internal String literal tag to identify the 'Some' variant of Optional. */
 const SomeTypeTagName = 'ts-data-forge::Optional.some';
@@ -451,11 +450,12 @@ export namespace Optional {
     switch (args.length) {
       case 2: {
         const [optional, predicate] = args;
-        return isSome(optional)
-          ? pipe(unwrap(optional)).map((value) =>
-              predicate(value) ? some(value) : none,
-            ).value
-          : none;
+        if (isSome(optional)) {
+          const value = unwrap(optional);
+          return predicate(value) ? some(value) : none;
+        }
+        // If the optional is None, return None
+        return none;
       }
 
       case 1: {

package/src/functional/result.mts

@@ -852,9 +852,7 @@ export namespace Result {
         return err(error);
       }
       const msg = unknownToString(error);
-      return isErr(msg)
-        ? err(new Error(String(error)))
-        : err(new Error(msg.value));
+      return err(new Error(msg));
     }
   };
 

package/src/json/json.mts

@@ -73,9 +73,7 @@ export namespace Json {
       );
     } catch (error: unknown) {
       const errStr = unknownToString(error);
-      return Result.err(
-        Result.isOk(errStr) ? errStr.value : 'Failed to parse JSON',
-      );
+      return Result.err(errStr);
     }
   };
 
@@ -128,9 +126,7 @@ export namespace Json {
       return Result.ok(JSON.stringify(value, replacer, space));
     } catch (error) {
       const errStr = unknownToString(error);
-      return Result.err(
-        Result.isOk(errStr) ? errStr.value : 'Failed to stringify JSON',
-      );
+      return Result.err(errStr);
     }
   };
 
@@ -181,9 +177,7 @@ export namespace Json {
       );
     } catch (error) {
       const errStr = unknownToString(error);
-      return Result.err(
-        Result.isOk(errStr) ? errStr.value : 'Failed to stringify JSON',
-      );
+      return Result.err(errStr);
     }
   };