go-go-try 6.0.6 → 6.1.0

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.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,55 +1,55 @@
 {
-  "name": "go-go-try",
-  "version": "6.0.6",
-  "description": "Tries to execute a sync/async function, returns a result tuple",
-  "license": "MIT",
-  "repository": "thelinuxlich/go-go-try",
-  "author": {
-    "name": "Alisson Cavalcante Agiani",
-    "email": "thelinuxlich@gmail.com"
-  },
-  "type": "module",
-  "main": "./dist/index.cjs",
-  "module": "./dist/index.mjs",
-  "types": "./dist/index.d.mts",
-  "exports": {
-    "require": {
-      "types": "./dist/index.d.cts",
-      "default": "./dist/index.cjs"
-    },
-    "import": {
-      "types": "./dist/index.d.mts",
-      "default": "./dist/index.mjs"
-    }
-  },
-  "engines": {
-    "node": ">=16"
-  },
-  "scripts": {
-    "build": "pkgroll",
-    "lint": "biome lint --write src/*.ts",
-    "test": "npm run build && npm run lint && vitest run"
-  },
-  "keywords": [
-    "errors",
-    "try",
-    "catch",
-    "error handling",
-    "nice-try",
-    "good-try",
-    "neverthrow",
-    "ts-result",
-    "effect",
-    "go-go-try",
-    "gotry",
-    "go-try"
-  ],
-  "devDependencies": {
-    "@ark/attest": "^0.46.0",
-    "@biomejs/biome": "^1.9.4",
-    "pkgroll": "^2.12.1",
-    "tsx": "^4.19.3",
-    "typescript": "^5.8.3",
-    "vitest": "^3.1.2"
-  }
+	"name": "go-go-try",
+	"version": "6.1.0",
+	"description": "Tries to execute a sync/async function, returns a result tuple",
+	"license": "MIT",
+	"repository": "thelinuxlich/go-go-try",
+	"author": {
+		"name": "Alisson Cavalcante Agiani",
+		"email": "thelinuxlich@gmail.com"
+	},
+	"type": "module",
+	"main": "./dist/index.cjs",
+	"module": "./dist/index.mjs",
+	"types": "./dist/index.d.mts",
+	"exports": {
+		"require": {
+			"types": "./dist/index.d.cts",
+			"default": "./dist/index.cjs"
+		},
+		"import": {
+			"types": "./dist/index.d.mts",
+			"default": "./dist/index.mjs"
+		}
+	},
+	"engines": {
+		"node": ">=16"
+	},
+	"scripts": {
+		"build": "pkgroll",
+		"lint": "biome lint --write src/*.ts",
+		"test": "npm run build && npm run lint && vitest run"
+	},
+	"keywords": [
+		"errors",
+		"try",
+		"catch",
+		"error handling",
+		"nice-try",
+		"good-try",
+		"neverthrow",
+		"ts-result",
+		"effect",
+		"go-go-try",
+		"gotry",
+		"go-try"
+	],
+	"devDependencies": {
+		"@ark/attest": "^0.46.0",
+		"@biomejs/biome": "^1.9.4",
+		"pkgroll": "^2.12.1",
+		"tsx": "^4.19.3",
+		"typescript": "^5.8.3",
+		"vitest": "^3.1.2"
+	}
 }

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

@@ -5,48 +5,54 @@ export type Result<E, T> = Success<T> | Failure<E>
 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 === 'object' &&
-    error !== null &&
-    'message' in error &&
-    typeof (error as Record<string, unknown>).message === 'string'
-  ) {
-    return (error as { message: string }).message
-  }
+	if (typeof error === 'string') return error
 
-  try {
-    return JSON.stringify(error)
-  } catch {
-    // fallback in case there's an error stringifying the error
-    // with circular references for example.
-    return String(error)
-  }
+	if (
+		typeof error === 'object' &&
+		error !== null &&
+		'message' in error &&
+		typeof (error as Record<string, unknown>).message === 'string'
+	) {
+		return (error as { message: string }).message
+	}
+
+	try {
+		return JSON.stringify(error)
+	} catch {
+		// fallback in case there's an error stringifying the error
+		// with circular references for example.
+		return String(error)
+	}
 }
 
 function isPromise<T>(value: unknown): value is Promise<T> {
-  return (
-    typeof value === 'object' &&
-    value !== null &&
-    'then' in value &&
-    typeof (value as { then: unknown }).then === 'function'
-  )
+	return (
+		typeof value === 'object' &&
+		value !== null &&
+		'then' in value &&
+		typeof (value as { then: unknown }).then === 'function'
+	)
+}
+
+function isError(value: unknown): value is Error {
+	return value instanceof Error
 }
 
 /**
@@ -73,20 +79,20 @@ 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>),
+	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
-    if (isPromise<T>(result)) {
-      return result
-        .then((resolvedValue) => success<T>(resolvedValue))
-        .catch((err) => failure<string>(getErrorMessage(err)))
-    }
-    return success<T>(result)
-  } catch (err) {
-    return failure<string>(getErrorMessage(err))
-  }
+	try {
+		const result =
+			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)))
+		}
+		return success<T>(result)
+	} catch (err) {
+		return failure<string>(getErrorMessage(err))
+	}
 }
 
 /**
@@ -111,23 +117,36 @@ export function goTry<T>(
  * const [err, result] = await goTryRaw(fetch('https://api.example.com/data'));
  */
 export function goTryRaw<T, E = Error>(
-  promise: Promise<T>,
+	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>
 export function goTryRaw<T, E = Error>(
-  value: T | Promise<T> | (() => T | Promise<T>),
+	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
-    if (isPromise<T>(result)) {
-      return result
-        .then((resolvedValue) => success<T>(resolvedValue))
-        .catch((err) => failure<E>(err as E))
-    }
-    return success<T>(result)
-  } catch (err) {
-    return failure<E>(err as E)
-  }
+	try {
+		const result =
+			typeof value === 'function' ? (value as () => T | Promise<T>)() : value
+		if (isPromise<T>(result)) {
+			return result
+				.then((resolvedValue) => success<T>(resolvedValue))
+				.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)
+	} catch (err) {
+		return failure<E>(
+			isError(err)
+				? (err as unknown as E)
+				: (new Error(String(err)) as unknown as E),
+		)
+	}
 }