go-go-try 6.0.5 → 6.1.0

package/README.md

@@ -46,7 +46,7 @@ const [err, todos = []] = await goTry(fetchTodos()) // err is string | undefined
 if (err) sendToErrorTrackingService(err)
 
 // goTry extracts the error message from the error object, if you want the raw error object, use goTryRaw
-const [err, value] = goTryRaw(() => JSON.parse('{/}')) // err will be Error, value will be always T
+const [err, value] = goTryRaw(() => JSON.parse('{/}')) // err is Error | undefined, value is T | undefined
 
 // fetch todos, fallback to empty array, send error to your error tracking service
 const [err, todos = []] = await goTryRaw(fetchTodos()) // err is Error | undefined
@@ -59,11 +59,7 @@ if (err) sendToErrorTrackingService(err)
 
 -   synchronous/asynchronous function / Promise
 
-**Returns** a tuple with the possible error and result (Golang style)
+**Returns** a tuple with the possible error and result as `[Err | undefined, T | undefined]` (Golang style)
 
 
 If you use TypeScript, the types are well defined and won't let you make a mistake.
-
-## Inspiration
-
--   This library started as a fork of [good-try](https://github.com/astoilkov/good-try) but diverged a lot so I decided to rename it

package/dist/index.cjs

@@ -13,6 +13,7 @@ function failure(error) {
   return [error, void 0];
 }
 function getErrorMessage(error) {
+  if (error === void 0) return "undefined";
   if (typeof error === "string") return error;
   if (typeof error === "object" && error !== null && "message" in error && typeof error.message === "string") {
     return error.message;
@@ -26,6 +27,9 @@ function getErrorMessage(error) {
 function isPromise(value) {
   return typeof value === "object" && value !== null && "then" in value && typeof value.then === "function";
 }
+function isError(value) {
+  return value instanceof Error;
+}
 function goTry(value) {
   try {
     const result = typeof value === "function" ? value() : value;
@@ -41,11 +45,20 @@ function goTryRaw(value) {
   try {
     const result = typeof value === "function" ? value() : value;
     if (isPromise(result)) {
-      return result.then((resolvedValue) => success(resolvedValue)).catch((err) => failure(err));
+      return result.then((resolvedValue) => success(resolvedValue)).catch((err) => {
+        if (err === void 0) {
+          return failure(new Error("undefined"));
+        }
+        return failure(
+          isError(err) ? err : new Error(String(err))
+        );
+      });
     }
     return success(result);
   } catch (err) {
-    return failure(err);
+    return failure(
+      isError(err) ? err : new Error(String(err))
+    );
   }
 }
 

package/dist/index.d.cts

@@ -6,9 +6,50 @@ declare function isSuccess<E, T>(result: Result<E, T>): result is Success<T>;
 declare function isFailure<E, T>(result: Result<E, T>): result is Failure<E>;
 declare function success<T>(value: T): Success<T>;
 declare function failure<E>(error: E): Failure<E>;
+/**
+ * Executes a function, promise, or value and returns a Result type.
+ * If an error occurs, it returns a Failure with the error message as a string.
+ *
+ * @template T The type of the successful result
+ * @param {T | Promise<T> | (() => T | Promise<T>)} value - The value, promise, or function to execute
+ * @returns {Result<string, T> | Promise<Result<string, T>>} A Result type or a Promise of a Result type
+ *
+ * @example
+ * // With a value
+ * const [err, result] = goTry(42);
+ *
+ * @example
+ * // With a function
+ * const [err, result] = goTry(() => JSON.parse('{"key": "value"}'));
+ *
+ * @example
+ * // With a promise
+ * const [err, result] = await goTry(fetch('https://api.example.com/data'));
+ */
 declare function goTry<T>(promise: Promise<T>): Promise<Result<string, T>>;
 declare function goTry<T>(fn: () => T): Result<string, T>;
 declare function goTry<T>(value: T): Result<string, T>;
+/**
+ * Executes a function, promise, or value and returns a Result type.
+ * If an error occurs, it returns a Failure with the raw error object.
+ *
+ * @template T The type of the successful result
+ * @template E The type of the error, defaults to Error
+ * @param {T | Promise<T> | (() => T | Promise<T>)} value - The value, promise, or function to execute
+ * @returns {Result<E, T> | Promise<Result<E, T>>} A Result type or a Promise of a Result type
+ *
+ * @example
+ * // With a value
+ * const [err, result] = goTryRaw(42);
+ *
+ * @example
+ * // With a function
+ * const [err, result] = goTryRaw(() => JSON.parse('{"key": "value"}'));
+ *
+ * @example
+ * // With a promise
+ * const [err, result] = await goTryRaw(fetch('https://api.example.com/data'));
+ */
 declare function goTryRaw<T, E = Error>(promise: Promise<T>): Promise<Result<E, T>>;
 declare function goTryRaw<T, E = Error>(fn: () => T): Result<E, T>;
 declare function goTryRaw<T, E = Error>(value: T): Result<E, T>;

package/dist/index.d.mts

@@ -6,9 +6,50 @@ declare function isSuccess<E, T>(result: Result<E, T>): result is Success<T>;
 declare function isFailure<E, T>(result: Result<E, T>): result is Failure<E>;
 declare function success<T>(value: T): Success<T>;
 declare function failure<E>(error: E): Failure<E>;
+/**
+ * Executes a function, promise, or value and returns a Result type.
+ * If an error occurs, it returns a Failure with the error message as a string.
+ *
+ * @template T The type of the successful result
+ * @param {T | Promise<T> | (() => T | Promise<T>)} value - The value, promise, or function to execute
+ * @returns {Result<string, T> | Promise<Result<string, T>>} A Result type or a Promise of a Result type
+ *
+ * @example
+ * // With a value
+ * const [err, result] = goTry(42);
+ *
+ * @example
+ * // With a function
+ * const [err, result] = goTry(() => JSON.parse('{"key": "value"}'));
+ *
+ * @example
+ * // With a promise
+ * const [err, result] = await goTry(fetch('https://api.example.com/data'));
+ */
 declare function goTry<T>(promise: Promise<T>): Promise<Result<string, T>>;
 declare function goTry<T>(fn: () => T): Result<string, T>;
 declare function goTry<T>(value: T): Result<string, T>;
+/**
+ * Executes a function, promise, or value and returns a Result type.
+ * If an error occurs, it returns a Failure with the raw error object.
+ *
+ * @template T The type of the successful result
+ * @template E The type of the error, defaults to Error
+ * @param {T | Promise<T> | (() => T | Promise<T>)} value - The value, promise, or function to execute
+ * @returns {Result<E, T> | Promise<Result<E, T>>} A Result type or a Promise of a Result type
+ *
+ * @example
+ * // With a value
+ * const [err, result] = goTryRaw(42);
+ *
+ * @example
+ * // With a function
+ * const [err, result] = goTryRaw(() => JSON.parse('{"key": "value"}'));
+ *
+ * @example
+ * // With a promise
+ * const [err, result] = await goTryRaw(fetch('https://api.example.com/data'));
+ */
 declare function goTryRaw<T, E = Error>(promise: Promise<T>): Promise<Result<E, T>>;
 declare function goTryRaw<T, E = Error>(fn: () => T): Result<E, T>;
 declare function goTryRaw<T, E = Error>(value: T): Result<E, T>;

package/dist/index.mjs

@@ -11,6 +11,7 @@ function failure(error) {
   return [error, void 0];
 }
 function getErrorMessage(error) {
+  if (error === void 0) return "undefined";
   if (typeof error === "string") return error;
   if (typeof error === "object" && error !== null && "message" in error && typeof error.message === "string") {
     return error.message;
@@ -24,6 +25,9 @@ function getErrorMessage(error) {
 function isPromise(value) {
   return typeof value === "object" && value !== null && "then" in value && typeof value.then === "function";
 }
+function isError(value) {
+  return value instanceof Error;
+}
 function goTry(value) {
   try {
     const result = typeof value === "function" ? value() : value;
@@ -39,11 +43,20 @@ function goTryRaw(value) {
   try {
     const result = typeof value === "function" ? value() : value;
     if (isPromise(result)) {
-      return result.then((resolvedValue) => success(resolvedValue)).catch((err) => failure(err));
+      return result.then((resolvedValue) => success(resolvedValue)).catch((err) => {
+        if (err === void 0) {
+          return failure(new Error("undefined"));
+        }
+        return failure(
+          isError(err) ? err : new Error(String(err))
+        );
+      });
     }
     return success(result);
   } catch (err) {
-    return failure(err);
+    return failure(
+      isError(err) ? err : new Error(String(err))
+    );
   }
 }
 

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "go-go-try",
-	"version": "6.0.5",
+	"version": "6.1.0",
 	"description": "Tries to execute a sync/async function, returns a result tuple",
 	"license": "MIT",
 	"repository": "thelinuxlich/go-go-try",
@@ -37,6 +37,9 @@
 		"error handling",
 		"nice-try",
 		"good-try",
+		"neverthrow",
+		"ts-result",
+		"effect",
 		"go-go-try",
 		"gotry",
 		"go-try"

package/src/index.test.ts

@@ -3,342 +3,368 @@ import { assert, describe, test } from 'vitest'
 import { type Result, goTry, goTryRaw, isFailure, isSuccess } from './index.js'
 
 test(`value returned by callback is used when callback doesn't throw`, async () => {
-  const fn = () => 'value'
-
-  // Test with function
-  const result1 = goTry(fn)
-  const result2 = goTryRaw(fn)
-
-  // Test destructuring
-  const [err1, value] = result1
-  const [err2, value2] = result2
-
-  // Test type guards
-  assert.equal(isSuccess(result1), true)
-  assert.equal(isSuccess(result2), true)
-  assert.equal(isFailure(result1), false)
-  assert.equal(isFailure(result2), false)
-
-  // Test values
-  assert.equal(value, 'value')
-  assert.equal(value2, 'value')
-  assert.equal(err1, undefined)
-  assert.equal(err2, undefined)
+	const fn = () => 'value'
+
+	// Test with function
+	const result1 = goTry(fn)
+	const result2 = goTryRaw(fn)
+
+	// Test destructuring
+	const [err1, value] = result1
+	const [err2, value2] = result2
+
+	// Test type guards
+	assert.equal(isSuccess(result1), true)
+	assert.equal(isSuccess(result2), true)
+	assert.equal(isFailure(result1), false)
+	assert.equal(isFailure(result2), false)
+
+	// Test values
+	assert.equal(value, 'value')
+	assert.equal(value2, 'value')
+	assert.equal(err1, undefined)
+	assert.equal(err2, undefined)
+})
+
+test('if function throws undefined, err should be "undefined"', async () => {
+	const fn = () => {
+		throw undefined
+	}
+
+	// Test with function that throws undefined
+	const result1 = goTry(fn)
+	const result2 = goTryRaw(fn)
+
+	// Test destructuring
+	const [err1, value] = result1
+	const [err2, value2] = result2
+
+	// Test type guards
+	assert.equal(isSuccess(result1), false)
+	assert.equal(isSuccess(result2), false)
+	assert.equal(isFailure(result1), true)
+	assert.equal(isFailure(result2), true)
+
+	// Test values
+	assert.equal(value, undefined)
+	assert.equal(value2, undefined)
+	assert.equal(err1, 'undefined')
+	assert.equal(typeof err2, 'object')
 })
 
 test('if callback throws, value should be undefined and err should contain the error message', async () => {
-  const fn = () => {
-    return JSON.parse('{/') as string
-  }
-
-  // Test with function that throws
-  const result1 = goTry(fn)
-  const result2 = goTryRaw(fn)
-
-  // Test destructuring
-  const [err1, value] = result1
-  const [err2, value2] = result2
-
-  // Test type guards
-  assert.equal(isSuccess(result1), false)
-  assert.equal(isSuccess(result2), false)
-  assert.equal(isFailure(result1), true)
-  assert.equal(isFailure(result2), true)
-
-  // Test values
-  assert.equal(value, undefined)
-  assert.equal(value2, undefined)
-  assert.equal(typeof err1, 'string')
-  assert.equal(typeof err2, 'object')
-  assert.equal(typeof err2?.message, 'string')
+	const fn = () => {
+		return JSON.parse('{/') as string
+	}
+
+	// Test with function that throws
+	const result1 = goTry(fn)
+	const result2 = goTryRaw(fn)
+
+	// Test destructuring
+	const [err1, value] = result1
+	const [err2, value2] = result2
+
+	// Test type guards
+	assert.equal(isSuccess(result1), false)
+	assert.equal(isSuccess(result2), false)
+	assert.equal(isFailure(result1), true)
+	assert.equal(isFailure(result2), true)
+
+	// Test values
+	assert.equal(value, undefined)
+	assert.equal(value2, undefined)
+	assert.equal(typeof err1, 'string')
+	assert.equal(typeof err2, 'object')
+	assert.equal(typeof err2?.message, 'string')
 })
 
 test('first parameter accepts promises and makes the function async', async () => {
-  const promise = Promise.resolve('value')
-
-  // Test with promise
-  const result1 = await goTry(promise)
-  const result2 = await goTryRaw(promise)
-
-  // Test destructuring
-  const [err1, value] = result1
-  const [err2, value2] = result2
-
-  // Test type guards
-  assert.equal(isSuccess(result1), true)
-  assert.equal(isSuccess(result2), true)
-  assert.equal(isFailure(result1), false)
-  assert.equal(isFailure(result2), false)
-
-  // Test values
-  assert.equal(value, 'value')
-  assert.equal(value2, 'value')
-  assert.equal(err1, undefined)
-  assert.equal(err2, undefined)
+	const promise = Promise.resolve('value')
+
+	// Test with promise
+	const result1 = await goTry(promise)
+	const result2 = await goTryRaw(promise)
+
+	// Test destructuring
+	const [err1, value] = result1
+	const [err2, value2] = result2
+
+	// Test type guards
+	assert.equal(isSuccess(result1), true)
+	assert.equal(isSuccess(result2), true)
+	assert.equal(isFailure(result1), false)
+	assert.equal(isFailure(result2), false)
+
+	// Test values
+	assert.equal(value, 'value')
+	assert.equal(value2, 'value')
+	assert.equal(err1, undefined)
+	assert.equal(err2, undefined)
 })
 
 test('if async callback throws, value should be undefined and err should contain the error message', async () => {
-  const promise = Promise.reject(new Error('error'))
-
-  // Test with promise that rejects
-  const result1 = await goTry(promise)
-  const result2 = await goTryRaw<Error>(promise)
-
-  // Test destructuring
-  const [err, value] = result1
-  const [err2, value2] = result2
-
-  // Test type guards
-  assert.equal(isSuccess(result1), false)
-  assert.equal(isSuccess(result2), false)
-  assert.equal(isFailure(result1), true)
-  assert.equal(isFailure(result2), true)
-
-  // Test values
-  assert.equal(value, undefined)
-  assert.equal(value2, undefined)
-  assert.equal(err, 'error')
-  assert.equal(typeof err2, 'object')
-  assert.equal(err2?.message, 'error')
+	const promise = Promise.reject(new Error('error'))
+
+	// Test with promise that rejects
+	const result1 = await goTry(promise)
+	const result2 = await goTryRaw<Error>(promise)
+
+	// Test destructuring
+	const [err, value] = result1
+	const [err2, value2] = result2
+
+	// Test type guards
+	assert.equal(isSuccess(result1), false)
+	assert.equal(isSuccess(result2), false)
+	assert.equal(isFailure(result1), true)
+	assert.equal(isFailure(result2), true)
+
+	// Test values
+	assert.equal(value, undefined)
+	assert.equal(value2, undefined)
+	assert.equal(err, 'error')
+	assert.equal(typeof err2, 'object')
+	assert.equal(err2?.message, 'error')
 })
 
 test('direct values work too', () => {
-  // Test with direct value
-  const result1 = goTry('value')
-  const result2 = goTryRaw('value')
-
-  // Test destructuring
-  const [err1, value] = result1
-  const [err2, value2] = result2
-
-  // Test values
-  assert.equal(value, 'value')
-  assert.equal(value2, 'value')
-  assert.equal(err1, undefined)
-  assert.equal(err2, undefined)
+	// Test with direct value
+	const result1 = goTry('value')
+	const result2 = goTryRaw('value')
+
+	// Test destructuring
+	const [err1, value] = result1
+	const [err2, value2] = result2
+
+	// Test values
+	assert.equal(value, 'value')
+	assert.equal(value2, 'value')
+	assert.equal(err1, undefined)
+	assert.equal(err2, undefined)
 })
 
 test('async functions work correctly', async () => {
-  // Define an async function
-  function asyncFn() {
-    return Promise.resolve(42)
-  }
-
-  // Test with async function
-  const result1 = await goTry(asyncFn())
-  const result2 = await goTryRaw(asyncFn())
-
-  // Test destructuring
-  const [err1, value] = result1
-  const [err2, value2] = result2
-
-  // Test values
-  assert.equal(value, 42)
-  assert.equal(value2, 42)
-  assert.equal(err1, undefined)
-  assert.equal(err2, undefined)
+	// Define an async function
+	function asyncFn() {
+		return Promise.resolve(42)
+	}
+
+	// Test with async function
+	const result1 = await goTry(asyncFn())
+	const result2 = await goTryRaw(asyncFn())
+
+	// Test destructuring
+	const [err1, value] = result1
+	const [err2, value2] = result2
+
+	// Test values
+	assert.equal(value, 42)
+	assert.equal(value2, 42)
+	assert.equal(err1, undefined)
+	assert.equal(err2, undefined)
 })
 
 test('async functions that throw work correctly', async () => {
-  // Define an async function that throws
-  async function asyncFnThatThrows() {
-    await 1
-    throw new Error('async error')
-  }
-
-  // Test with async function that throws
-  const result1 = await goTry(asyncFnThatThrows())
-  const result2 = await goTryRaw(asyncFnThatThrows())
-
-  // Test destructuring
-  const [err1, value] = result1
-  const [err2, value2] = result2
-
-  // Test values
-  assert.equal(value, undefined)
-  assert.equal(value2, undefined)
-  assert.equal(err1, 'async error')
-  assert.equal(typeof err2, 'object')
-  assert.equal(err2?.message, 'async error')
+	// Define an async function that throws
+	async function asyncFnThatThrows() {
+		await 1
+		throw new Error('async error')
+	}
+
+	// Test with async function that throws
+	const result1 = await goTry(asyncFnThatThrows())
+	const result2 = await goTryRaw(asyncFnThatThrows())
+
+	// Test destructuring
+	const [err1, value] = result1
+	const [err2, value2] = result2
+
+	// Test values
+	assert.equal(value, undefined)
+	assert.equal(value2, undefined)
+	assert.equal(err1, 'async error')
+	assert.equal(typeof err2, 'object')
+	assert.equal(err2?.message, 'async error')
 })
 
 describe('goTry type tests', () => {
-  test('synchronous function returns correct types', () => {
-    const fn = () => 'value'
-    const result = goTry(fn)
-
-    // Check the result type
-    attest<Result<string, string>>(result)
-
-    // Check the destructured types
-    const [err, value] = result
-    attest<string | undefined>(err)
-    attest<string | undefined>(value)
-
-    // When destructured, the types should be narrowed correctly
-    if (err === undefined) {
-      attest<string>(value)
-    } else {
-      attest<undefined>(value)
-    }
-  })
-
-  test('direct value returns correct types', () => {
-    const result = goTry('value')
-
-    // Check the result type
-    attest<Result<string, string>>(result)
-
-    // Check the destructured types
-    const [err, value] = result
-    attest<string | undefined>(err)
-    attest<string | undefined>(value)
-
-    // When destructured, the types should be narrowed correctly
-    if (err === undefined) {
-      attest<string>(value)
-    } else {
-      attest<undefined>(value)
-    }
-  })
-
-  test('promise returns correct types', async () => {
-    const promise = Promise.resolve('value')
-    const result = await goTry(promise)
-
-    // Check the result type
-    attest<Result<string, string>>(result)
-
-    // Check the destructured types
-    const [err, value] = result
-    attest<string | undefined>(err)
-    attest<string | undefined>(value)
-
-    // When destructured, the types should be narrowed correctly
-    if (err === undefined) {
-      attest<string>(value)
-    } else {
-      attest<undefined>(value)
-    }
-  })
-
-  test('async function returns correct types', async () => {
-    const asyncFn = async () => 'value'
-    const result = await goTry(asyncFn())
-
-    // Check the result type
-    attest<Result<string, string>>(result)
-
-    // Check the destructured types
-    const [err, value] = result
-    attest<string | undefined>(err)
-    attest<string | undefined>(value)
-
-    // When destructured, the types should be narrowed correctly
-    if (err === undefined) {
-      attest<string>(value)
-    } else {
-      attest<undefined>(value)
-    }
-  })
+	test('synchronous function returns correct types', () => {
+		const fn = () => 'value'
+		const result = goTry(fn)
+
+		// Check the result type
+		attest<Result<string, string>>(result)
+
+		// Check the destructured types
+		const [err, value] = result
+		attest<string | undefined>(err)
+		attest<string | undefined>(value)
+
+		// When destructured, the types should be narrowed correctly
+		if (err === undefined) {
+			attest<string>(value)
+		} else {
+			attest<undefined>(value)
+		}
+	})
+
+	test('direct value returns correct types', () => {
+		const result = goTry('value')
+
+		// Check the result type
+		attest<Result<string, string>>(result)
+
+		// Check the destructured types
+		const [err, value] = result
+		attest<string | undefined>(err)
+		attest<string | undefined>(value)
+
+		// When destructured, the types should be narrowed correctly
+		if (err === undefined) {
+			attest<string>(value)
+		} else {
+			attest<undefined>(value)
+		}
+	})
+
+	test('promise returns correct types', async () => {
+		const promise = Promise.resolve('value')
+		const result = await goTry(promise)
+
+		// Check the result type
+		attest<Result<string, string>>(result)
+
+		// Check the destructured types
+		const [err, value] = result
+		attest<string | undefined>(err)
+		attest<string | undefined>(value)
+
+		// When destructured, the types should be narrowed correctly
+		if (err === undefined) {
+			attest<string>(value)
+		} else {
+			attest<undefined>(value)
+		}
+	})
+
+	test('async function returns correct types', async () => {
+		const asyncFn = async () => 'value'
+		const result = await goTry(asyncFn())
+
+		// Check the result type
+		attest<Result<string, string>>(result)
+
+		// Check the destructured types
+		const [err, value] = result
+		attest<string | undefined>(err)
+		attest<string | undefined>(value)
+
+		// When destructured, the types should be narrowed correctly
+		if (err === undefined) {
+			attest<string>(value)
+		} else {
+			attest<undefined>(value)
+		}
+	})
 })
 
 describe('goTryRaw type tests', () => {
-  test('type inference works correctly', () => {
-    const fn = () => 'value'
-    const result = goTryRaw(fn)
-
-    // Check the result type
-    attest<Result<Error, string>>(result)
-
-    // Check the destructured types
-    const [err, value] = result
-    attest<Error | undefined>(err)
-    attest<string | undefined>(value)
-
-    // When destructured, the types should be narrowed correctly
-    if (err === undefined) {
-      attest<string>(value)
-    } else {
-      attest<undefined>(value)
-    }
-  })
-  test('synchronous function returns correct types', () => {
-    const fn = () => 'value'
-    const result = goTryRaw(fn)
-
-    // Check the result type
-    attest<Result<Error, string>>(result)
-
-    // Check the destructured types
-    const [err, value] = result
-    attest<Error | undefined>(err)
-    attest<string | undefined>(value)
-
-    // When destructured, the types should be narrowed correctly
-    if (err === undefined) {
-      attest<string>(value)
-    } else {
-      attest<undefined>(value)
-    }
-  })
-
-  test('direct value returns correct types', () => {
-    const result = goTryRaw('value')
-
-    // Check the result type
-    attest<Result<Error, string>>(result)
-
-    // Check the destructured types
-    const [err, value] = result
-    attest<Error | undefined>(err)
-    attest<string | undefined>(value)
-
-    // When destructured, the types should be narrowed correctly
-    if (err === undefined) {
-      attest<string>(value)
-    } else {
-      attest<undefined>(value)
-    }
-  })
-
-  test('promise returns correct types', async () => {
-    const promise = Promise.resolve('value')
-    const result = await goTryRaw(promise)
-
-    // Check the result type
-    attest<Result<Error, string>>(result)
-
-    // Check the destructured types
-    const [err, value] = result
-    attest<Error | undefined>(err)
-    attest<string | undefined>(value)
-
-    // When destructured, the types should be narrowed correctly
-    if (err === undefined) {
-      attest<string>(value)
-    } else {
-      attest<undefined>(value)
-    }
-  })
-
-  test('async function returns correct types', async () => {
-    const asyncFn = async () => 'value'
-    const result = await goTryRaw(asyncFn())
-
-    // Check the result type
-    attest<Result<Error, string>>(result)
-
-    // Check the destructured types
-    const [err, value] = result
-    attest<Error | undefined>(err)
-    attest<string | undefined>(value)
-
-    // When destructured, the types should be narrowed correctly
-    if (err === undefined) {
-      attest<string>(value)
-    } else {
-      attest<undefined>(value)
-    }
-  })
+	test('type inference works correctly', () => {
+		const fn = () => 'value'
+		const result = goTryRaw(fn)
+
+		// Check the result type
+		attest<Result<Error, string>>(result)
+
+		// Check the destructured types
+		const [err, value] = result
+		attest<Error | undefined>(err)
+		attest<string | undefined>(value)
+
+		// When destructured, the types should be narrowed correctly
+		if (err === undefined) {
+			attest<string>(value)
+		} else {
+			attest<undefined>(value)
+		}
+	})
+	test('synchronous function returns correct types', () => {
+		const fn = () => 'value'
+		const result = goTryRaw(fn)
+
+		// Check the result type
+		attest<Result<Error, string>>(result)
+
+		// Check the destructured types
+		const [err, value] = result
+		attest<Error | undefined>(err)
+		attest<string | undefined>(value)
+
+		// When destructured, the types should be narrowed correctly
+		if (err === undefined) {
+			attest<string>(value)
+		} else {
+			attest<undefined>(value)
+		}
+	})
+
+	test('direct value returns correct types', () => {
+		const result = goTryRaw('value')
+
+		// Check the result type
+		attest<Result<Error, string>>(result)
+
+		// Check the destructured types
+		const [err, value] = result
+		attest<Error | undefined>(err)
+		attest<string | undefined>(value)
+
+		// When destructured, the types should be narrowed correctly
+		if (err === undefined) {
+			attest<string>(value)
+		} else {
+			attest<undefined>(value)
+		}
+	})
+
+	test('promise returns correct types', async () => {
+		const promise = Promise.resolve('value')
+		const result = await goTryRaw(promise)
+
+		// Check the result type
+		attest<Result<Error, string>>(result)
+
+		// Check the destructured types
+		const [err, value] = result
+		attest<Error | undefined>(err)
+		attest<string | undefined>(value)
+
+		// When destructured, the types should be narrowed correctly
+		if (err === undefined) {
+			attest<string>(value)
+		} else {
+			attest<undefined>(value)
+		}
+	})
+
+	test('async function returns correct types', async () => {
+		const asyncFn = async () => 'value'
+		const result = await goTryRaw(asyncFn())
+
+		// Check the result type
+		attest<Result<Error, string>>(result)
+
+		// Check the destructured types
+		const [err, value] = result
+		attest<Error | undefined>(err)
+		attest<string | undefined>(value)
+
+		// When destructured, the types should be narrowed correctly
+		if (err === undefined) {
+			attest<string>(value)
+		} else {
+			attest<undefined>(value)
+		}
+	})
 })

package/src/index.ts

@@ -1,92 +1,152 @@
-export type Success<T> = readonly [undefined, T];
-export type Failure<E> = readonly [E, undefined];
-export type Result<E, T> = Success<T> | Failure<E>;
+export type Success<T> = readonly [undefined, T]
+export type Failure<E> = readonly [E, undefined]
+export type Result<E, T> = Success<T> | Failure<E>
 
-export type MaybePromise<T> = T | Promise<T>;
+export type MaybePromise<T> = T | Promise<T>
 
 export function isSuccess<E, T>(result: Result<E, T>): result is Success<T> {
-	return result[0] === undefined;
+	return result[0] === undefined
 }
 export function isFailure<E, T>(result: Result<E, T>): result is Failure<E> {
-	return result[0] !== undefined;
+	return result[0] !== undefined
 }
 
 export function success<T>(value: T): Success<T> {
-	return [undefined, value] as const;
+	return [undefined, value] as const
 }
 
 export function failure<E>(error: E): Failure<E> {
-	return [error, undefined] as const;
+	return [error, undefined] as const
 }
 
 function getErrorMessage(error: unknown): string {
-	if (typeof error === "string") return error;
+	if (error === undefined) return 'undefined'
+
+	if (typeof error === 'string') return error
 
 	if (
-		typeof error === "object" &&
+		typeof error === 'object' &&
 		error !== null &&
-		"message" in error &&
-		typeof (error as Record<string, unknown>).message === "string"
+		'message' in error &&
+		typeof (error as Record<string, unknown>).message === 'string'
 	) {
-		return (error as { message: string }).message;
+		return (error as { message: string }).message
 	}
 
 	try {
-		return JSON.stringify(error);
+		return JSON.stringify(error)
 	} catch {
 		// fallback in case there's an error stringifying the error
 		// with circular references for example.
-		return String(error);
+		return String(error)
 	}
 }
 
 function isPromise<T>(value: unknown): value is Promise<T> {
 	return (
-		typeof value === "object" &&
+		typeof value === 'object' &&
 		value !== null &&
-		"then" in value &&
-		typeof (value as { then: unknown }).then === "function"
-	);
+		'then' in value &&
+		typeof (value as { then: unknown }).then === 'function'
+	)
+}
+
+function isError(value: unknown): value is Error {
+	return value instanceof Error
 }
 
-export function goTry<T>(promise: Promise<T>): Promise<Result<string, T>>;
-export function goTry<T>(fn: () => T): Result<string, T>;
-export function goTry<T>(value: T): Result<string, T>;
+/**
+ * Executes a function, promise, or value and returns a Result type.
+ * If an error occurs, it returns a Failure with the error message as a string.
+ *
+ * @template T The type of the successful result
+ * @param {T | Promise<T> | (() => T | Promise<T>)} value - The value, promise, or function to execute
+ * @returns {Result<string, T> | Promise<Result<string, T>>} A Result type or a Promise of a Result type
+ *
+ * @example
+ * // With a value
+ * const [err, result] = goTry(42);
+ *
+ * @example
+ * // With a function
+ * const [err, result] = goTry(() => JSON.parse('{"key": "value"}'));
+ *
+ * @example
+ * // With a promise
+ * const [err, result] = await goTry(fetch('https://api.example.com/data'));
+ */
+export function goTry<T>(promise: Promise<T>): Promise<Result<string, T>>
+export function goTry<T>(fn: () => T): Result<string, T>
+export function goTry<T>(value: T): Result<string, T>
 export function goTry<T>(
 	value: T | Promise<T> | (() => T | Promise<T>),
 ): Result<string, T> | Promise<Result<string, T>> {
 	try {
 		const result =
-			typeof value === "function" ? (value as () => T | Promise<T>)() : value;
+			typeof value === 'function' ? (value as () => T | Promise<T>)() : value
 		if (isPromise<T>(result)) {
 			return result
 				.then((resolvedValue) => success<T>(resolvedValue))
-				.catch((err) => failure<string>(getErrorMessage(err)));
+				.catch((err) => failure<string>(getErrorMessage(err)))
 		}
-		return success<T>(result);
+		return success<T>(result)
 	} catch (err) {
-		return failure<string>(getErrorMessage(err));
+		return failure<string>(getErrorMessage(err))
 	}
 }
 
+/**
+ * Executes a function, promise, or value and returns a Result type.
+ * If an error occurs, it returns a Failure with the raw error object.
+ *
+ * @template T The type of the successful result
+ * @template E The type of the error, defaults to Error
+ * @param {T | Promise<T> | (() => T | Promise<T>)} value - The value, promise, or function to execute
+ * @returns {Result<E, T> | Promise<Result<E, T>>} A Result type or a Promise of a Result type
+ *
+ * @example
+ * // With a value
+ * const [err, result] = goTryRaw(42);
+ *
+ * @example
+ * // With a function
+ * const [err, result] = goTryRaw(() => JSON.parse('{"key": "value"}'));
+ *
+ * @example
+ * // With a promise
+ * const [err, result] = await goTryRaw(fetch('https://api.example.com/data'));
+ */
 export function goTryRaw<T, E = Error>(
 	promise: Promise<T>,
-): Promise<Result<E, T>>;
-export function goTryRaw<T, E = Error>(fn: () => T): Result<E, T>;
-export function goTryRaw<T, E = Error>(value: T): Result<E, T>;
+): Promise<Result<E, T>>
+export function goTryRaw<T, E = Error>(fn: () => T): Result<E, T>
+export function goTryRaw<T, E = Error>(value: T): Result<E, T>
 export function goTryRaw<T, E = Error>(
 	value: T | Promise<T> | (() => T | Promise<T>),
 ): Result<E, T> | Promise<Result<E, T>> {
 	try {
 		const result =
-			typeof value === "function" ? (value as () => T | Promise<T>)() : value;
+			typeof value === 'function' ? (value as () => T | Promise<T>)() : value
 		if (isPromise<T>(result)) {
 			return result
 				.then((resolvedValue) => success<T>(resolvedValue))
-				.catch((err) => failure<E>(err as E));
+				.catch((err) => {
+					if (err === undefined) {
+						return failure<E>(new Error('undefined') as unknown as E)
+					}
+					return failure<E>(
+						isError(err)
+							? (err as unknown as E)
+							: (new Error(String(err)) as unknown as E),
+					)
+				})
 		}
-		return success<T>(result);
+		return success<T>(result)
 	} catch (err) {
-		return failure<E>(err as E);
+		return failure<E>(
+			isError(err)
+				? (err as unknown as E)
+				: (new Error(String(err)) as unknown as E),
+		)
 	}
 }